Add internal API in SVGrasterizer to rasterize images at given height and width

Adding internal API to SVGRasterizer and simple tests to see if the svgs
are loaded at right sizes by the rasterizer

Author: arunjose696

bundles/org.eclipse.swt.svg/src/org/eclipse/swt/svg/JSVGRasterizer.java

@@ -35,7 +35,6 @@
 import java.awt.RenderingHints.Key;
 import java.awt.image.BufferedImage;
 import java.awt.image.DataBufferInt;
-import java.io.IOException;
 import java.io.InputStream;
 import java.util.Map;
 
@@ -71,35 +70,48 @@ public class JSVGRasterizer implements SVGRasterizer {
 	);
 
 	@Override
-	public ImageData rasterizeSVG(InputStream inputStream, int zoom) throws IOException {
-		SVGDocument svgDocument = loadSVG(inputStream);
-		if (svgDocument == null) {
-			SWT.error(SWT.ERROR_INVALID_IMAGE);
-		}
+	public ImageData rasterizeSVG(InputStream inputStream, int zoom){
+		SVGDocument svgDocument = loadAndValidateSVG(inputStream);
 		BufferedImage rasterizedImage = renderSVG(svgDocument, zoom);
 		return convertToSWTImageData(rasterizedImage);
 	}
-
-	private SVGDocument loadSVG(InputStream inputStream) {
-		return SVG_LOADER.load(inputStream, null, LoaderContext.createDefault());
+	
+	@Override
+	public ImageData rasterizeSVG(InputStream inputStream, int width, int height){
+		SVGDocument svgDocument = loadAndValidateSVG(inputStream);
+		BufferedImage rasterizedImage = renderSVG(svgDocument, width, height);
+		return convertToSWTImageData(rasterizedImage);
+	}
+	
+	private SVGDocument loadAndValidateSVG(InputStream inputStream) {
+		SVGDocument svgDocument = SVG_LOADER.load(inputStream, null, LoaderContext.createDefault());
+		if (svgDocument == null) {
+			SWT.error(SWT.ERROR_INVALID_IMAGE);
+		}
+		return svgDocument;
 	}
 
 	private BufferedImage renderSVG(SVGDocument svgDocument, int zoom) {
+		FloatSize sourceImageSize = svgDocument.size();
 		float scalingFactor = zoom / 100.0f;
-		BufferedImage image = createImageBase(svgDocument, scalingFactor);
-		Graphics2D g = configureRenderingOptions(scalingFactor, image);
+		int targetImageWidth = calculateTargetWidth(scalingFactor, sourceImageSize);
+		int targetImageHeight = calculateTargetHeight(scalingFactor, sourceImageSize);
+		return renderSVG(svgDocument, targetImageWidth, targetImageHeight);
+	}
+	
+	private BufferedImage renderSVG(SVGDocument svgDocument, int width, int height) {
+		if (width <= 0 || height <= 0) {
+			SWT.error(SWT.ERROR_INVALID_ARGUMENT);
+		}
+		BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+		float widthScalingFactor = width / svgDocument.size().width;
+		float heightScalingFactor = height / svgDocument.size().height;
+		Graphics2D g = configureRenderingOptions(widthScalingFactor, heightScalingFactor, image);
 		svgDocument.render(null, g);
 		g.dispose();
 		return image;
 	}
 
-	private BufferedImage createImageBase(SVGDocument svgDocument, float scalingFactor) {
-		FloatSize sourceImageSize = svgDocument.size();
-		int targetImageWidth = calculateTargetWidth(scalingFactor, sourceImageSize);
-		int targetImageHeight = calculateTargetHeight(scalingFactor, sourceImageSize);
-		return new BufferedImage(targetImageWidth, targetImageHeight, BufferedImage.TYPE_INT_ARGB);
-	}
-
 	private int calculateTargetWidth(float scalingFactor, FloatSize sourceImageSize) {
 		double sourceImageWidth = sourceImageSize.getWidth();
 		return (int) Math.round(sourceImageWidth * scalingFactor);
@@ -110,10 +122,10 @@ private int calculateTargetHeight(float scalingFactor, FloatSize sourceImageSize
 		return (int) Math.round(sourceImageHeight * scalingFactor);
 	}
 
-	private Graphics2D configureRenderingOptions(float scalingFactor, BufferedImage image) {
+	private Graphics2D configureRenderingOptions(float widthScalingFactor, float heightScalingFactor, BufferedImage image) {
 		Graphics2D g = image.createGraphics();
 		g.setRenderingHints(RENDERING_HINTS);
-		g.scale(scalingFactor, scalingFactor);
+		g.scale(widthScalingFactor, heightScalingFactor);
 		return g;
 	}
 

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/internal/image/SVGFileFormat.java

@@ -51,13 +51,8 @@ List<ElementAtZoom<ImageData>> loadFromByteStream(int fileZoom, int targetZoom)
 		if (targetZoom <= 0) {
 			SWT.error(SWT.ERROR_INVALID_ARGUMENT, null, " [Cannot rasterize SVG for zoom <= 0]");
 		}
-		try {
-			ImageData rasterizedImageData = RASTERIZER.rasterizeSVG(inputStream, 100 * targetZoom / fileZoom);
-			return List.of(new ElementAtZoom<>(rasterizedImageData, targetZoom));
-		} catch (IOException e) {
-			SWT.error(SWT.ERROR_INVALID_IMAGE, e);
-			return List.of();
-		}
+		ImageData rasterizedImageData = RASTERIZER.rasterizeSVG(inputStream, 100 * targetZoom / fileZoom);
+		return List.of(new ElementAtZoom<>(rasterizedImageData, targetZoom));
 	}
 
 	@Override

bundles/org.eclipse.swt/Eclipse SWT/common/org/eclipse/swt/internal/image/SVGRasterizer.java

@@ -14,6 +14,7 @@
 
 import java.io.*;
 
+import org.eclipse.swt.*;
 import org.eclipse.swt.graphics.*;
 
 /**
@@ -30,6 +31,39 @@ public interface SVGRasterizer {
 	 *               size. This value must be greater zero.
 	 * @return the {@link ImageData} for the rasterized image, or {@code null} if
 	 *         the input is not a valid SVG file or cannot be processed.
+	 *
+	 * @exception SWTException
+	 *<ul>
+	 *    <li>ERROR_INVALID_IMAGE - if the SVG cannot be rasterized</li>
+	 *</ul>
+	 * @exception SWTException
+	 *<ul>
+	 *    <li>ERROR_INVALID_IMAGE - if the zoom is less than zero</li>
+	 *</ul>
+	 */
+	public ImageData rasterizeSVG(InputStream stream, int zoom);
+
+	/**
+	 * Rasterizes an SVG image from the provided {@code InputStream} into a raster
+	 * image of the specified width and height.
+	 *
+	 * If {@code width} or {@code height} is zero or negative, this method throws an
+	 * {@link SWT#ERROR_INVALID_ARGUMENT}.
+	 *
+	 * @param stream the SVG image as an {@link InputStream}.
+	 * @param width  the width of the rasterized image in pixels (must be positive).
+	 * @param height the height of the rasterized image in pixels (must be
+	 *               positive).
+	 * @return the {@link ImageData} for the rasterized image.
+	 *
+	 * @exception SWTException
+	 *<ul>
+	 *    <li>ERROR_INVALID_IMAGE - if the SVG cannot be rasterized</li>
+	 *</ul>
+	 * @exception SWTException
+	 *<ul>
+	 *    <li>ERROR_INVALID_IMAGE - if the width or height is less than zero</li>
+	 *</ul>
 	 */
-	public ImageData rasterizeSVG(InputStream stream, int zoom) throws IOException;
+	public ImageData rasterizeSVG(InputStream stream, int width, int height);
 }

tests/org.eclipse.swt.tests/JUnit Tests/org/eclipse/swt/tests/junit/JSVGRasterizerTest.java

@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Yatta Solutions and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Yatta Solutions - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.tests.junit;
+import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.SWTException;
+import org.eclipse.swt.graphics.ImageData;
+import org.eclipse.swt.svg.JSVGRasterizer;
+import org.junit.jupiter.api.Test;
+
+class JSVGRasterizerTest {
+
+    private final JSVGRasterizer rasterizer = new JSVGRasterizer();
+    private String svgString = """
+    		<svg viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg">
+    		    <rect width="100%" height="100%"/>
+    		</svg>
+    		""";
+    private ByteArrayInputStream svgStream(String svg) {
+        return new ByteArrayInputStream(svg.getBytes(StandardCharsets.UTF_8));
+    }
+    private ByteArrayInputStream invalidSvg = new ByteArrayInputStream(new byte[0]);
+
+    @Test
+    void testRasterizeWithZoom(){
+        ImageData data = rasterizer.rasterizeSVG(svgStream(svgString), 200);
+        assertEquals(200, data.width);
+        assertEquals(200, data.height);
+    }
+
+    @Test
+    void testRasterizeWithZoomNegative(){
+        assertThrows(IllegalArgumentException.class, () -> {
+        	rasterizer.rasterizeSVG(svgStream(svgString), -100);
+        });
+    }
+
+	@Test
+	void testRasterizeWithZoomWithInvalidSVG() {
+
+		SWTException exception = assertThrows(SWTException.class, () -> {
+			rasterizer.rasterizeSVG(invalidSvg, 100);
+		});
+		assertEquals(SWT.ERROR_INVALID_IMAGE, exception.code);
+	}
+
+    @Test
+    void testRasterizeWithTargetSize(){
+        ImageData data = rasterizer.rasterizeSVG(svgStream(svgString), 300, 150);
+        assertEquals(300, data.width);
+        assertEquals(150, data.height);
+    }
+
+	@Test
+	void testRasterizeWithTargetSizeHavingInvalidHeight() {
+		assertThrows(IllegalArgumentException.class, () -> {
+			rasterizer.rasterizeSVG(svgStream(svgString), -1, 150);
+		});
+	}
+
+	@Test
+	void testRasterizeWithTargetSizeHavingInvalidWidth() {
+		assertThrows(IllegalArgumentException.class, () -> {
+			rasterizer.rasterizeSVG(svgStream(svgString), 150, -1);
+		});
+	}
+
+	@Test
+	void testRasterizeWithTargetSizeWithInvalidSVG() {
+		SWTException exception = assertThrows(SWTException.class, () -> {
+			rasterizer.rasterizeSVG(invalidSvg, 150, 150);
+		});
+		assertEquals(SWT.ERROR_INVALID_IMAGE, exception.code);
+	}
+
+
+}