EMMA Coverage Report (generated Sun Apr 20 22:38:01 CEST 2008)
[all classes][net.sf.jomic.comic]

COVERAGE SUMMARY FOR SOURCE FILE [ComicSheetLayoutTest.java]

nameclass, %method, %block, %line, %
ComicSheetLayoutTest.java100% (1/1)100% (20/20)94%  (809/862)96%  (138.7/144)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ComicSheetLayoutTest100% (1/1)100% (20/20)94%  (809/862)96%  (138.7/144)
createTargetImageFor (RenderedImage, double, double): BufferedImage 100% (1/1)68%  (25/37)68%  (2.7/4)
createTargetImage (int, int): BufferedImage 100% (1/1)68%  (17/25)75%  (3/4)
createTargetImageFor (int, int, double, double): BufferedImage 100% (1/1)69%  (35/51)64%  (3.2/5)
setUp (): void 100% (1/1)71%  (12/17)93%  (3.7/4)
writeTestTargetTopLeftImage (String, RenderedImage): void 100% (1/1)74%  (25/34)86%  (4.3/5)
<static initializer> 100% (1/1)80%  (12/15)80%  (0.8/1)
ComicSheetLayoutTest (): void 100% (1/1)100% (3/3)100% (1/1)
tearDown (): void 100% (1/1)100% (6/6)100% (3/3)
testGetTargetScales (): void 100% (1/1)100% (74/74)100% (16/16)
testRenderBoth (String, RenderedImage, RenderedImage, int, int, String): void 100% (1/1)100% (100/100)100% (14/14)
testRenderBothActual (): void 100% (1/1)100% (63/63)100% (9/9)
testRenderBothActualFit (String, String, String): void 100% (1/1)100% (94/94)100% (17/17)
testRenderBothActualFitWithDifferentFormats (): void 100% (1/1)100% (21/21)100% (5/5)
testRenderBothFitl (): void 100% (1/1)100% (75/75)100% (10/10)
testRenderLeft (String, RenderedImage, double, double, String): void 100% (1/1)100% (67/67)100% (13/13)
testRenderLeftActual (): void 100% (1/1)100% (27/27)100% (5/5)
testRenderLeftFitX (): void 100% (1/1)100% (27/27)100% (5/5)
testRenderRight (String, RenderedImage, double, double, String): void 100% (1/1)100% (72/72)100% (14/14)
testRenderRightActual (): void 100% (1/1)100% (27/27)100% (5/5)
testRenderRightFitX (): void 100% (1/1)100% (27/27)100% (5/5)

