/**
* Create an ImageRenderInfo object based on inline image data. This is nowhere near completely thought through
* and really just acts as a placeholder.
* @param ctm the coordinate transformation matrix at the time the image is rendered
* @param imageObject the image object representing the inline image
* @return the ImageRenderInfo representing the rendered embedded image
* @since 5.0.1
*/
protected internal static ImageRenderInfo CreateForEmbeddedImage(GraphicsState gs, InlineImageInfo inlineImageInfo, PdfDictionary colorSpaceDictionary)
{
ImageRenderInfo renderInfo = new ImageRenderInfo(gs, inlineImageInfo, colorSpaceDictionary);
return(renderInfo);
}
public void RenderImage(ImageRenderInfo renderInfo)
{
}
/**
*
* @param renderInfo
* @return true if the image render operation should be performed
*/
public virtual bool AllowImage(ImageRenderInfo renderInfo){
return true;
}
virtual public void RenderImage(ImageRenderInfo renderInfo)
{
deleg.RenderImage(renderInfo);
}
//*
// * no-op method - this renderer isn't interested in image events
// * @see com.itextpdf.text.pdf.parser.RenderListener#renderImage(com.itextpdf.text.pdf.parser.ImageRenderInfo)
// * @since 5.0.1
//
public void RenderImage(ImageRenderInfo renderInfo)
{
// do nothing
}
public void RenderImage(ImageRenderInfo renderInfo)
{
PdfImageObject image = renderInfo.GetImage();
var v = PdfName.FILTER;
//PdfArray array = new PdfArray();
//array.Add(PdfName.FLATEDECODE);
//array.Add(PdfName.DCTDECODE);
//imgStream.put(PdfName.FILTER, array);
//PdfName filter = (PdfName)image.Get(PdfName.FILTER);
PdfName filter = (PdfName)image.Get(PdfName.FIRST);
int width = Convert.ToInt32(image.Get(PdfName.WIDTH).ToString());
int bitsPerComponent = Convert.ToInt32(image.Get(PdfName.BITSPERCOMPONENT).ToString());
string subtype = image.Get(PdfName.SUBTYPE).ToString();
int height = Convert.ToInt32(image.Get(PdfName.HEIGHT).ToString());
int length = Convert.ToInt32(image.Get(PdfName.LENGTH).ToString());
string colorSpace = image.Get(PdfName.COLORSPACE).ToString();
/* It appears to be safe to assume that when filter == null, PdfImageObject
* does not know how to decode the image to a System.Drawing.Image.
*
* Uncomment the code above to verify, but when I've seen this happen,
* width, height and bits per component all equal zero as well. */
//if (filter != null)
//{
Image drawingImage = image.GetDrawingImage();
string extension = PdfImageObject.ImageBytesType.JPG.FileExtension;
//if (filter == PdfName.DCTDECODE)
//{
// extension += PdfImageObject.ImageBytesType.JPG.FileExtension;
//}
//else if (filter == PdfName.JPXDECODE)
//{
// extension += PdfImageObject.ImageBytesType.JP2.FileExtension;
//}
//else if (filter == PdfName.FLATEDECODE)
//{
// extension += PdfImageObject.ImageBytesType.PNG.FileExtension;
//}
//else if (filter == PdfName.LZWDECODE)
//{
// extension += PdfImageObject.ImageBytesType.CCITT.FileExtension;
//}
/* Rather than struggle with the image stream and try to figure out how to handle
* BitMapData scan lines in various formats (like virtually every sample I've found
* online), use the PdfImageObject.GetDrawingImage() method, which does the work for us. */
try
{
var pages = Program.NumberOfPagesPdf(Program.FilePhth);
this.Images.Add(drawingImage, extension);
string filename = @"C:\Images\" + pages + "\\";
bool exists = System.IO.Directory.Exists(filename);
PdfImageExtractor.increment++;
if (!exists)
{
System.IO.Directory.CreateDirectory(filename);
}
if (PdfImageExtractor.increment <= pages)
{
string fullName2 = filename + "im" + PdfImageExtractor.increment + ".JPG";
byte[] byteArray = Encoding.UTF8.GetBytes(fullName2);
MemoryStream stream = new MemoryStream();
drawingImage.Save(stream, drawingImage.RawFormat);
drawingImage.Save(fullName2, ImageFormat.Gif);
if (Program.invoice.images1.Any(m => m.ImageName == fullName2))
{
}
else
{
//sparar bilden till modellen
Program.invoice.images1.Add(new Models.Images()
{
ImageName = fullName2,
ImageData = stream.ToArray()
});
}
}
}
catch (IOException e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// Converts the Matrix containing the coordinates of an image as stored
/// in an ImageRenderInfo object into a Rectangle.
/// </summary>
/// <param name="imageRenderInfo">Object that contains info about an image</param>
/// <returns>coordinates in the form of a Rectangle object</returns>
private static Rectangle GetRectangle(ImageRenderInfo imageRenderInfo)
{
Matrix ctm = imageRenderInfo.GetImageCTM();
return(new Rectangle(ctm[6], ctm[7], ctm[6] + ctm[0], ctm[7] + ctm[4]));
}
/**
* Create an ImageRenderInfo object based on inline image data. This is nowhere near completely thought through
* and really just acts as a placeholder.
* @param ctm the coordinate transformation matrix at the time the image is rendered
* @param imageObject the image object representing the inline image
* @return the ImageRenderInfo representing the rendered embedded image
* @since 5.0.1
*/
protected internal static ImageRenderInfo CreateForEmbeddedImage(Matrix ctm, InlineImageInfo inlineImageInfo, PdfDictionary colorSpaceDictionary) {
ImageRenderInfo renderInfo = new ImageRenderInfo(ctm, inlineImageInfo, colorSpaceDictionary);
return renderInfo;
}
public void RenderImage(ImageRenderInfo renderInfo)
{
throw new NotImplementedException();
}
private bool ExtractImageOLD(String pdfFile, string imgPath, ProgressBar progressBar1)
{
bool ret = true;
int imgNo = 1;
// string pdfFile=@"F:\gheyret\kitablar\Matitey we anarqiz pajiesi.pdf";
// string imgPath=@"F:\gheyret\kitab_suret\Hazirqi Zaman Uyghur Tili Gramatikisi\";
string imgname = System.IO.Path.GetFileNameWithoutExtension(pdfFile);
progressBar1.Visible = true;
progressBar1.Minimum = 1;
try{
PdfDictionary pg, tg;
PdfDictionary res;
PdfDictionary xobj;
PdfImageObject pdfimage;
PdfObject lpdfobjW;
PdfObject lpdfobjH;
ImageRenderInfo imgRI;
string width, height;
int pageRotation;
PdfReader pdfReader = new PdfReader(pdfFile);
progressBar1.Maximum = pdfReader.NumberOfPages;
for (int pageNumber = 1; pageNumber <= pdfReader.NumberOfPages; pageNumber++)
{
// if(gStop) break;
// pg = pdfReader.GetPageN(pageNumber);
pg = pdfReader.GetPageNRelease(pageNumber);
res = (PdfDictionary)PdfReader.GetPdfObject(pg.Get(PdfName.RESOURCES));
xobj = (PdfDictionary)PdfReader.GetPdfObject(res.Get(PdfName.XOBJECT));
imgNo = 1;
pageRotation = pdfReader.GetPageRotation(pageNumber);
foreach (PdfName name in xobj.Keys)
{
PdfObject obj = xobj.Get(name);
if (obj.IsIndirect())
{
tg = (PdfDictionary)PdfReader.GetPdfObject(obj);
lpdfobjW = tg.Get(PdfName.WIDTH);
lpdfobjH = tg.Get(PdfName.HEIGHT);
if (lpdfobjW != null && lpdfobjH != null)
{
width = lpdfobjW.ToString();
height = lpdfobjH.ToString();
// imgRI = ImageRenderInfo.CreateForXObject(new Matrix(float.Parse(width), float.Parse(height)), (PRIndirectReference)obj, tg);
imgRI = ImageRenderInfo.CreateForXObject(new GraphicsState(), (PRIndirectReference)obj, tg);
pdfimage = imgRI.GetImage();
ExtractImageOLD(pdfimage, imgPath + "\\" + imgname + pageNumber.ToString("_000") + "_" + imgNo + ".png", pageRotation);
imgNo++;
}
}
}
progressBar1.Value = pageNumber;
Application.DoEvents();
}
pdfReader.Close();
}
catch (Exception ee) {
// MessageBox.Show(ee.Message,"Xataliq koruldi");
System.Diagnostics.Debug.WriteLine(ee.StackTrace);
ret = false;
}
progressBar1.Visible = false;
return(ret);
}
internal FilteredImageKey(ImageRenderInfo imageInfo, IList <Rectangle> cleanedAreas)
{
this.image = imageInfo;
this.cleanedAreas = cleanedAreas;
}
public void RenderImage(ImageRenderInfo renderInfo) => Buffer.Add(renderInfo.GetImage());
/// <summary>Filter an ImageRenderInfo object</summary>
/// <param name="image">the ImageRenderInfo object to be filtered</param>
public virtual PdfCleanUpFilter.FilterResult <ImageData> FilterImage(ImageRenderInfo image)
{
return(FilterImage(image, GetImageAreasToBeCleaned(image)));
}
internal virtual FilteredImagesCache.FilteredImageKey CreateFilteredImageKey(ImageRenderInfo image, PdfDocument
document)
{
return(FilteredImagesCache.CreateFilteredImageKey(image, GetImageAreasToBeCleaned(image), document));
}
private bool GetCheckboxState(ImageRenderInfo renderInfo)
{
var n = renderInfo.GetRef().Number;
return(n == 21); // MagicNumberOfYesCheckboxImage;
}
public override bool AllowImage(ImageRenderInfo renderInfo)
{
throw new NotImplementedException();
}
public void RenderImage(ImageRenderInfo renderInfo)
{
this.m_CurrentCheckboxBox.CheckboxStates.Add(this.GetCheckboxState(renderInfo));
}
public void OCRPdf(bool rotate, string docPath, ref Documents doc)
{
PdfReader pdfReader = new PdfReader(docPath);
int totalPage = pdfReader.NumberOfPages;
Console.WriteLine("Pdf file {0} contains {1} pages...", docPath, totalPage);
List <int> pageNos = new List <int>();
for (int i = 1; i <= totalPage; i++)
{
if (!doc.DocBodyDic.ContainsKey(i))
{
pageNos.Add(i);
}
}
foreach (int pageNumber in pageNos)
{
try
{
Console.WriteLine("Working on page {0}...", pageNumber);
PdfReader pdf = new PdfReader(docPath);
PdfDictionary pg = pdf.GetPageN(pageNumber);
PdfDictionary res = (PdfDictionary)PdfReader.GetPdfObject(pg.Get(PdfName.RESOURCES));
PdfDictionary xobj = (PdfDictionary)PdfReader.GetPdfObject(res.Get(PdfName.XOBJECT));
foreach (PdfName name in xobj.Keys)
{
PdfObject obj = xobj.Get(name);
if (obj.IsIndirect())
{
PdfDictionary tg = (PdfDictionary)PdfReader.GetPdfObject(obj);
string width = tg.Get(PdfName.WIDTH).ToString();
float widthValue = float.Parse(width);
string height = tg.Get(PdfName.HEIGHT).ToString();
float heightValue = -1;
bool isDigit = float.TryParse(height, out heightValue);
heightValue = isDigit ? heightValue : widthValue;
if (heightValue < 100 || widthValue < 100)
{
continue;
}
ImageRenderInfo imgRI = ImageRenderInfo.CreateForXObject(new Matrix(float.Parse(width), heightValue), (PRIndirectReference)obj, tg);
PdfImageObject image = imgRI.GetImage();
string imageFileName = string.Empty;
using (Image dotnetImg = image.GetDrawingImage())
{
if (dotnetImg != null)
{
using (MemoryStream ms = new MemoryStream())
{
dotnetImg.Save(ms, ImageFormat.Jpeg);
}
}
string ocrFolder = string.Format("{0}\\{1}", this.localDirectory, Path.GetFileNameWithoutExtension(docPath));
if (!Directory.Exists(ocrFolder))
{
Directory.CreateDirectory(ocrFolder);
}
imageFileName = string.Format("{0}\\{1}\\Page_{2}.jpg", localDirectory, Path.GetFileNameWithoutExtension(docPath), pageNumber);
dotnetImg.Save(imageFileName);
}
//string text = RunOCRCommand(imageFileName);
string text = RetryText(imageFileName);
if ((!doc.DocBodyDic.ContainsKey(pageNumber)) && (!string.IsNullOrEmpty(text)))
{
doc.DocBodyDic.Add(pageNumber, text);
}
else
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Page {0} could read...", pageNumber);
Console.ResetColor();
}
}
}
}
catch (Exception ex)
{
}
}
pdfReader.Close();
}
/// <summary>
/// Creates an ImageItem based on an ImageRenderInfo object.
/// </summary>
/// <param name="imageRenderInfo">Object containing info about an image</param>
public ImageItem(ImageRenderInfo imageRenderInfo) : base()
{
rectangle = GetRectangle(imageRenderInfo);
color = IMG_COLOR;
}
/**
* @return null if the image is not allowed (either it is fully covered or ctm == null).
* List of covered image areas otherwise.
*/
private IList <Rectangle> GetImageAreasToBeCleaned(ImageRenderInfo renderInfo)
{
return(filter.GetCoveredAreas(renderInfo));
}
/**
*
* @param renderInfo
* @return true if the image render operation should be performed
*/
public virtual bool AllowImage(ImageRenderInfo renderInfo)
{
return(true);
}
/**
* Create an ImageRenderInfo object based on inline image data. This is nowhere near completely thought through
* and really just acts as a placeholder.
* @param ctm the coordinate transformation matrix at the time the image is rendered
* @param imageObject the image object representing the inline image
* @return the ImageRenderInfo representing the rendered embedded image
* @since 5.0.1
*/
protected internal static ImageRenderInfo CreateForEmbeddedImage(GraphicsState gs, InlineImageInfo inlineImageInfo, PdfDictionary colorSpaceDictionary)
{
ImageRenderInfo renderInfo = new ImageRenderInfo(gs, inlineImageInfo, colorSpaceDictionary);
return renderInfo;
}
public virtual void RenderImage(ImageRenderInfo renderInfo)
{
}
//
// EventListener implementation
//
/// <summary><inheritDoc/></summary>
public void EventOccurred(IEventData data, EventType type)
{
switch (type)
{
case EventType.RENDER_IMAGE:
{
ImageRenderInfo renderInfo = (ImageRenderInfo)data;
Matrix ctm = renderInfo.GetImageCtm();
float[] yCoords = new float[4];
for (int x = 0; x < 2; x++)
{
for (int y = 0; y < 2; y++)
{
Vector corner = new Vector(x, y, 1).Cross(ctm);
yCoords[2 * x + y] = corner.Get(Vector.I2);
}
}
Array.Sort(yCoords);
AddVerticalUseSection(yCoords[0], yCoords[3]);
break;
}
case EventType.RENDER_PATH:
{
PathRenderInfo renderInfo = (PathRenderInfo)data;
if (renderInfo.GetOperation() != PathRenderInfo.NO_OP)
{
Matrix ctm = renderInfo.GetCtm();
Path path = renderInfo.GetPath();
foreach (Subpath subpath in path.GetSubpaths())
{
List <float> yCoordsList = new List <float>();
foreach (Point point2d in subpath.GetPiecewiseLinearApproximation())
{
Vector vector = new Vector((float)point2d.GetX(), (float)point2d.GetY(), 1);
vector = vector.Cross(ctm);
yCoordsList.Add(vector.Get(Vector.I2));
}
if (yCoordsList.Count != 0)
{
float[] yCoords = yCoordsList.ToArray();
Array.Sort(yCoords);
AddVerticalUseSection(yCoords[0], yCoords[yCoords.Length - 1]);
}
}
}
break;
}
case EventType.RENDER_TEXT:
{
TextRenderInfo renderInfo = (TextRenderInfo)data;
LineSegment ascentLine = renderInfo.GetAscentLine();
LineSegment descentLine = renderInfo.GetDescentLine();
float[] yCoords = new float[]
{
ascentLine.GetStartPoint().Get(Vector.I2),
ascentLine.GetEndPoint().Get(Vector.I2),
descentLine.GetStartPoint().Get(Vector.I2),
descentLine.GetEndPoint().Get(Vector.I2)
};
Array.Sort(yCoords);
AddVerticalUseSection(yCoords[0], yCoords[3]);
break;
}
default:
{
break;
}
}
}
/// <see cref="IRenderListener.RenderImage"/>
public void RenderImage(ImageRenderInfo renderInfo)
{
items.Add(new ImageItem(renderInfo));
}
void IRenderListener.RenderImage(ImageRenderInfo renderInfo)
{
Logger.log(MethodBase.GetCurrentMethod());
}
public void RenderImage(ImageRenderInfo renderInfo)
{
this.textextractionstrategy.RenderImage(renderInfo);
}
/**
* Create an ImageRenderInfo object based on inline image data. This is nowhere near completely thought through
* and really just acts as a placeholder.
* @param ctm the coordinate transformation matrix at the time the image is rendered
* @param imageObject the image object representing the inline image
* @return the ImageRenderInfo representing the rendered embedded image
* @since 5.0.1
*/
protected internal static ImageRenderInfo CreateForEmbeddedImage(Matrix ctm, InlineImageInfo inlineImageInfo, PdfDictionary colorSpaceDictionary)
{
ImageRenderInfo renderInfo = new ImageRenderInfo(ctm, inlineImageInfo, colorSpaceDictionary);
return(renderInfo);
}
virtual public void RenderImage(ImageRenderInfo renderInfo) {
deleg.RenderImage(renderInfo);
}
public void RenderImage(ImageRenderInfo renderInfo)
{
PdfImageObject image = renderInfo.GetImage();
PdfName filter = (PdfName)image.Get(PdfName.FILTER);
//int width = Convert.ToInt32(image.Get(PdfName.WIDTH).ToString());
//int bitsPerComponent = Convert.ToInt32(image.Get(PdfName.BITSPERCOMPONENT).ToString());
//string subtype = image.Get(PdfName.SUBTYPE).ToString();
//int height = Convert.ToInt32(image.Get(PdfName.HEIGHT).ToString());
//int length = Convert.ToInt32(image.Get(PdfName.LENGTH).ToString());
//string colorSpace = image.Get(PdfName.COLORSPACE).ToString();
/* It appears to be safe to assume that when filter == null, PdfImageObject
* does not know how to decode the image to a System.Drawing.Image.
*
* Uncomment the code above to verify, but when I’ve seen this happen,
* width, height and bits per component all equal zero as well. */
if (filter != null)
{
Matrix matrix = renderInfo.GetImageCTM();
System.Drawing.Image drawingImage = image.GetDrawingImage();
string extension = ".";
float x = matrix[Matrix.I31];
float y = matrix[Matrix.I32];
float w = matrix[Matrix.I11];
float h = matrix[Matrix.I22];
if (filter == PdfName.DCTDECODE)
{
extension += PdfImageObject.ImageBytesType.JPG.FileExtension;
}
else if (filter == PdfName.JPXDECODE)
{
extension += PdfImageObject.ImageBytesType.JP2.FileExtension;
}
else if (filter == PdfName.FLATEDECODE)
{
extension += PdfImageObject.ImageBytesType.PNG.FileExtension;
}
else if (filter == PdfName.LZWDECODE)
{
extension += PdfImageObject.ImageBytesType.CCITT.FileExtension;
}
/* Rather than struggle with the image stream and try to figure out how to handle
* BitMapData scan lines in various formats (like virtually every sample I’ve found
* online), use the PdfImageObject.GetDrawingImage() method, which does the work for us. */
//this.Images.Add(drawingImage, extension);
images.Add(new PdfImage()
{
X = x,
Y = y,
Width = w,
Height = h,
DrawingImage = drawingImage,
Extension = extension
});
}
}
