From f2e542354f9783e30c72b403422beeb33de9d787 Mon Sep 17 00:00:00 2001 From: Simon Steiner Date: Thu, 1 Sep 2022 10:14:56 +0000 Subject: [PATCH] FOP-3091: Add transparency color support for AFP git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@1903806 13f79535-47bb-0310-9956-ffa450edef68 --- .../apache/fop/afp/AFPDataObjectFactory.java | 1 + .../org/apache/fop/afp/AFPDataObjectInfo.java | 10 ++ .../apache/fop/afp/AFPRectanglePainter.java | 111 +++++++++++++++++- .../org/apache/fop/afp/ioca/ImageContent.java | 10 +- .../org/apache/fop/afp/ioca/ImageSegment.java | 4 + .../java/org/apache/fop/afp/ioca/Tile.java | 48 ++++++-- .../apache/fop/afp/ioca/TransparencyMask.java | 62 ++++++++++ .../org/apache/fop/afp/modca/ImageObject.java | 12 +- .../fop/render/afp/AFPDocumentHandler.java | 2 +- .../fop/afp/AFPRectanglePainterTestCase.java | 83 +++++++++++++ .../fop/afp/ioca/ImageContentTestCase.java | 48 ++++++++ 11 files changed, 370 insertions(+), 21 deletions(-) create mode 100644 fop-core/src/main/java/org/apache/fop/afp/ioca/TransparencyMask.java create mode 100644 fop-core/src/test/java/org/apache/fop/afp/AFPRectanglePainterTestCase.java create mode 100644 fop-core/src/test/java/org/apache/fop/afp/ioca/ImageContentTestCase.java diff --git a/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectFactory.java b/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectFactory.java index 17114ebbe..987102af7 100644 --- a/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectFactory.java +++ b/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectFactory.java @@ -150,6 +150,7 @@ public class AFPDataObjectFactory { } imageObj.setData(imageObjectInfo.getData()); + imageObj.setTransparencyMask(imageObjectInfo.getTransparencyMask()); return imageObj; } diff --git a/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectInfo.java b/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectInfo.java index b93056f02..dc828a540 100644 --- a/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectInfo.java +++ b/fop-core/src/main/java/org/apache/fop/afp/AFPDataObjectInfo.java @@ -45,6 +45,8 @@ public class AFPDataObjectInfo { /** the object data in a byte array */ private byte[] data; + private byte[] transparencyMask; + /** the object data height resolution */ private int dataHeightRes; @@ -239,6 +241,14 @@ public class AFPDataObjectInfo { return this.data; } + public void setTransparencyMask(byte[] transparencyMask) { + this.transparencyMask = transparencyMask; + } + + public byte[] getTransparencyMask() { + return transparencyMask; + } + /** * Controls whether to create a page segment or a normal object. * @param value true for page segments, false for objects diff --git a/fop-core/src/main/java/org/apache/fop/afp/AFPRectanglePainter.java b/fop-core/src/main/java/org/apache/fop/afp/AFPRectanglePainter.java index 8b598008a..009f5bc88 100644 --- a/fop-core/src/main/java/org/apache/fop/afp/AFPRectanglePainter.java +++ b/fop-core/src/main/java/org/apache/fop/afp/AFPRectanglePainter.java @@ -19,26 +19,50 @@ package org.apache.fop.afp; +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics; import java.awt.geom.AffineTransform; +import java.awt.geom.Point2D; +import java.awt.image.BufferedImage; +import java.awt.image.DataBufferByte; +import java.awt.image.RenderedImage; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import org.apache.xmlgraphics.image.loader.ImageSize; +import org.apache.xmlgraphics.java2d.color.ColorWithAlternatives; +import org.apache.xmlgraphics.util.MimeConstants; + +import org.apache.fop.util.bitmap.BitmapImageUtil; /** * A painter of rectangles in AFP */ public class AFPRectanglePainter extends AbstractAFPPainter { + private AFPResourceManager resourceManager; + /** * Main constructor * * @param paintingState the AFP painting state * @param dataStream the AFP datastream */ - public AFPRectanglePainter(AFPPaintingState paintingState, DataStream dataStream) { + public AFPRectanglePainter(AFPPaintingState paintingState, DataStream dataStream, + AFPResourceManager resourceManager) { super(paintingState, dataStream); + this.resourceManager = resourceManager; } /** {@inheritDoc} */ - public void paint(PaintingInfo paintInfo) { + public void paint(PaintingInfo paintInfo) throws IOException { + Color color = paintingState.getColor(); + if (color instanceof ColorWithAlternatives && color.getAlpha() != 255) { + paintAlpha(paintInfo); + return; + } + RectanglePaintingInfo rectanglePaintInfo = (RectanglePaintingInfo)paintInfo; int pageWidth = dataStream.getCurrentPage().getWidth(); int pageHeight = dataStream.getCurrentPage().getHeight(); @@ -90,4 +114,87 @@ public class AFPRectanglePainter extends AbstractAFPPainter { } dataStream.createLine(lineDataInfo); } + + private void paintAlpha(PaintingInfo paintInfo) throws IOException { + RectanglePaintingInfo rectanglePaintInfo = (RectanglePaintingInfo)paintInfo; + if (rectanglePaintInfo.getWidth() <= 0 || rectanglePaintInfo.getHeight() <= 0) { + return; + } + Dimension size = new Dimension((int)rectanglePaintInfo.getWidth(), (int)rectanglePaintInfo.getHeight()); + + AFPImageObjectInfo imageObjectInfo = new AFPImageObjectInfo(); + imageObjectInfo.setMimeType(MimeConstants.MIME_AFP_IOCA_FS45); + imageObjectInfo.getResourceInfo().setLevel(new AFPResourceLevel(AFPResourceLevel.ResourceType.INLINE)); + imageObjectInfo.getResourceInfo().setImageDimension(size); + imageObjectInfo.setColor(true); + + int width = size.width; + int height = size.height; + int resolution = paintingState.getResolution(); + ImageSize bitmapSize = new ImageSize(width, height, resolution); + imageObjectInfo.setDataHeightRes((int)Math.round(bitmapSize.getDpiHorizontal() * 10)); + imageObjectInfo.setDataWidthRes((int)Math.round(bitmapSize.getDpiVertical() * 10)); + imageObjectInfo.setDataWidth(width); + imageObjectInfo.setDataHeight(height); + + Color color = paintingState.getColor(); + byte[] image = buildImage(color, width, height); + imageObjectInfo.setData(image); + if (color instanceof ColorWithAlternatives) { + imageObjectInfo.setBitsPerPixel(32); + } else { + imageObjectInfo.setBitsPerPixel(24); + } + + image = buildMaskImage(color, width, height); + imageObjectInfo.setTransparencyMask(image); + + int rotation = paintingState.getRotation(); + AffineTransform at = paintingState.getData().getTransform(); + Point2D origin = at.transform(new Point2D.Float( + rectanglePaintInfo.getX() * 1000, + rectanglePaintInfo.getY() * 1000), null); + AFPUnitConverter unitConv = paintingState.getUnitConverter(); + float widthf = unitConv.pt2units(rectanglePaintInfo.getWidth()); + float heightf = unitConv.pt2units(rectanglePaintInfo.getHeight()); + AFPObjectAreaInfo objectAreaInfo = new AFPObjectAreaInfo( + (int) Math.round(origin.getX()), + (int) Math.round(origin.getY()), + Math.round(widthf), Math.round(heightf), resolution, rotation); + imageObjectInfo.setObjectAreaInfo(objectAreaInfo); + + resourceManager.createObject(imageObjectInfo); + } + + private byte[] buildImage(Color color, int width, int height) { + float[] components; + if (color instanceof ColorWithAlternatives) { + components = ((ColorWithAlternatives)color).getAlternativeColors()[0].getColorComponents(null); + } else { + components = color.getColorComponents(null); + } + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + for (float component : components) { + component *= 255; + bos.write((byte)component); + } + } + } + return bos.toByteArray(); + } + + private byte[] buildMaskImage(Color color, int width, int height) { + BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); + Graphics graphics = bufferedImage.getGraphics(); + Color alpha = new Color(color.getAlpha(), color.getAlpha(), color.getAlpha()); + graphics.setColor(alpha); + graphics.fillRect(0, 0, width, height); + graphics.dispose(); + RenderedImage renderedImage = + BitmapImageUtil.convertToMonochrome(bufferedImage, new Dimension(width, height), 1); + DataBufferByte bufferByte = (DataBufferByte) renderedImage.getData().getDataBuffer(); + return bufferByte.getData(); + } } diff --git a/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageContent.java b/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageContent.java index 516d4f715..b4f9645a6 100644 --- a/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageContent.java +++ b/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageContent.java @@ -182,12 +182,18 @@ public class ImageContent extends AbstractStructuredObject { } } - private static final int MAX_DATA_LEN = 65535; + public void setTransparencyMask(byte[] transparencyMask) { + if (transparencyMask != null) { + tile.setTransparencyMask(new TransparencyMask(transparencyMask, imageSizeParameter)); + } + } + + private static final int MAX_DATA_LEN = 8188; /** {@inheritDoc} */ @Override protected void writeContent(OutputStream os) throws IOException { - if (imageSizeParameter != null) { + if (imageSizeParameter != null && tile == null) { imageSizeParameter.writeToStream(os); } diff --git a/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageSegment.java b/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageSegment.java index 96afa1136..68e4dd74b 100644 --- a/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageSegment.java +++ b/fop-core/src/main/java/org/apache/fop/afp/ioca/ImageSegment.java @@ -136,6 +136,10 @@ public class ImageSegment extends AbstractNamedAFPObject { getImageContent().setImageData(imageData); } + public void setTransparencyMask(byte[] transparencyMask) { + getImageContent().setTransparencyMask(transparencyMask); + } + /** {@inheritDoc} */ public void writeContent(OutputStream os) throws IOException { if (imageContent != null) { diff --git a/fop-core/src/main/java/org/apache/fop/afp/ioca/Tile.java b/fop-core/src/main/java/org/apache/fop/afp/ioca/Tile.java index 3e9d3d5ff..9f5f88d3a 100644 --- a/fop-core/src/main/java/org/apache/fop/afp/ioca/Tile.java +++ b/fop-core/src/main/java/org/apache/fop/afp/ioca/Tile.java @@ -31,6 +31,7 @@ public class Tile extends AbstractStructuredObject { private TilePosition tilePosition; private TileSize tileSize; private BandImage bandImage; + private TransparencyMask transparencyMask; private byte[] data; private IDEStructureParameter ideStructureParameter; @@ -50,7 +51,40 @@ public class Tile extends AbstractStructuredObject { if (ideStructureParameter != null) { ideStructureParameter.writeToStream(os); } + if (transparencyMask != null) { + transparencyMask.writeToStream(os); + } if (data != null) { + writeData(os); + } + } + + private void writeData(OutputStream os) throws IOException { + final byte[] dataHeader = new byte[]{(byte) 0xFE, // ID + (byte) 0x9C, // ID + 0x00, // length + 0x00, // length + 0x00, // bandnum + 0x00, // reserved + 0x00 // reserved + }; + final int lengthOffset = 2; + if (ideSize == 24) { + byte[] red = new byte[data.length / 3]; + byte[] green = new byte[data.length / 3]; + byte[] blue = new byte[data.length / 3]; + for (int j = 0; j < data.length / 3; j++) { + red[j] = data[3 * j]; + green[j] = data[3 * j + 1]; + blue[j] = data[3 * j + 2]; + } + dataHeader[4] = (byte) 0x01; + writeChunksToStream(red, dataHeader, lengthOffset, MAX_DATA_LEN, os); + dataHeader[4] = (byte) 0x02; + writeChunksToStream(green, dataHeader, lengthOffset, MAX_DATA_LEN, os); + dataHeader[4] = (byte) 0x03; + writeChunksToStream(blue, dataHeader, lengthOffset, MAX_DATA_LEN, os); + } else { byte[] c = new byte[data.length / 4]; byte[] m = new byte[data.length / 4]; byte[] y = new byte[data.length / 4]; @@ -61,15 +95,6 @@ public class Tile extends AbstractStructuredObject { y[j] = data[4 * j + 2]; k[j] = data[4 * j + 3]; } - final byte[] dataHeader = new byte[] {(byte) 0xFE, // ID - (byte) 0x9C, // ID - 0x00, // length - 0x00, // length - 0x00, // bandnum - 0x00, // reserved - 0x00 // reserved - }; - final int lengthOffset = 2; dataHeader[4] = (byte) 0x01; writeChunksToStream(c, dataHeader, lengthOffset, MAX_DATA_LEN, os); dataHeader[4] = (byte) 0x02; @@ -116,7 +141,7 @@ public class Tile extends AbstractStructuredObject { int numFullChunks = dataLength / maxChunkLength; int lastChunkLength = dataLength % maxChunkLength; - byte[] len = {(byte) 0x1f, (byte) 0xff}; + byte[] len = BinaryUtils.convert(3 + maxChunkLength, 2); int off = 0; if (numFullChunks > 0) { // write out full data chunks @@ -173,4 +198,7 @@ public class Tile extends AbstractStructuredObject { this.bandImage = bandImage; } + public void setTransparencyMask(TransparencyMask transparencyMask) { + this.transparencyMask = transparencyMask; + } } diff --git a/fop-core/src/main/java/org/apache/fop/afp/ioca/TransparencyMask.java b/fop-core/src/main/java/org/apache/fop/afp/ioca/TransparencyMask.java new file mode 100644 index 000000000..8b0582833 --- /dev/null +++ b/fop-core/src/main/java/org/apache/fop/afp/ioca/TransparencyMask.java @@ -0,0 +1,62 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* $Id$ */ +package org.apache.fop.afp.ioca; + +import java.io.IOException; +import java.io.OutputStream; + +import org.apache.fop.afp.modca.AbstractAFPObject; + +public class TransparencyMask extends AbstractAFPObject { + private static final int MAX_DATA_LEN = 8188; + private ImageSizeParameter imageSizeParameter; + private byte[] maskData; + + public TransparencyMask(byte[] maskData, ImageSizeParameter imageSizeParameter) { + this.maskData = maskData; + this.imageSizeParameter = imageSizeParameter; + } + + public void writeToStream(OutputStream os) throws IOException { + os.write(0x8E); + os.write(0); + imageSizeParameter.writeToStream(os); + os.write(getImageEncodingParameter()); + + final byte[] dataHeader = new byte[] {(byte) 0xFE, // ID + (byte) 0x92, // ID + 0x00, // length + 0x00 // length + }; + final int lengthOffset = 2; + writeChunksToStream(maskData, dataHeader, lengthOffset, MAX_DATA_LEN, os); + + os.write(0x8F); + os.write(0); + } + + private byte[] getImageEncodingParameter() { + byte encoding = (byte) 0x03; + return new byte[] {(byte) 0x95, // ID + 0x02, // Length + encoding, + (byte) 0x01, // RECID + }; + } +} diff --git a/fop-core/src/main/java/org/apache/fop/afp/modca/ImageObject.java b/fop-core/src/main/java/org/apache/fop/afp/modca/ImageObject.java index 2452a9c15..0697e427c 100644 --- a/fop-core/src/main/java/org/apache/fop/afp/modca/ImageObject.java +++ b/fop-core/src/main/java/org/apache/fop/afp/modca/ImageObject.java @@ -79,11 +79,9 @@ public class ImageObject extends AbstractDataObject { ImageDataDescriptor imageDataDescriptor = factory.createImageDataDescriptor(dataWidth, dataHeight, dataWidthRes, dataHeightRes); - boolean setImageSize = true; if (MimeConstants.MIME_AFP_IOCA_FS45.equals(imageObjectInfo.getMimeType())) { imageDataDescriptor.setFunctionSet(ImageDataDescriptor.FUNCTION_SET_FS45); if (imageObjectInfo.getBitsPerPixel() == 32) { - setImageSize = false; Tile tile = factory.createTile(); TilePosition tilePosition = factory.createTilePosition(); TileSize tileSize = factory.createTileSize(dataWidth, dataHeight, dataWidthRes, dataHeightRes); @@ -101,10 +99,8 @@ public class ImageObject extends AbstractDataObject { getObjectEnvironmentGroup().setMapImageObject( new MapImageObject(dataObjectInfo.getMappingOption())); - if (setImageSize) { - // not used for FS45 - getImageSegment().setImageSize(dataWidth, dataHeight, dataWidthRes, dataHeightRes); - } + // not used for FS45 + getImageSegment().setImageSize(dataWidth, dataHeight, dataWidthRes, dataHeightRes); } /** @@ -164,6 +160,10 @@ public class ImageObject extends AbstractDataObject { getImageSegment().setData(imageData); } + public void setTransparencyMask(byte[] date) { + getImageSegment().setTransparencyMask(date); + } + /** {@inheritDoc} */ protected void writeStart(OutputStream os) throws IOException { byte[] data = new byte[17]; diff --git a/fop-core/src/main/java/org/apache/fop/render/afp/AFPDocumentHandler.java b/fop-core/src/main/java/org/apache/fop/render/afp/AFPDocumentHandler.java index e80dedd87..a711282d2 100644 --- a/fop-core/src/main/java/org/apache/fop/render/afp/AFPDocumentHandler.java +++ b/fop-core/src/main/java/org/apache/fop/render/afp/AFPDocumentHandler.java @@ -164,7 +164,7 @@ public class AFPDocumentHandler extends AbstractBinaryWritingIFDocumentHandler getPaintingState(), getDataStream(), getResourceManager()); } else { return new AFPRectanglePainter( - getPaintingState(), getDataStream()); + getPaintingState(), getDataStream(), getResourceManager()); } } diff --git a/fop-core/src/test/java/org/apache/fop/afp/AFPRectanglePainterTestCase.java b/fop-core/src/test/java/org/apache/fop/afp/AFPRectanglePainterTestCase.java new file mode 100644 index 000000000..310fff26f --- /dev/null +++ b/fop-core/src/test/java/org/apache/fop/afp/AFPRectanglePainterTestCase.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* $Id$ */ +package org.apache.fop.afp; + +import java.awt.Color; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; + +import org.junit.Assert; +import org.junit.Test; + +import org.apache.xmlgraphics.java2d.color.ColorSpaces; +import org.apache.xmlgraphics.java2d.color.ColorWithAlternatives; + +import org.apache.fop.afp.parser.MODCAParser; +import org.apache.fop.afp.parser.UnparsedStructuredField; +import org.apache.fop.apps.FOUserAgent; +import org.apache.fop.apps.FopFactory; + +public class AFPRectanglePainterTestCase { + @Test + public void testCMYKTransparencyMask() throws Exception { + float cyan = 0.5f; + Color deviceColor = new Color(ColorSpaces.getDeviceCMYKColorSpace(), new float[]{cyan, 0, 0, 0}, 0.4f); + ByteArrayInputStream bis = buildAFP(new ColorWithAlternatives(0, 0, 0, 128, new Color[]{deviceColor})); + bis.skip(59); + Assert.assertEquals(bis.read(), 0x8E); //start + bis.skip(20); + Assert.assertEquals(bis.read(), 170); //mask data + bis.skip(1299); + Assert.assertEquals(bis.read(), 0x8F); //end + bis.skip(89); + Assert.assertEquals(bis.read(), 127); //cyan byte + } + + @Test + public void testRGBTransparencyMask() throws Exception { + ByteArrayInputStream bis = buildAFP(new Color(0, 0, 0, 128)); + Assert.assertNull(bis); + } + + private ByteArrayInputStream buildAFP(Color color) throws Exception { + FOUserAgent foUserAgent = FopFactory.newInstance(new File(".").toURI()).newFOUserAgent(); + AFPPaintingState paintingState = new AFPPaintingState(); + paintingState.setColor(color); + AFPResourceManager resourceManager = new AFPResourceManager(foUserAgent.getResourceResolver()); + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + DataStream stream = resourceManager.createDataStream(paintingState, bos); + stream.startDocument(); + stream.startPage(100, 100, 0, 10, 10); + AFPRectanglePainter painter = new AFPRectanglePainter(paintingState, stream, resourceManager); + painter.paint(new RectanglePaintingInfo(0, 0, 100, 100)); + stream.endPage(); + stream.endDocument(); + resourceManager.writeToStream(); + + MODCAParser parser = new MODCAParser(new ByteArrayInputStream(bos.toByteArray())); + UnparsedStructuredField structuredField; + while ((structuredField = parser.readNextStructuredField()) != null) { + if (structuredField.toString().endsWith("Data Image")) { + return new ByteArrayInputStream(structuredField.getData()); + } + } + return null; + } +} diff --git a/fop-core/src/test/java/org/apache/fop/afp/ioca/ImageContentTestCase.java b/fop-core/src/test/java/org/apache/fop/afp/ioca/ImageContentTestCase.java new file mode 100644 index 000000000..9a9c30c4e --- /dev/null +++ b/fop-core/src/test/java/org/apache/fop/afp/ioca/ImageContentTestCase.java @@ -0,0 +1,48 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* $Id$ */ +package org.apache.fop.afp.ioca; + +import java.io.ByteArrayOutputStream; + +import org.junit.Assert; +import org.junit.Test; + +public class ImageContentTestCase { + @Test + public void testImageSizeParameterWritten() throws Exception { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + ImageContent imageContent = new ImageContent(); + imageContent.setImageSizeParameter(new ImageSizeParameter(1, 1, 1, 1)); + imageContent.writeToStream(bos); + Assert.assertEquals(bos.size(), 20); + } + + @Test + public void testImageSizeParameterNotWritten() throws Exception { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + ImageContent imageContent = new ImageContent(); + imageContent.setImageSizeParameter(new ImageSizeParameter(1, 1, 1, 1)); + Tile tile = new Tile(); + tile.setPosition(new TilePosition()); + tile.setSize(new TileSize(1, 1, 1, 1)); + imageContent.addTile(tile); + imageContent.writeToStream(bos); + Assert.assertEquals(bos.size(), 34); + } +} -- 2.39.5