1// Jomic - a viewer for comic book archives.
2// Copyright (C) 2004-2008 Thomas Aglassinger
3//
4// This program is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8//
9// This program is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12// GNU General Public License for more details.
13//
14// You should have received a copy of the GNU General Public License
15// along with this program.  If not, see <http://www.gnu.org/licenses/>.
16package net.sf.jomic.comic;
17 
18import java.awt.Graphics2D;
19import java.awt.geom.AffineTransform;
20import java.awt.image.BufferedImage;
21import java.awt.image.RenderedImage;
22import java.io.File;
23import java.io.IOException;
24import java.text.DecimalFormat;
25 
26import junit.framework.TestCase;
27import net.sf.jomic.common.ComicSheetRenderSettings;
28import net.sf.jomic.tools.ImageTools;
29import net.sf.jomic.tools.TestTools;
30import net.sf.wraplog.Logger;
31 
32/**
33 *  TestCase for ComicSheetLayout.
34 *
35 * @author    Thomas Aglassinger
36 */
37public class ComicSheetLayoutTest extends TestCase
38{
39    private static final double SCALE_COMPARISON_EPSILON = 0.0001;
40 
41    private Logger logger;
42    private TestTools testTools;
43 
44    protected void setUp()
45        throws Exception {
46        super.setUp();
47        logger = Logger.getLogger(ComicSheetLayoutTest.class);
48        testTools = TestTools.instance();
49    }
50 
51    public void testGetTargetScales()
52        throws IOException {
53        RenderedImage leftImage = testTools.getTestImage("01.png");
54        RenderedImage rightImage = testTools.getTestImage("02.png");
55        ComicSheetRenderSettings renderSettings = new ComicSheetRenderSettings();
56        ComicSheetLayout renderer = new ComicSheetLayout();
57 
58        renderer.prepare(leftImage, rightImage, renderSettings);
59 
60        double[] scalesWithLeft = renderer.getTargetScales(300, 200, ComicSheetLayout.RENDER_LEFT);
61 
62        assertNotNull(scalesWithLeft);
63        assertEquals(2, scalesWithLeft.length);
64        testTools.assertGreaterThan(scalesWithLeft[0], 0.0);
65        assertEquals(ComicSheetLayout.NO_SCALE, scalesWithLeft[1], SCALE_COMPARISON_EPSILON);
66 
67        double[] scalesWithRight = renderer.getTargetScales(300, 200, ComicSheetLayout.RENDER_RIGHT);
68 
69        assertNotNull(scalesWithRight);
70        assertEquals(2, scalesWithRight.length);
71        assertEquals(ComicSheetLayout.NO_SCALE, scalesWithRight[0], 0.0001);
72        testTools.assertGreaterThan(scalesWithRight[1], 0.0);
73    }
74 
75    public void testRenderBothActual()
76        throws IOException {
77        RenderedImage leftImage = testTools.getTestImage("01.png");
78        RenderedImage rightImage = testTools.getTestImage("02.png");
79        int totalWidth = leftImage.getWidth() + rightImage.getWidth();
80        int totalHeight = Math.max(leftImage.getHeight(), rightImage.getHeight());
81 
82        testRenderBoth("actual-center", leftImage, rightImage, totalWidth + 50, totalHeight + 75,
83                ImageTools.SCALE_ACTUAL);
84        testRenderBoth("actual-fit-x", leftImage, rightImage, totalWidth, totalHeight + 75, ImageTools.SCALE_ACTUAL);
85        testRenderBoth("actual-fit-y", leftImage, rightImage, totalWidth + 50, totalHeight, ImageTools.SCALE_ACTUAL);
86        testRenderBoth("actual-fit", leftImage, rightImage, totalWidth, totalHeight, ImageTools.SCALE_ACTUAL);
87    }
88 
89    public void testRenderBothActualFitWithDifferentFormats()
90        throws IOException {
91        testRenderBothActualFit("8-bit", TestTools.TEST_IMAGE_8_BIT, TestTools.TEST_IMAGE_FILE_NAME);
92        testRenderBothActualFit("8-bit-gray", TestTools.TEST_IMAGE_8_BIT_GRAY, TestTools.TEST_IMAGE_FILE_NAME);
93        testRenderBothActualFit("4-bit", TestTools.TEST_IMAGE_4_BIT, TestTools.TEST_IMAGE_FILE_NAME);
94        testRenderBothActualFit("1-bit", TestTools.TEST_IMAGE_1_BIT, TestTools.TEST_IMAGE_FILE_NAME);
95    }
96 
97    public void testRenderBothFitl()
98        throws IOException {
99        RenderedImage leftImage = testTools.getTestImage("01.png");
100        RenderedImage rightImage = testTools.getTestImage("02.png");
101        int totalWidth = leftImage.getWidth() + rightImage.getWidth();
102        int totalHeight = Math.max(leftImage.getHeight(), rightImage.getHeight());
103 
104        testRenderBoth("fit-x", leftImage, rightImage, totalWidth, totalHeight + 75, ImageTools.SCALE_FIT);
105        testRenderBoth("fit-perfectly", leftImage, rightImage, totalWidth, totalHeight, ImageTools.SCALE_FIT);
106        testRenderBoth("fit-y", leftImage, rightImage, totalWidth + 50, totalHeight, ImageTools.SCALE_FIT);
107        testRenderBoth("fit-grow", leftImage, rightImage, 2 * totalWidth, 2 * totalHeight, ImageTools.SCALE_FIT);
108        testRenderBoth("fit-shrink", leftImage, rightImage, totalWidth / 2, totalHeight / 2, ImageTools.SCALE_FIT);
109    }
110 
111    public void testRenderLeftActual()
112        throws IOException {
113        RenderedImage leftImage = testTools.getTestImage("01.png");
114 
115        testRenderLeft("actual-center", leftImage, 1.3, 1.7, ImageTools.SCALE_ACTUAL);
116        testRenderLeft("actual-fit-x", leftImage, 1.0, 1.7, ImageTools.SCALE_ACTUAL);
117        testRenderLeft("actual-fit-y", leftImage, 1.3, 1.0, ImageTools.SCALE_ACTUAL);
118    }
119 
120    public void testRenderLeftFitX()
121        throws IOException {
122        RenderedImage leftImage = testTools.getTestImage("01.png");
123 
124        testRenderLeft("fit-x", leftImage, 1.3, 1.7, ImageTools.SCALE_FIT);
125        testRenderLeft("fit-y", leftImage, 1.7, 1.3, ImageTools.SCALE_FIT);
126        testRenderLeft("fit-perfectly", leftImage, 1.0, 1.0, ImageTools.SCALE_FIT);
127    }
128 
129    public void testRenderRightActual()
130        throws IOException {
131        RenderedImage rightImage = testTools.getTestImage("02.png");
132 
133        testRenderRight("actual-center", rightImage, 1.3, 1.7, ImageTools.SCALE_ACTUAL);
134        testRenderRight("actual-fit-x", rightImage, 1.0, 1.7, ImageTools.SCALE_ACTUAL);
135        testRenderRight("actual-fit-y", rightImage, 1.3, 1.0, ImageTools.SCALE_ACTUAL);
136    }
137 
138    public void testRenderRightFitX()
139        throws IOException {
140        RenderedImage rightImage = testTools.getTestImage("02.png");
141 
142        testRenderRight("fit-x", rightImage, 1.3, 1.7, ImageTools.SCALE_FIT);
143        testRenderRight("fit-y", rightImage, 1.7, 1.3, ImageTools.SCALE_FIT);
144        testRenderRight("fit-perfectly", rightImage, 1.0, 1.0, ImageTools.SCALE_FIT);
145    }
146 
147    protected void tearDown()
148        throws Exception {
149        testTools = null;
150        super.tearDown();
151    }
152 
153    private BufferedImage createTargetImage(int sourceWidth, int sourceHeight) {
154        assert sourceWidth > 0;
155        assert sourceHeight > 0;
156 
157        BufferedImage result = new BufferedImage(sourceWidth, sourceHeight, BufferedImage.TYPE_INT_RGB);
158 
159        return result;
160    }
161 
162    private BufferedImage createTargetImageFor(RenderedImage sourceImage, double xScale, double yScale) {
163        assert sourceImage != null;
164        assert xScale > 0;
165        assert yScale > 0;
166 
167        return createTargetImageFor(sourceImage.getWidth(), sourceImage.getHeight(), xScale, yScale);
168    }
169 
170    private BufferedImage createTargetImageFor(int sourceWidth, int sourceHeight, double xScale, double yScale) {
171        assert sourceWidth > 0;
172        assert sourceHeight > 0;
173        assert xScale > 0;
174        assert yScale > 0;
175 
176        return createTargetImage((int) Math.ceil(xScale * sourceWidth), (int) Math.ceil(yScale * sourceHeight));
177    }
178 
179    private void testRenderBoth(String nameDetails, RenderedImage leftImage, RenderedImage rightImage,
180            int targetImageWidth, int targetImageHeight, String scaleMode)
181        throws IOException {
182        ComicSheetRenderSettings renderSettings = new ComicSheetRenderSettings();
183        ComicSheetLayout renderer = new ComicSheetLayout();
184        BufferedImage targetImage = createTargetImage(targetImageWidth, targetImageHeight);
185 
186        renderSettings.setScaleMode(scaleMode);
187        renderer.prepare(leftImage, rightImage, renderSettings);
188 
189        double[] scales = renderer.getTargetScales(targetImageWidth, targetImageHeight, ComicSheetLayout.RENDER_BOTH);
190        int[] topLeftCorner = renderer.getTargetTopLeft(targetImageWidth, targetImageHeight,
191                ComicSheetLayout.RENDER_BOTH, scales);
192        AffineTransform rotationTransformation = renderer.getTargetRotationTransformation(
193                targetImageWidth, targetImageHeight);
194 
195        if (logger.isInfoEnabled()) {
196            logger.info("scales[0] = " + (new DecimalFormat("#.00").format(scales[0])));
197            logger.info("scales[1] = " + (new DecimalFormat("#.00").format(scales[1])));
198        }
199        renderer.render((Graphics2D) targetImage.getGraphics(), ComicSheetLayout.RENDER_BOTH, scales, topLeftCorner,
200                rotationTransformation);
201        writeTestTargetTopLeftImage("both-" + nameDetails, targetImage);
202    }
203 
204    private void testRenderBothActualFit(String nameDetails, String leftName, String rightName)
205        throws IOException {
206        RenderedImage leftImage = testTools.getTestImage(leftName);
207        RenderedImage rightImage = testTools.getTestImage(rightName);
208        ComicSheetRenderSettings renderSettings = new ComicSheetRenderSettings();
209        ComicSheetLayout renderer = new ComicSheetLayout();
210        int targetImageWidth = leftImage.getWidth() + rightImage.getWidth();
211        int targetImageHeight = Math.max(leftImage.getHeight(), rightImage.getHeight());
212        BufferedImage targetImage = createTargetImage(targetImageWidth, targetImageHeight);
213 
214        renderSettings.setScaleMode(ImageTools.SCALE_ACTUAL);
215        renderer.prepare(leftImage, rightImage, renderSettings);
216 
217        double[] scales = renderer.getTargetScales(targetImageWidth, targetImageHeight, ComicSheetLayout.RENDER_BOTH);
218        int[] topLeftCorner = renderer.getTargetTopLeft(targetImageWidth, targetImageHeight,
219                ComicSheetLayout.RENDER_BOTH, scales);
220        AffineTransform rotationTransformation = renderer.getTargetRotationTransformation(
221                targetImageWidth, targetImageHeight);
222 
223        assertEquals(1.0, scales[0], SCALE_COMPARISON_EPSILON);
224        assertEquals(1.0, scales[1], SCALE_COMPARISON_EPSILON);
225        renderer.render((Graphics2D) targetImage.getGraphics(), ComicSheetLayout.RENDER_BOTH, scales, topLeftCorner,
226                rotationTransformation);
227        writeTestTargetTopLeftImage("both-actual-fit-" + nameDetails, targetImage);
228    }
229 
230    private void testRenderLeft(String nameDetails, RenderedImage leftImage,
231            double targetXScale, double targetYScale, String scaleMode)
232        throws IOException {
233        ComicSheetRenderSettings renderSettings = new ComicSheetRenderSettings();
234        ComicSheetLayout renderer = new ComicSheetLayout();
235        BufferedImage targetImage = createTargetImageFor(leftImage, targetXScale, targetYScale);
236        int targetImageWidth = targetImage.getWidth();
237        int targetImageHeight = targetImage.getHeight();
238 
239        renderSettings.setScaleMode(scaleMode);
240        renderer.prepare(leftImage, null, renderSettings);
241 
242        double[] scales = renderer.getTargetScales(targetImageWidth, targetImageHeight, ComicSheetLayout.RENDER_LEFT);
243        int[] topLeftCorner = renderer.getTargetTopLeft(targetImageWidth, targetImageHeight,
244                ComicSheetLayout.RENDER_LEFT, scales);
245        AffineTransform rotationTransformation = renderer.getTargetRotationTransformation(
246                targetImageWidth, targetImageHeight);
247 
248        renderer.render((Graphics2D) targetImage.getGraphics(), ComicSheetLayout.RENDER_LEFT, scales, topLeftCorner,
249                rotationTransformation);
250        writeTestTargetTopLeftImage("left-" + nameDetails, targetImage);
251    }
252 
253    private void testRenderRight(String nameDetails, RenderedImage rightImage,
254            double targetXScale, double targetYScale, String scaleMode)
255        throws IOException {
256        RenderedImage dummyLeftImage = testTools.getTestImage("01.png");
257        ComicSheetRenderSettings renderSettings = new ComicSheetRenderSettings();
258        ComicSheetLayout renderer = new ComicSheetLayout();
259        BufferedImage targetImage = createTargetImageFor(rightImage, targetXScale, targetYScale);
260        int targetImageWidth = targetImage.getWidth();
261        int targetImageHeight = targetImage.getHeight();
262 
263        renderSettings.setScaleMode(scaleMode);
264        renderer.prepare(dummyLeftImage, rightImage, renderSettings);
265 
266        double[] scales = renderer.getTargetScales(targetImageWidth, targetImageHeight, ComicSheetLayout.RENDER_RIGHT);
267        int[] topLeftCorner = renderer.getTargetTopLeft(targetImageWidth, targetImageHeight,
268                ComicSheetLayout.RENDER_RIGHT, scales);
269        AffineTransform rotationTransformation = renderer.getTargetRotationTransformation(
270                targetImageWidth, targetImageHeight);
271 
272        renderer.render((Graphics2D) targetImage.getGraphics(), ComicSheetLayout.RENDER_RIGHT, scales, topLeftCorner,
273                rotationTransformation);
274        writeTestTargetTopLeftImage("right-" + nameDetails, targetImage);
275    }
276 
277    private void writeTestTargetTopLeftImage(String name, RenderedImage imageToWrite)
278        throws IOException {
279        assert name != null;
280 
281        String targetImageName = testTools.getTestFileName(ComicSheetLayoutTest.class, "testRender", name, "png");
282        File targetImageFile = testTools.getTestOutputFile(targetImageName);
283 
284        testTools.writeImageFile(targetImageFile, imageToWrite);
285    }
286}

[all classes][net.sf.jomic.comic]
EMMA 2.0.4217 (C) Vladimir Roubtsov