Created ViewFavicon class specialized in favicon viewing.

Main image processing is now in ImageViewer, used by both ViewImage and
ViewFavicon.

Fixed URIMetadataNode.getFavicon to use non-standard icons with no size
ass fallback.

1 files changed, 240 insertions, 0 deletions

diff --git a/test/ImageViewerPerfTest.java b/test/ImageViewerPerfTest.java
new file mode 100755
index 000000000..6f758164c
--- /dev/null
+++ b/test/ImageViewerPerfTest.java
@@ -0,0 +1,240 @@
+// ImageViewerPerfTest.java
+// -----------------------
+// part of YaCy
+// (C) by Michael Peter Christen; mc@yacy.net
+// first published on http://www.anomic.de
+// Frankfurt, Germany, 2006
+// created 03.04.2006
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import javax.imageio.ImageIO;
+import javax.imageio.stream.ImageInputStream;
+
+import net.yacy.cora.document.id.DigestURL;
+import net.yacy.cora.util.ConcurrentLog;
+import net.yacy.peers.graphics.EncodedImage;
+import net.yacy.server.serverObjects;
+
+
+
+/**
+ * Test to measure image render performance by 
+ * 
+ * @author luc
+ *
+ */
+public class ImageViewerPerfTest extends ImageViewerTest {
+
+	/** Default minimum measurement time */
+	private static final int DEFAULT_MIN_MEASURE_TIME = 10;
+
+	/** Minimum measurement time */
+	private int minMeasureTime;
+
+	/**
+	 * @param args
+	 *            main parameters : args[7] may contain minimum measurement time
+	 *            in secondes. Default : 10.
+	 */
+	public ImageViewerPerfTest(String args[]) {
+		this.minMeasureTime = getMinMeasurementTime(args);
+	}
+
+	/**
+	 * 
+	 * @param args
+	 *            main parameters : args[7] may contain minimum measurement time
+	 *            in secondes. Default : 10.
+	 * @return extension to use for encoding
+	 */
+	protected int getMinMeasurementTime(String args[]) {
+		int time;
+		if (args != null && args.length > 7) {
+			time = Integer.parseInt(args[7]);
+		} else {
+			time = DEFAULT_MIN_MEASURE_TIME;
+		}
+		return time;
+	}
+
+	/**
+	 * Process inFile image, update processedFiles list and failures map, and
+	 * append measurements to results_perfs.txt. All parameters must not be
+	 * null.
+	 * 
+	 * @param ext
+	 *            output encoding image format
+	 * @param outDir
+	 *            output directory
+	 * @param post
+	 *             post parameters
+	 * @param failures
+	 *            map failed file urls to eventual exception
+	 * @param inFile
+	 *            file image to process
+	 * @throws IOException
+	 *             when an read/write error occured
+	 */
+	@Override
+	protected void processFile(String ext, File outDir, serverObjects post, Map<String, Throwable> failures,
+			File inFile) throws IOException {
+		/* Delete eventual previous result file */
+		System.out
+				.println("Measuring  render with file : " + inFile.getAbsolutePath() + " encoded To : " + ext);
+		File outFile = new File(outDir, inFile.getName() + "." + ext);
+		if (outFile.exists()) {
+			outFile.delete();
+		}
+
+		String urlString = inFile.getAbsolutePath();
+		EncodedImage img = null;
+		Exception error = null;
+		long beginTime = System.nanoTime(), time, minTime = Long.MAX_VALUE, maxTime = 0, meanTime = 0, totalTime = 0;
+		int step = 0;
+		for (step = 0; (totalTime / 1000000000) < this.minMeasureTime; step++) {
+			beginTime = System.nanoTime();
+			ImageInputStream inStream = ImageIO.createImageInputStream(inFile);
+			try {
+				img = this.VIEWER.parseAndScale(post, true, new DigestURL(urlString), ext, inStream);
+			} catch (Exception e) {
+				error = e;
+			}
+			time = System.nanoTime() - beginTime;
+			minTime = Math.min(minTime, time);
+			maxTime = Math.max(maxTime, time);
+			totalTime += time;
+		}
+		if (step > 0) {
+			meanTime = totalTime / step;
+		} else {
+			meanTime = totalTime;
+		}
+		PrintWriter resultsWriter = new PrintWriter(new FileWriter(new File(outDir, "results_perfs.txt"), true));
+		try {
+			writeMessage("Measured  render with file : " + inFile.getAbsolutePath() + " encoded To : " + ext,
+					resultsWriter);
+			if(img == null) {
+				writeMessage("Image could not be rendered! Measurement show time needed to read and parse image data until error detection.", resultsWriter);
+			}
+			writeMessage("Render total time (ms) : " + (totalTime) / 1000000 + " on " + step + " steps.",
+					resultsWriter);
+			writeMessage("Render mean time (ms) : " + (meanTime) / 1000000, resultsWriter);
+			writeMessage("Render min time (ms) : " + (minTime) / 1000000, resultsWriter);
+			writeMessage("Render max time (ms) : " + (maxTime) / 1000000, resultsWriter);
+		} finally {
+			resultsWriter.close();
+		}
+
+		if (img == null) {
+			failures.put(urlString, error);
+		} else {
+			FileOutputStream outFileStream = null;
+			try {
+				outFileStream = new FileOutputStream(outFile);
+				img.getImage().writeTo(outFileStream);
+			} finally {
+				if (outFileStream != null) {
+					outFileStream.close();
+				}
+				img.getImage().close();
+			}
+		}
+	}
+
+	/**
+	 * Test image(s) (default : classpath resource folder /viewImageTest/test/)
+	 * are parsed and rendered again and again until specified time (default :
+	 * 10 seconds) elapsed. Then rendered image is written to outDir for visual
+	 * check and measured statistics are displayed.
+	 * 
+	 * @param args
+	 *            may be empty or contain parameters to override defaults :
+	 *            <ul>
+	 *            <li>args[0] : input image file URL or folder containing image
+	 *            files URL. Default : classpath resource /viewImageTest/test/
+	 *            </li>
+	 *            <li>args[1] : output format name (for example : "jpg") for
+	 *            rendered image. Defaut : "png".</li>
+	 *            <li>args[2] : ouput folder URL. Default :
+	 *            "[system tmp dir]/Test".</li>
+	 *            <li>args[3] : max width (in pixels) for rendered image. May be
+	 *            set to zero to specify no max width. Default : no value.</li>
+	 *            <li>args[4] : max height (in pixels) for rendered image. May
+	 *            be set to zero to specify no max height. Default : no value.
+	 *            </li>
+	 *            <li>args[5] : set to "quadratic" to render square output
+	 *            image. May be set to any string to specify no quadratic shape.
+	 *            Default : false.</li>
+	 *            <li>args[6] : set to "recursive" to process recursively sub
+	 *            folders. Default : false.</li>
+	 *            <li>args[7] : minimum measurement time in secondes. Default :
+	 *            10.</li>
+	 *            </ul>
+	 * @throws IOException
+	 *             when a read/write error occured
+	 */
+	public static void main(String args[]) throws IOException {
+		ImageViewerPerfTest test = new ImageViewerPerfTest(args);
+		File inFile = test.getInputURL(args);
+		String ext = test.getEncodingExt(args);
+		File outDir = test.getOuputDir(args);
+		boolean recursive = test.isRecursive(args);
+		serverObjects post = test.makePostParams(args);
+		outDir.mkdirs();
+
+		File[] inFiles;
+		if (inFile.isFile()) {
+			inFiles = new File[1];
+			inFiles[0] = inFile;
+			System.out.println(
+					"Measuring  render with file : " + inFile.getAbsolutePath() + " encoded To : " + ext);
+		} else if (inFile.isDirectory()) {
+			inFiles = inFile.listFiles();
+			System.out.println("Measuring  render with files in folder : " + inFile.getAbsolutePath()
+					+ " encoded To : " + ext);
+		} else {
+			inFiles = new File[0];
+		}
+		if (inFiles.length == 0) {
+			throw new IllegalArgumentException(inFile.getAbsolutePath() + " is not a valid file or folder url.");
+		}
+
+		System.out.println("Rendered images will be written in dir : " + outDir.getAbsolutePath());
+
+		List<File> processedFiles = new ArrayList<File>();
+		Map<String, Throwable> failures = new TreeMap<>();
+		try {
+			long time = System.nanoTime();
+			test.processFiles(ext, recursive, outDir, post, inFiles, processedFiles, failures);
+			time = System.nanoTime() - time;
+			test.displayResults(processedFiles, failures, time, outDir);
+		} finally {
+			ConcurrentLog.shutdown();
+		}
+
+	}
+
+}