public virtual void DivWithRotatedPercentImage()
{
String outFileName = destinationFolder + "divRotatedPercentImage.pdf";
String cmpFileName = sourceFolder + "cmp_divRotatedPercentImage.pdf";
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(outFileName));
Document doc = new Document(pdfDocument);
PdfImageXObject imageXObject = new PdfImageXObject(ImageDataFactory.Create(sourceFolder + "itis.jpg"));
iText.Layout.Element.Image img = new iText.Layout.Element.Image(imageXObject).SetRotationAngle(Math.PI * 3
/ 8);
Div d = new Div().Add(img).SetBorder(new SolidBorder(ColorConstants.BLUE, 2f)).SetMarginBottom(10);
iText.Layout.Element.Image imgPercent = new iText.Layout.Element.Image(imageXObject).SetWidth(UnitValue.CreatePercentValue
(50)).SetRotationAngle(Math.PI * 3 / 8);
Div dPercent = new Div().Add(imgPercent).SetBorder(new SolidBorder(ColorConstants.BLUE, 2f));
MinMaxWidth result = ((AbstractRenderer)d.CreateRendererSubTree().SetParent(doc.GetRenderer())).GetMinMaxWidth
();
d.SetWidth(ToEffectiveWidth(d, result.GetMinWidth()));
MinMaxWidth resultPercent = ((AbstractRenderer)dPercent.CreateRendererSubTree().SetParent(doc.GetRenderer(
))).GetMinMaxWidth();
dPercent.SetWidth(ToEffectiveWidth(dPercent, resultPercent.GetMaxWidth()));
doc.Add(d);
doc.Add(dPercent);
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
/// <exception cref="System.Exception"/>
private void TestFile(String filename, int page, String objectid)
{
PdfDocument pdfDocument = new PdfDocument(new PdfReader(sourceFolder + filename));
try {
PdfResources resources = pdfDocument.GetPage(page).GetResources();
PdfDictionary xobjets = resources.GetResource(PdfName.XObject);
PdfObject obj = xobjets.Get(new PdfName(objectid));
if (obj == null)
{
throw new ArgumentNullException("Reference " + objectid + " not found - Available keys are " + xobjets.KeySet
());
}
PdfImageXObject img = new PdfImageXObject((PdfStream)(obj.IsIndirectReference() ? ((PdfIndirectReference)obj
).GetRefersTo() : obj));
byte[] result = img.GetImageBytes(true);
NUnit.Framework.Assert.IsNotNull(result);
int zeroCount = 0;
foreach (byte b in result)
{
if (b == 0)
{
zeroCount++;
}
}
NUnit.Framework.Assert.IsTrue(zeroCount > 0);
}
finally {
pdfDocument.Close();
}
}
/// <summary>
/// Creates an
/// <see cref="Image"/>
/// from an image XObject, the representation of an
/// image in PDF syntax, on a fixed position.
/// </summary>
/// <param name="xObject">
/// an internal
/// <see cref="iText.Kernel.Pdf.Xobject.PdfImageXObject"/>
/// </param>
/// <param name="left">a float value representing the horizontal offset of the lower left corner of the image</param>
/// <param name="bottom">a float value representing the vertical offset of the lower left corner of the image</param>
public Image(PdfImageXObject xObject, float left, float bottom)
{
this.xObject = xObject;
SetProperty(Property.LEFT, left);
SetProperty(Property.BOTTOM, bottom);
SetProperty(Property.POSITION, LayoutPosition.FIXED);
}
/// <summary>
/// Creates an
/// <see cref="Image"/>
/// from an image XObject, the representation of an
/// image in PDF syntax, on a fixed position.
/// </summary>
/// <param name="xObject">
/// an internal
/// <see cref="iText.Kernel.Pdf.Xobject.PdfImageXObject"/>
/// </param>
/// <param name="x">a float value representing the horizontal offset of the lower left corner of the image</param>
/// <param name="y">a float value representing the vertical offset of the lower left corner of the image</param>
public Image(PdfImageXObject xObject, float x, float y)
{
this.xObject = xObject;
SetProperty(Property.X, x);
SetProperty(Property.Y, y);
SetProperty(Property.POSITION, LayoutPosition.FIXED);
}
private bool MergeMask(ImageRenderInfo data, PdfName name, ref byte[] bytes)
{
var image = data.GetImage();
var maskStream = image.GetPdfObject().GetAsStream(name);
if (maskStream == null)
{
return(false);
}
var bitmapImage = Bitmap.FromStream(new MemoryStream(bytes)) as Bitmap;
var maskImage = new PdfImageXObject(maskStream);
var bytesMask = maskImage.GetImageBytes();
var bitmapMask = Bitmap.FromStream(new MemoryStream(bytesMask)) as Bitmap;
var bitmapResult = ApplyMask(bitmapImage, bitmapMask);
using (var memoryStream = new MemoryStream())
{
bitmapResult.Save(memoryStream, bitmapImage.RawFormat);
bytes = memoryStream.GetBuffer();
}
return(true);
}
public virtual void ImageCsCompatibleTest()
{
PdfImageXObject image1 = CreateMockedPdfImageXObject(PdfName.DeviceRGB, 8);
PdfImageXObject image2 = CreateMockedPdfImageXObject(PdfName.DeviceRGB, 8);
Assert.True(CleanUpCsCompareUtil.IsOriginalCsCompatible(image1, image2));
}
protected void ManipulatePdf(String dest)
{
PdfDocument pdfDoc = new PdfDocument(new PdfReader(SRC), new PdfWriter(dest));
// Suppose that this is our image data
byte[] circleData = new byte[]
{ (byte)0x3c, (byte)0x7e, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x7e, (byte)0x3c };
PdfSpecialCs colorspace = GetSeparationColorspace(pdfDoc.GetWriter(),
new DeviceCmyk(0.8f, 0.3f, 0.3f, 0.1f));
// Specifying a single component colorspace in the image
ImageData image = ImageDataFactory.Create(8, 8, 1, 1, circleData,
new int[] { 0, 0 });
PdfImageXObject imageXObject = new PdfImageXObject(image);
imageXObject.Put(PdfName.ColorSpace, colorspace.GetPdfObject());
imageXObject.MakeIndirect(pdfDoc);
// Now we add the image to the existing PDF document
PdfPage pdfPage = pdfDoc.GetFirstPage();
pdfPage.SetIgnorePageRotationForContent(true);
PdfCanvas canvas = new PdfCanvas(pdfPage);
Rectangle rect = PdfXObject.CalculateProportionallyFitRectangleWithWidth(imageXObject, 100, 200, 100);
canvas.AddXObjectFittedIntoRectangle(imageXObject, rect);
pdfDoc.Close();
}
public virtual void TabsInParagraphTest01()
{
String outFileName = destinationFolder + "tabsInParagraphTest01.pdf";
String cmpFileName = sourceFolder + "cmp_tabsInParagraphTest01.pdf";
PdfDocument pdfDoc = new PdfDocument(new PdfWriter(outFileName));
Document doc = new Document(pdfDoc);
float tabWidth = pdfDoc.GetDefaultPageSize().GetWidth() - doc.GetLeftMargin() - doc.GetRightMargin();
Paragraph p = new Paragraph();
p.AddTabStops(new TabStop(tabWidth, TabAlignment.RIGHT)).Add("There is a right-aligned tab after me. And then three chunks of text."
).Add(new Tab()).Add("Text1").Add("Text2").Add("Text3");
doc.Add(p);
p = new Paragraph();
p.AddTabStops(new TabStop(tabWidth, TabAlignment.RIGHT)).Add("There is a right-aligned tab after me. And then three chunks of text."
).Add(new Tab()).Add("Text1").Add("Tex\nt2").Add("Text3");
doc.Add(p);
p = new Paragraph();
p.AddTabStops(new TabStop(tabWidth, TabAlignment.RIGHT)).Add("There is a right-aligned tab after me. And then three chunks of text."
).Add(new Tab()).Add("Long Long Long Long Long Long Long Text1").Add("Tex\nt2").Add("Text3");
doc.Add(p);
PdfImageXObject xObject = new PdfImageXObject(ImageDataFactory.CreateJpeg(UrlUtil.ToURL(sourceFolder + "Desert.jpg"
)));
iText.Layout.Element.Image image = new iText.Layout.Element.Image(xObject, 100);
p = new Paragraph();
p.AddTabStops(new TabStop(tabWidth, TabAlignment.RIGHT)).Add("There is a right-aligned tab after me. And then texts and an image."
).Add(new Tab()).Add("Text1").Add(image).Add("Text3");
doc.Add(p);
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
public virtual void AddAssociatedFilesTest02()
{
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(destinationFolder + "add_associated_files02.pdf",
new WriterProperties().SetPdfVersion(PdfVersion.PDF_2_0)));
pdfDocument.SetTagged();
PdfCanvas pageCanvas = new PdfCanvas(pdfDocument.AddNewPage());
PdfImageXObject imageXObject = new PdfImageXObject(ImageDataFactory.Create(sourceFolder + "berlin2013.jpg"
));
imageXObject.AddAssociatedFile(PdfFileSpec.CreateEmbeddedFileSpec(pdfDocument, "Associated File 1".GetBytes
(), "af_1.txt", PdfName.Data));
pageCanvas.AddXObject(imageXObject, 40, 400);
PdfFormXObject formXObject = new PdfFormXObject(new Rectangle(200, 200));
PdfCanvas formCanvas = new PdfCanvas(formXObject, pdfDocument);
formCanvas.SaveState().Circle(100, 100, 50).SetColor(ColorConstants.BLACK, true).Fill().RestoreState();
formCanvas.Release();
formXObject.AddAssociatedFile(PdfFileSpec.CreateEmbeddedFileSpec(pdfDocument, "Associated File 2".GetBytes
(), "af_2.txt", PdfName.Data));
pageCanvas.AddXObject(formXObject, 40, 100);
pdfDocument.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(destinationFolder + "add_associated_files02.pdf"
, sourceFolder + "cmp_add_associated_files02.pdf", "d:/", "diff_"));
}
/// <summary>
/// Creates a new
/// <see cref="HtmlBackgroundImage"/>
/// instance.
/// </summary>
/// <param name="xObject">
/// background-image property.
/// <see cref="iText.Kernel.Pdf.Xobject.PdfImageXObject"/>
/// instance.
/// </param>
/// <param name="repeat">
/// background-repeat property.
/// <see cref="iText.Layout.Properties.BackgroundRepeat"/>
/// instance.
/// </param>
/// <param name="position">
/// background-position property.
/// <see cref="iText.Layout.Properties.BackgroundPosition"/>
/// instance.
/// </param>
/// <param name="blendMode">
/// background-blend-mode property.
/// <see cref="iText.Layout.Properties.BlendMode"/>
/// instance.
/// </param>
/// <param name="clip">
/// background-clip property.
/// <see cref="iText.Layout.Properties.BackgroundBox"/>
/// instance.
/// </param>
/// <param name="origin">
/// background-origin property.
/// <see cref="iText.Layout.Properties.BackgroundBox"/>
/// instance.
/// </param>
public HtmlBackgroundImage(PdfImageXObject xObject, BackgroundRepeat repeat, BackgroundPosition position,
BlendMode blendMode, BackgroundBox clip, BackgroundBox origin)
: base(new BackgroundImage.Builder().SetImage(xObject).SetBackgroundRepeat(repeat).SetBackgroundPosition(position
).SetBackgroundBlendMode(blendMode).SetBackgroundClip(clip).SetBackgroundOrigin(origin).Build())
{
dimensionMultiplier = PX_TO_PT_MULTIPLIER;
}
public virtual void ImageWithMinMaxHeightTest01()
{
String outFileName = destinationFolder + "imageWithMinMaxHeightTest01.pdf";
String cmpFileName = sourceFolder + "cmp_imageWithMinMaxHeightTest01.pdf";
PdfWriter writer = new PdfWriter(outFileName);
PdfDocument pdfDoc = new PdfDocument(writer);
Document doc = new Document(pdfDoc);
PdfImageXObject xObject = new PdfImageXObject(ImageDataFactory.Create(sourceFolder + "itis.jpg"));
iText.Layout.Element.Image image = new iText.Layout.Element.Image(xObject, 100);
doc.Add(new Paragraph(new Text("Default height")));
doc.Add(image);
doc.Add(new Paragraph(new Text("Min height bigger than default")));
doc.Add(image.SetMinHeight(200));
doc.Add(new Paragraph(new Text("Min height smaller than default")));
image.DeleteOwnProperty(Property.MIN_HEIGHT);
doc.Add(image.SetMinHeight(10));
doc.Add(new Paragraph(new Text("Max height bigger than default")));
image.DeleteOwnProperty(Property.MIN_HEIGHT);
doc.Add(image.SetMaxHeight(250));
doc.Add(new Paragraph(new Text("Max height smaller than default")));
image.DeleteOwnProperty(Property.MAX_HEIGHT);
doc.Add(image.SetMaxHeight(30));
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
protected void ManipulatePdf(String dest)
{
PdfDocument resultDoc = new PdfDocument(new PdfWriter(dest));
PdfDocument srcDoc = new PdfDocument(new PdfReader(SRC));
// Assume that there is a single XObject in the source document
// and this single object is an image.
PdfDictionary pageDict = srcDoc.GetFirstPage().GetPdfObject();
PdfDictionary pageResources = pageDict.GetAsDictionary(PdfName.Resources);
PdfDictionary pageXObjects = pageResources.GetAsDictionary(PdfName.XObject);
PdfName imgRef = pageXObjects.KeySet().First();
PdfStream imgStream = pageXObjects.GetAsStream(imgRef);
PdfImageXObject imgObject = new PdfImageXObject((PdfStream)imgStream.CopyTo(resultDoc));
Image image = new Image(imgObject);
image.ScaleToFit(14400, 14400);
image.SetFixedPosition(0, 0);
srcDoc.Close();
PageSize pageSize = new PageSize(image.GetImageScaledWidth(), image.GetImageScaledHeight());
Document doc = new Document(resultDoc, pageSize);
doc.Add(image);
doc.Close();
}
public virtual void CalculateProportionallyFitRectangleWithHeightTest()
{
String fileName = "calculateProportionallyFitRectangleWithHeightTest.pdf";
String destPdf = DESTINATION_FOLDER + fileName;
String cmpPdf = SOURCE_FOLDER + "cmp_" + fileName;
FileStream fos = new FileStream(destPdf, FileMode.Create);
PdfWriter writer = new PdfWriter(fos);
PdfDocument document = new PdfDocument(writer);
PdfFormXObject formXObject = new PdfFormXObject(new Rectangle(5, 5, 15, 20));
formXObject.Put(PdfName.Matrix, new PdfArray(new float[] { 1, 0.57f, 0, 2, 20, 5 }));
new PdfCanvas(formXObject, document).Circle(10, 15, 10).Fill();
PdfImageXObject imageXObject = new PdfImageXObject(ImageDataFactory.Create(SOURCE_FOLDER + "itext.png"));
PdfPage page = document.AddNewPage();
PdfCanvas canvas = new PdfCanvas(page);
Rectangle rect = PdfXObject.CalculateProportionallyFitRectangleWithHeight(formXObject, 0, 0, 20);
canvas.AddXObjectFittedIntoRectangle(formXObject, rect);
rect = PdfXObject.CalculateProportionallyFitRectangleWithHeight(imageXObject, 20, 0, 20);
canvas.AddXObjectFittedIntoRectangle(imageXObject, rect);
canvas.Release();
page.Flush();
document.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(destPdf, cmpPdf, DESTINATION_FOLDER, "diff_"
));
}
public virtual void ImageWidthTest02()
{
PdfImageXObject xObject = new PdfImageXObject(ImageDataFactory.Create(imageFolder + "Desert.jpg"));
iText.Layout.Element.Image image = new iText.Layout.Element.Image(xObject);
ImageRenderer renderer = new ImageRenderer(image);
image.SetProperty(Property.MAX_WIDTH, UnitValue.CreatePointValue(50));
MinMaxWidth minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(50.0, minMaxWidth.GetMaxWidth(), EPSILON);
NUnit.Framework.Assert.AreEqual(0.0, minMaxWidth.GetMaxWidth() - minMaxWidth.GetMinWidth(), EPSILON);
image.SetProperty(Property.MAX_WIDTH, UnitValue.CreatePercentValue(50));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(1024.0, minMaxWidth.GetMaxWidth(), EPSILON);
image.SetProperty(Property.MAX_HEIGHT, UnitValue.CreatePointValue(100f));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(100.0 * 1024.0 / 768.0, minMaxWidth.GetMaxWidth(), EPSILON);
image = new iText.Layout.Element.Image(xObject);
renderer = new ImageRenderer(image);
image.SetProperty(Property.MIN_WIDTH, UnitValue.CreatePointValue(2000));
image.SetProperty(Property.MAX_WIDTH, UnitValue.CreatePointValue(3000));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(2000.0, minMaxWidth.GetMaxWidth(), EPSILON);
NUnit.Framework.Assert.AreEqual(0.0, minMaxWidth.GetMaxWidth() - minMaxWidth.GetMinWidth(), EPSILON);
image.SetProperty(Property.MIN_HEIGHT, UnitValue.CreatePointValue(100f));
image.SetProperty(Property.HEIGHT, UnitValue.CreatePointValue(100f));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(100.0 * 1024.0 / 768.0, minMaxWidth.GetMaxWidth(), EPSILON);
}
private void CreateImageFromPdfXObject(String imageFileName, PdfImageXObject imageObject)
{
using (FileStream stream = new FileStream(imageFileName, FileMode.Create)) {
byte[] image = imageObject.GetImageBytes();
stream.Write(image, 0, image.Length);
}
}
/// <summary>Create an ImageRenderInfo</summary>
/// <param name="ctm">the coordinate transformation matrix at the time the image is rendered</param>
/// <param name="stream">image stream object</param>
/// <param name="colorSpaceDictionary">the color space dictionary from resources which are associated with the image
/// </param>
/// <param name="isInline">defines if the encountered image was inline</param>
public ImageRenderInfo(Matrix ctm, PdfStream stream, PdfDictionary colorSpaceDictionary, bool isInline)
{
this.ctm = ctm;
this.image = new PdfImageXObject(stream);
this.colorSpaceDictionary = colorSpaceDictionary;
this.isInline = isInline;
}
public BackgroundImage(PdfImageXObject image, bool repeatX, bool repeatY)
: this(image, new BackgroundRepeat(repeatX ? BackgroundRepeat.BackgroundRepeatValue.REPEAT : BackgroundRepeat.BackgroundRepeatValue
.NO_REPEAT, repeatY ? BackgroundRepeat.BackgroundRepeatValue.REPEAT : BackgroundRepeat.BackgroundRepeatValue
.NO_REPEAT), new BackgroundPosition(), new BackgroundSize(), null, DEFAULT_BLEND_MODE, BackgroundBox.BORDER_BOX
, BackgroundBox.PADDING_BOX)
{
}
public virtual void BackgroundXObjectAndImage()
{
//TODO DEVSIX-3108
String filename = "backgroundXObjectAndImage";
String fileName = filename + ".pdf";
String outFileName = destinationFolder + fileName;
String cmpFileName = sourceFolder + "cmp_" + filename + ".pdf";
using (PdfDocument pdfDocument = new PdfDocument(new PdfWriter(new FileStream(outFileName, FileMode.Create
)))) {
Document doc = new Document(pdfDocument);
String text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, " + "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
+ "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi " + "ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit "
+ "in voluptate velit esse cillum dolore eu fugiat nulla pariatur. " + "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui "
+ "officia deserunt mollit anim id est laborum. ";
Div div = new Div().Add(new Paragraph(text + text + text));
PdfImageXObject imageXObject = new PdfImageXObject(ImageDataFactory.Create(sourceFolder + "itis.jpg"));
iText.Layout.Properties.BackgroundImage backgroundImage = new iText.Layout.Properties.BackgroundImage(imageXObject
);
div.SetProperty(Property.BACKGROUND_IMAGE, backgroundImage);
doc.Add(div);
iText.Layout.Properties.BackgroundImage backgroundFormXObject = new iText.Layout.Properties.BackgroundImage
(CreateFormXObject(pdfDocument));
div = new Div().Add(new Paragraph(text + text + text));
div.SetProperty(Property.BACKGROUND_IMAGE, backgroundFormXObject);
doc.Add(div);
pdfDocument.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
}
public void EventOccurred(IEventData data, EventType type)
{
switch (type)
{
case EventType.RENDER_IMAGE:
try
{
//Get the image render information.
ImageRenderInfo imageRenderInfo = data as ImageRenderInfo;
//Get the image object from the render information.
PdfImageXObject pdfImageXObject = imageRenderInfo.GetImage();
if (pdfImageXObject != null)
{
byte[] imageData = pdfImageXObject.GetImageBytes(true);
//Store.
ImageDataAndExtension.Add(imageData, pdfImageXObject.IdentifyImageFileExtension());
}
}
catch (Exception ex)
{
throw ex;
}
break;
default:
return;
}
}
public virtual void RetrieveImageWrongPathTest()
{
String fileName = "/itextpdf.com/itis.jpg";
ResourceResolver resourceResolver = new ResourceResolver(baseUri);
PdfImageXObject image = resourceResolver.RetrieveImage(fileName);
Assert.Null(image);
}
public virtual void RetrieveImagePathWithSpacesTest()
{
String fileName = "retrieveImagePathWithSpaces.jpg";
ResourceResolver resourceResolver = new ResourceResolver(baseUri + "path with spaces/");
PdfImageXObject image = resourceResolver.RetrieveImage(fileName);
Assert.NotNull(image);
Assert.IsTrue(image.IdentifyImageFileExtension().EqualsIgnoreCase("jpg"));
}
public override void EventOccurred(IEventData data, EventType type)
{
if (type != EventType.RENDER_IMAGE)
{
return;
}
var counter = _increaseCounter();
var renderInfo = (ImageRenderInfo)data;
var imageObject = renderInfo.GetImage();
Bitmap image;
try
{
var imageBytes = imageObject.GetImageBytes();
image = new Bitmap(new MemoryStream(imageBytes));
}
catch (Exception exp)
{
Console.WriteLine(exp);
return;
}
var smask = imageObject.GetPdfObject().GetAsStream(PdfName.SMask);
if (smask != null)
{
try
{
var maskImageObject = new PdfImageXObject(smask);
var maskBytes = maskImageObject.GetImageBytes();
using var maskImage = new Bitmap(new MemoryStream(maskBytes));
image = GenerateMaskedImage(image, maskImage);
}
catch (Exception exp)
{
Console.WriteLine(exp);
}
}
var matix = renderInfo.GetImageCtm();
var imageChunk = new ImageChunk
{
X = matix.Get(Geom.Matrix.I31),
Y = matix.Get(Geom.Matrix.I32),
W = matix.Get(Geom.Matrix.I11),
H = matix.Get(Geom.Matrix.I22),
Image = image
};
_chunkDictionairy.Add(counter, imageChunk);
base.EventOccurred(data, type);
}
public virtual void RetrieveImageTest()
{
String fileName = "resourceResolverTest.png";
ResourceResolver resourceResolver = new ResourceResolver(baseUri);
PdfImageXObject image = resourceResolver.RetrieveImage(fileName);
NUnit.Framework.Assert.NotNull(image);
NUnit.Framework.Assert.True(image.IdentifyImageFileExtension().EqualsIgnoreCase("png"));
}
public virtual void RetrieveImageRightPathTest()
{
String fileName = "itextpdf.com/itis.jpg";
ResourceResolver resourceResolver = new ResourceResolver(baseUri);
PdfImageXObject image = resourceResolver.RetrieveImage(fileName);
Assert.NotNull(image);
Assert.IsTrue(image.IdentifyImageFileExtension().EqualsIgnoreCase("jpg"));
}
public virtual void CalculateSizeWithCoverAndImageWeightMoreThatHeightTest()
{
PdfImageXObject xObject = new PdfImageXObject(ImageDataFactory.Create(SOURCE_FOLDER + "itis.jpg"));
BackgroundImage backgroundImage = new BackgroundImage(xObject);
backgroundImage.GetBackgroundSize().SetBackgroundSizeToCover();
float[] widthAndHeight = BackgroundSizeCalculationUtil.CalculateBackgroundImageSize(backgroundImage, 200f,
300f);
NUnit.Framework.Assert.AreEqual(new float[] { 533.3333f, 300f }, widthAndHeight);
}
public virtual void BackgroundImageWithoutRepeatY()
{
PdfImageXObject xObject = new PdfImageXObject(ImageDataFactory.Create(sourceFolder + "itis.jpg"));
iText.Layout.Properties.BackgroundImage backgroundImage = new iText.Layout.Properties.BackgroundImage(xObject
, true, false);
NUnit.Framework.Assert.IsTrue(backgroundImage.IsRepeatX());
NUnit.Framework.Assert.IsFalse(backgroundImage.IsRepeatY());
BackgroundImageGenericTest("backgroundImageWithoutRepeatY", backgroundImage);
}
public virtual void CleanUpImageEmptyAreasToCleanTest()
{
ImageData data = ImageDataFactory.Create(SOURCE_PATH + "cleanUpImageEmptyAreasToClean.png");
PdfImageXObject imageXObject = new PdfImageXObject(data);
byte[] sourceImageBytes = imageXObject.GetImageBytes();
byte[] resultImageBytes = CleanUpImageUtil.CleanUpImage(new PdfImageXObject(data).GetImageBytes(), new List
<Rectangle>());
NUnit.Framework.Assert.AreEqual(sourceImageBytes, resultImageBytes);
}
public virtual void CalculateImageSizeTest()
{
PdfImageXObject xObject = new PdfImageXObject(ImageDataFactory.Create(SOURCE_FOLDER + "pattern-grg-rrg-rgg.png"
));
BackgroundImage backgroundImage = new BackgroundImage(xObject);
float[] widthAndHeight = BackgroundSizeCalculationUtil.CalculateBackgroundImageSize(backgroundImage, 200f,
300f);
NUnit.Framework.Assert.AreEqual(new float[] { 45f, 45f }, widthAndHeight);
}
internal static FilteredImagesCache.FilteredImageKey CreateFilteredImageKey(PdfImageXObject image, IList <Rectangle
> areasToBeCleaned, PdfDocument document)
{
PdfStream imagePdfObject = image.GetPdfObject();
if (imagePdfObject.GetIndirectReference() == null)
{
imagePdfObject.MakeIndirect(document);
}
return(new FilteredImagesCache.FilteredImageKey(image, areasToBeCleaned));
}
/// <summary>Create an ImageRenderInfo</summary>
/// <param name="ctm">the coordinate transformation matrix at the time the image is rendered</param>
/// <param name="imageStream">image stream object</param>
/// <param name="resourceName"/>
/// <param name="colorSpaceDictionary">the color space dictionary from resources which are associated with the image
/// </param>
/// <param name="isInline">defines if the encountered image was inline</param>
public ImageRenderInfo(Stack <CanvasTag> canvasTagHierarchy, CanvasGraphicsState gs, Matrix ctm, PdfStream
imageStream, PdfName resourceName, PdfDictionary colorSpaceDictionary, bool isInline)
: base(gs)
{
this.canvasTagHierarchy = JavaCollectionsUtil.UnmodifiableList <CanvasTag>(new List <CanvasTag>(canvasTagHierarchy
));
this.resourceName = resourceName;
this.ctm = ctm;
this.image = new PdfImageXObject(imageStream);
this.colorSpaceDictionary = colorSpaceDictionary;
this.isInline = isInline;
}
