/*
* 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: BatchDiffer.java 426576 2006-07-28 15:44:37Z jeremias $ */
package org.apache.fop.visual;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Iterator;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.stream.StreamSource;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.container.ContainerUtil;
import org.apache.batik.ext.awt.image.codec.PNGEncodeParam;
import org.apache.batik.ext.awt.image.codec.PNGImageEncoder;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.fop.layoutengine.LayoutEngineTestSuite;
import org.xml.sax.SAXException;
/**
* This class is used to visually diff bitmap images created through various sources.
* <p>
* Here's what the configuration format looks like:
* <p>
* <pre>
* <batch-diff>
* <source-directory>C:/Dev/FOP/trunk/test/layoutengine</source-directory>
* <filter-disabled>false</filter-disabled>
* <max-files>10</max-files>
* <target-directory>C:/Temp/diff-out</target-directory>
* <resolution>100</resolution>
* <stop-on-exception>false</stop-on-exception>
* <create-diffs>false</create-diffs>
* <stylesheet>C:/Dev/FOP/trunk/test/layoutengine/testcase2fo.xsl</stylesheet>
* <producers>
* <producer classname="org.apache.fop.visual.BitmapProducerJava2D">
* <delete-temp-files>false</delete-temp-files>
* </producer>
* <producer classname="org.apache.fop.visual.ReferenceBitmapLoader">
* <directory>C:/Temp/diff-bitmaps</directory>
* </producer>
* </producers>
* </batch-diff>
* </pre>
* <p>
* The optional "filter-disabled" element determines whether the source files should be filtered
* using the same "disabled-testcases.txt" file used for the layout engine tests. Default: true
* <p>
* The optional "max-files" element controls how many files at maximum should be processed.
* Default is to process all the files found.
* <p>
* The optional "resolution" element controls the requested bitmap resolution in dpi for the
* generated bitmaps. Defaults to 72dpi.
* <p>
* The optional "stop-on-exception" element controls whether the batch should be aborted when
* an exception is caught. Defaults to true.
* <p>
* The optional "create-diffs" element controls whether the diff images should be created.
* Defaults to true.
* <p>
* The optional "stylesheet" element allows you to supply an XSLT stylesheet to preprocess all
* source files with. Default: no stylesheet, identity transform.
* <p>
* The "producers" element contains a list of producer implementations with configuration.
* The "classname" attribute specifies the fully qualified class name for the implementation.
*/
public class BatchDiffer {
/** Logger */
protected static Log log = LogFactory.getLog(BatchDiffer.class);
/**
* Prints the usage of this app to stdout.
*/
public static void printUsage() {
System.out.println("Usage:");
System.out.println("java " + BatchDiffer.class.getName() + " <cfgfile>");
System.out.println();
System.out.println("<cfgfile>: Path to an XML file with the configuration"
+ " for the batch run.");
}
/**
* Saves a BufferedImage as a PNG file.
* @param bitmap the bitmap to encode
* @param outputFile the target file
* @throws IOException in case of an I/O problem
*/
public static void saveAsPNG(BufferedImage bitmap, File outputFile) throws IOException {
OutputStream out = new FileOutputStream(outputFile);
try {
PNGImageEncoder encoder = new PNGImageEncoder(
out,
PNGEncodeParam.getDefaultEncodeParam(bitmap));
encoder.encode(bitmap);
} finally {
IOUtils.closeQuietly(out);
}
}
/**
* Runs the batch.
* @param cfgFile configuration file to use
* @throws ConfigurationException In case of a problem with the configuration
* @throws SAXException In case of a problem during SAX processing
* @throws IOException In case of a I/O problem
*/
public void runBatch(File cfgFile)
throws ConfigurationException, SAXException, IOException {
DefaultConfigurationBuilder cfgBuilder = new DefaultConfigurationBuilder();
Configuration cfg = cfgBuilder.buildFromFile(cfgFile);
runBatch(cfg);
}
/**
* Runs the batch
* @param cfg Configuration for the batch
* @throws TransformerConfigurationException
*/
public void runBatch(Configuration cfg) {
try {
ProducerContext context = new ProducerContext();
context.setTargetResolution(cfg.getChild("resolution").getValueAsInteger(72));
String xslt = cfg.getChild("stylesheet").getValue(null);
if (xslt != null) {
try {
context.setTemplates(context.getTransformerFactory().newTemplates(
new StreamSource(xslt)));
} catch (TransformerConfigurationException e) {
log.error("Error setting up stylesheet", e);
throw new RuntimeException("Error setting up stylesheet");
}
}
BitmapProducer[] producers = getProducers(cfg.getChild("producers"));
//Set up directories
File srcDir = new File(cfg.getChild("source-directory").getValue());
if (!srcDir.exists()) {
throw new RuntimeException("source-directory does not exist: " + srcDir);
}
File targetDir = new File(cfg.getChild("target-directory").getValue());
targetDir.mkdirs();
if (!targetDir.exists()) {
throw new RuntimeException("target-directory is invalid: " + targetDir);
}
context.setTargetDir(targetDir);
boolean stopOnException = cfg.getChild("stop-on-exception").getValueAsBoolean(true);
boolean createDiffs = cfg.getChild("create-diffs").getValueAsBoolean(true);
//RUN!
BufferedImage[] bitmaps = new BufferedImage[producers.length];
IOFileFilter filter = new SuffixFileFilter(new String[] {".xml", ".fo"});
//Same filtering as in layout engine tests
if (cfg.getChild("filter-disabled").getValueAsBoolean(true)) {
filter = LayoutEngineTestSuite.decorateWithDisabledList(filter);
}
int maxfiles = cfg.getChild("max-files").getValueAsInteger(-1);
Collection files = FileUtils.listFiles(srcDir, filter, null);
Iterator i = files.iterator();
while (i.hasNext()) {
try {
File f = (File)i.next();
log.info("---=== " + f + " ===---");
for (int j = 0; j < producers.length; j++) {
bitmaps[j] = producers[j].produce(f, context);
}
//Create combined image
if (bitmaps[0] == null) {
throw new RuntimeException("First producer didn't return a bitmap."
+ " Cannot continue.");
}
BufferedImage combined = BitmapComparator.buildCompareImage(bitmaps);
//Save combined bitmap as PNG file
File outputFile = new File(targetDir, f.getName() + "._combined.png");
saveAsPNG(combined, outputFile);
if (createDiffs) {
for (int k = 1; k < bitmaps.length; k++) {
BufferedImage diff = BitmapComparator.buildDiffImage(
bitmaps[0], bitmaps[k]);
outputFile = new File(targetDir, f.getName() + "._diff" + k + ".png");
saveAsPNG(diff, outputFile);
}
}
//Release memory as soon as possible. These images are huge!
for (int k = 0; k < bitmaps.length; k++) {
bitmaps[k] = null;
}
} catch (RuntimeException e) {
System.out.println("Catching RE: " + e.getMessage());
if (stopOnException) {
System.out.println("rethrowing...");
throw e;
}
}
maxfiles = (maxfiles < 0 ? maxfiles : maxfiles - 1);
if (maxfiles == 0) {
break;
}
}
} catch (IOException ioe) {
log.error("I/O problem while processing", ioe);
throw new RuntimeException("I/O problem: " + ioe.getMessage());
} catch (ConfigurationException e) {
log.error("Error while configuring BatchDiffer", e);
throw new RuntimeException("Error while configuring BatchDiffer: " + e.getMessage());
}
}
private BitmapProducer[] getProducers(Configuration cfg) {
Configuration[] children = cfg.getChildren("producer");
BitmapProducer[] producers = new BitmapProducer[children.length];
for (int i = 0; i < children.length; i++) {
try {
Class clazz = Class.forName(children[i].getAttribute("classname"));
producers[i] = (BitmapProducer)clazz.newInstance();
ContainerUtil.configure(producers[i], children[i]);
} catch (Exception e) {
log.error("Error setting up producers", e);
throw new RuntimeException("Error while setting up producers");
}
}
return producers;
}
/**
* Main method.
* @param args command-line arguments
*/
public static void main(String[] args) {
try {
if (args.length == 0) {
System.err.println("Configuration file is missing!");
printUsage();
System.exit(-1);
}
File cfgFile = new File(args[0]);
if (!cfgFile.exists()) {
System.err.println("Configuration file cannot be found: " + args[0]);
printUsage();
System.exit(-1);
}
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
BatchDiffer differ = new BatchDiffer();
differ.runBatch(cfgFile);
System.out.println("Regular exit...");
} catch (Exception e) {
System.out.println("Exception caugth...");
e.printStackTrace();
}
}
}