/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2008, Open Source Geospatial Foundation (OSGeo)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library 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
* Lesser General Public License for more details.
*/
package org.geotools.utils.imagemosaic;
import java.awt.Rectangle;
import java.awt.geom.Rectangle2D;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.SampleModel;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.stream.ImageInputStream;
import org.apache.commons.cli2.Option;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.WildcardFileFilter;
import org.geotools.coverage.grid.io.AbstractGridCoverage2DReader;
import org.geotools.coverage.grid.io.AbstractGridFormat;
import org.geotools.coverage.grid.io.GridFormatFinder;
import org.geotools.data.DataSourceException;
import org.geotools.data.DefaultTransaction;
import org.geotools.data.FeatureWriter;
import org.geotools.data.Transaction;
import org.geotools.data.shapefile.ShapefileDataStore;
import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
import org.geotools.geometry.GeneralEnvelope;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.referencing.CRS;
import org.geotools.resources.CRSUtilities;
import org.geotools.utils.progress.BaseArgumentsManager;
import org.geotools.utils.progress.ExceptionEvent;
import org.geotools.utils.progress.ProcessingEvent;
import org.geotools.utils.progress.ProcessingEventListener;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.geometry.Envelope;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.operation.MathTransform;
import org.opengis.referencing.operation.TransformException;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.Polygon;
import com.vividsolutions.jts.geom.PrecisionModel;
/**
* This class is in responsible for creating the index for a mosaic of images
* that we want to tie together as a single coverage.
*
* <p>
* To get instructions on how to run the tool just run it without any argument
* and a nice and clean help message will be printed to the command line.
*
* <p>
* Anyway an example of a suitable list of argumentBuilder can be seen here
* below:
*
* <p>
* -s H:\\work\\data\\merano_aime -w *.tif -name merano -abs
* <p>
* where:
* <ol>
* <li>-s H:\\work\\data\\merano_aime is the source directory</li>
* <li>-w *.tif is he wildcard for the files to process</li>
* <li>-name merano sets the name for the output shape</li>
* <li>-abs asks the tool to use absolute paths instead of relative</li>
* </ol>
*
*
* <p>
* It is worth to point out that this tool comes as a command line tool but it
* has been built with GUI in mind . It has the capability to register
* {@link ProcessingEventListener} object that receive notifications about what
* is going on. Moreover it delegates all the computations to an external
* thread, hence we can stop the tool in the middle of processing with no so
* many concerns (hopefully :-) ).
* <p>
*
*
* @author Simone Giannecchini, GeoSolutions
* @author Alessio Fabiani, GeoSolutions
* @author Blaz Repnik
*
*
* @source $URL$
* @version 0.3
*
*/
public class MosaicIndexBuilder extends BaseArgumentsManager implements
Runnable, ProcessingEventListener {
/** Default Logger * */
private final static Logger LOGGER = org.geotools.util.logging.Logging
.getLogger("it.geosolutions.utils.imagemosaic");
/** Program Version */
private final static String VERSION = "0.3";
private final static String NAME = "MosaicIndexBuilder";
private final Option locationOpt;
private final Option nameOpt;
private final Option relativePathOpt;
private final Option wildcardOpt;
private String locationPath;
/**
* Number of resolution levels for the coverages.
*/
private int numberOfLevels;
/**
* Resolutions levels.
*/
private double[][] resolutionLevels;
/** Number of files to process. */
private int numFiles;
private String wildcardString = "*.*";
/**
* Index file name. Default is index.
*/
private String indexName = "index";
/**
* This field will tell the plugin if it must do a conversion of color from
* the original index color model to an RGB color model. This happens f the
* original images uses different color maps between each other making for
* us impossible to reuse it for the mosaic.
*/
private boolean mustConvertToRGB = false;
private ColorModel actualCM = null;
private ColorModel defaultCM = null;
private SampleModel defaultSM = null;
private SampleModel actualSM = null;
private GeneralEnvelope globEnvelope = null;
private GeneralEnvelope envelope = null;
private byte[][] defaultPalette = null;
private CoordinateReferenceSystem defaultCRS = null;
private CoordinateReferenceSystem actualCRS = null;
private boolean absolute = false;
/**
* Recurses the directory tree and returns valid files.
*/
private void recurse(List<File> allFiles, String locationPath) {
final File dir = new File(locationPath);
final FileFilter fileFilter = new WildcardFileFilter(wildcardString);
final File[] files = dir.listFiles(fileFilter);
final File[] dirs = dir
.listFiles((FileFilter) DirectoryFileFilter.INSTANCE);
for (int i = 0; i < files.length; i++) {
allFiles.add(files[i]);
}
for (int i = 0; i < dirs.length; i++) {
recurse(allFiles, new StringBuilder(locationPath).append('/')
.append(dirs[i].getName()).toString());
}
}
/**
* Main thread for the mosaic index builder.
*/
public void run() {
// /////////////////////////////////////////////////////////////////////
//
// CREATING INDEX FILE
//
// /////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////
//
// Create a file handler that write log record to a file called
// my.log
//
// /////////////////////////////////////////////////////////////////////
FileHandler handler=null;
try {
boolean append = true;
handler = new FileHandler(new StringBuffer(locationPath).append(
"/error.txt").toString(), append);
handler.setLevel(Level.SEVERE);
// Add to the desired logger
LOGGER.addHandler(handler);
// /////////////////////////////////////////////////////////////////////
//
// Create a set of file names that have to be skipped since these are
// our metadata files
//
// /////////////////////////////////////////////////////////////////////
final Set<String> skipFiles = new HashSet<String>(Arrays
.asList(new String[] { indexName + ".shp", indexName + ".dbf",
indexName + ".shx", indexName + ".prj", "error.txt",
"error.txt.lck", indexName + ".properties" }));
// /////////////////////////////////////////////////////////////////////
//
// Creating temp vars
//
// /////////////////////////////////////////////////////////////////////
ShapefileDataStore index = null;
Transaction t = new DefaultTransaction();
// declaring a preciosion model to adhere the java double type
// precision
PrecisionModel precMod = new PrecisionModel(PrecisionModel.FLOATING);
GeometryFactory geomFactory = new GeometryFactory(precMod);
try {
index = new ShapefileDataStore(new File(locationPath + File.separator
+ indexName + ".shp").toURI().toURL());
} catch (MalformedURLException ex) {
if (LOGGER.isLoggable(Level.SEVERE))
LOGGER.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
fireException(ex);
return;
}
final List<File> files = new ArrayList<File>();
recurse(files, locationPath);
// /////////////////////////////////////////////////////////////////////
//
// Cycling over the files that have filtered out
//
// /////////////////////////////////////////////////////////////////////
numFiles = files.size();
String validFileName = null;
final Iterator<File> filesIt = files.iterator();
FeatureWriter<SimpleFeatureType, SimpleFeature> fw = null;
boolean doneSomething = false;
for (int i = 0; i < numFiles; i++) {
StringBuffer message;
// //
//
// Check that this file is actually good to go
//
// //
final File fileBeingProcessed = ((File) filesIt.next());
if(!fileBeingProcessed.exists()||!fileBeingProcessed.canRead()||!fileBeingProcessed.isFile())
{
// send a message
message = new StringBuffer("Skipped file ").append(
files.get(i)).append(
" snce it seems invalid.");
if (LOGGER.isLoggable(Level.INFO))
LOGGER.info(message.toString());
fireEvent(message.toString(), ((i * 99.0) / numFiles));
continue;
}
// //
//
// Anyone has asked us to stop?
//
// //
if (getStopThread()) {
message = new StringBuffer("Stopping requested at file ")
.append(i).append(" of ").append(numFiles).append(
" files");
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine(message.toString());
}
fireEvent(message.toString(), ((i * 100.0) / numFiles));
return;
} // replacing chars on input path
try {
validFileName = fileBeingProcessed.getCanonicalPath();
} catch (IOException e1) {
fireException(e1);
return;
}
validFileName = validFileName.replace('\\', '/');
validFileName = validFileName.substring(locationPath.length() + 1,
fileBeingProcessed.getAbsolutePath().length());
if (skipFiles.contains(validFileName))
continue;
message = new StringBuffer("Now indexing file ")
.append(validFileName);
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine(message.toString());
}
fireEvent(message.toString(), ((i * 100.0) / numFiles));
try {
// ////////////////////////////////////////////////////////
//
//
// STEP 1
// Getting an ImageIO reader for this coverage.
//
//
// ////////////////////////////////////////////////////////
ImageInputStream inStream = ImageIO
.createImageInputStream(fileBeingProcessed);
if(inStream==null)
{
if(LOGGER.isLoggable(Level.SEVERE))
LOGGER.severe(fileBeingProcessed+" has been skipped since we could not get a stream for it");
continue;
}
inStream.mark();
final Iterator<ImageReader> it = ImageIO.getImageReaders(inStream);
ImageReader r = null;
if (it.hasNext()) {
r = (ImageReader) it.next();
r.setInput(inStream);
} else {
// release resources
try {
inStream.close();
} catch (Exception e) {
// ignore exception
}
// try {
// r.dispose();
// } catch (Exception e) {
// // ignore exception
// }
// send a message
message = new StringBuffer("Skipped file ").append(
files.get(i)).append(
":No ImageIO readeres avalaible.");
if (LOGGER.isLoggable(Level.INFO))
LOGGER.info(message.toString());
fireEvent(message.toString(), ((i * 99.0) / numFiles));
continue;
}
// ////////////////////////////////////////////////////////
//
// STEP 2
// Getting a coverage reader for this coverage.
//
// ////////////////////////////////////////////////////////
if (LOGGER.isLoggable(Level.FINE))
LOGGER
.fine(new StringBuffer("Getting a reader")
.toString());
final AbstractGridFormat format = (AbstractGridFormat) GridFormatFinder
.findFormat(files.get(i));
if (format == null||!format.accepts(files.get(i))) {
// release resources
try {
inStream.close();
} catch (Exception e) {
// ignore exception
}
try {
r.dispose();
} catch (Exception e) {
// ignore exception
}
message = new StringBuffer("Skipped file ").append(
files.get(i)).append(
": File format is not supported.");
if (LOGGER.isLoggable(Level.INFO))
LOGGER.info(message.toString());
fireEvent(message.toString(), ((i * 99.0) / numFiles));
continue;
}
final AbstractGridCoverage2DReader reader = (AbstractGridCoverage2DReader) format
.getReader(files.get(i));
envelope = (GeneralEnvelope) reader.getOriginalEnvelope();
actualCRS = reader.getCrs();
// /////////////////////////////////////////////////////////////////////
//
// STEP 3
// Get the type specifier for this image and the check that the
// image has the correct sample model and color model.
// If this is the first cycle of the loop we initialize
// eveything.
//
// /////////////////////////////////////////////////////////////////////
final ImageTypeSpecifier its = ((ImageTypeSpecifier) r.getImageTypes(0).next());
boolean skipFeature = false;
if (globEnvelope == null) {
// /////////////////////////////////////////////////////////////////////
//
// at the first step we initialize everything that we will
// reuse afterwards starting with color models, sample
// models, crs, etc....
//
// /////////////////////////////////////////////////////////////////////
defaultCM = its.getColorModel();
if (defaultCM instanceof IndexColorModel) {
IndexColorModel icm = (IndexColorModel) defaultCM;
int numBands = defaultCM.getNumColorComponents();
defaultPalette = new byte[3][icm.getMapSize()];
icm.getReds(defaultPalette[0]);
icm.getGreens(defaultPalette[0]);
icm.getBlues(defaultPalette[0]);
if (numBands == 4)
icm.getAlphas(defaultPalette[0]);
}
defaultSM = its.getSampleModel();
defaultCRS = actualCRS;
globEnvelope = new GeneralEnvelope(envelope);
// /////////////////////////////////////////////////////////////////////
//
// getting information about resolution
//
// /////////////////////////////////////////////////////////////////////
// //
//
// get the dimension of the hr image and build the model
// as well as
// computing the resolution
// //
// resetting reader and recreating stream, turnaround for a
// strange imageio bug
r.reset();
try{
inStream.reset();
}catch (IOException e) {
inStream= ImageIO.createImageInputStream(fileBeingProcessed);
}
//let's check if we got something now
if(inStream==null)
{
//skip file
if(LOGGER.isLoggable(Level.WARNING))
LOGGER.warning("Skipping file "+fileBeingProcessed.toString());
continue;
}
r.setInput(inStream);
numberOfLevels = r.getNumImages(true);
resolutionLevels = new double[2][numberOfLevels];
double[] res = getResolution(envelope, new Rectangle(r
.getWidth(0), r.getHeight(0)), defaultCRS);
resolutionLevels[0][0] = res[0];
resolutionLevels[1][0] = res[1];
// resolutions levels
if (numberOfLevels > 1) {
for (int k = 0; k < numberOfLevels; k++) {
res = getResolution(envelope, new Rectangle(r
.getWidth(k), r.getHeight(k)), defaultCRS);
resolutionLevels[0][k] = res[0];
resolutionLevels[1][k] = res[1];
}
}
// /////////////////////////////////////////////////////////////////////
//
// creating the schema
//
// /////////////////////////////////////////////////////////////////////
final SimpleFeatureTypeBuilder featureBuilder = new SimpleFeatureTypeBuilder();
featureBuilder.setName("Flag");
featureBuilder.setNamespaceURI("http://www.geo-solutions.it/");
featureBuilder.add("location", String.class);
featureBuilder.add("the_geom", Polygon.class,this.actualCRS);
featureBuilder.setDefaultGeometry("the_geom");
final SimpleFeatureType simpleFeatureType = featureBuilder.buildFeatureType();
// create the schema for the new shape file
index.createSchema(simpleFeatureType);
// get a feature writer
fw = index.getFeatureWriter( t);
} else {
// ////////////////////////////////////////////////////////
//
// comparing ColorModel
// comparing SampeModel
// comparing CRSs
// ////////////////////////////////////////////////////////
globEnvelope.add(envelope);
actualCM = its.getColorModel();
actualSM = its.getSampleModel();
skipFeature = (i > 0 ? !(CRS.equalsIgnoreMetadata(
defaultCRS, actualCRS)) : false);
if (skipFeature)
LOGGER.warning(new StringBuffer("Skipping image ")
.append(files.get(i)).append(
" because CRSs do not match.")
.toString());
skipFeature = checkColorModels(defaultCM, defaultPalette,
actualCM);
if (skipFeature)
LOGGER.warning(new StringBuffer("Skipping image ")
.append(files.get(i)).append(
" because color models do not match.")
.toString());
// defaultCM.getNumComponents()==actualCM.getNumComponents()&&
// defaultCM.getClass().equals(actualCM.getClass())
// && defaultSM.getNumBands() == actualSM
// .getNumBands()
// && defaultSM.getDataType() == actualSM
// .getDataType() &&
//
// if (skipFeature)
// LOGGER
// .warning(new StringBuffer("Skipping image ")
// .append(files.get(i))
// .append(
// " because cm or sm does not match.")
// .toString());
// res = getResolution(envelope, new
// Rectangle(r.getWidth(0),
// r.getHeight(0)), defaultCRS);
// if (Math.abs((resX - res[0]) / resX) > EPS
// || Math.abs(resY - res[1]) > EPS) {
// LOGGER.warning(new StringBuffer("Skipping image
// ").append(
// files.get(i)).append(
// " because resolutions does not match.")
// .toString());
// skipFeature = true;
// }
}
// ////////////////////////////////////////////////////////
//
// STEP 4
//
// create and store features
//
// ////////////////////////////////////////////////////////
if (!skipFeature) {
final SimpleFeature feature = fw.next();
feature.setAttribute(1, geomFactory
.toGeometry(new ReferencedEnvelope(
(Envelope) envelope)));
feature.setAttribute(0, absolute ? new StringBuilder(
this.locationPath).append(File.separatorChar)
.append(validFileName).toString() : validFileName);
fw.write();
message = new StringBuffer("Done with file ").append(files
.get(i));
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine(message.toString());
}
message.append('\n');
fireEvent(message.toString(), (((i + 1) * 99.0) / numFiles));
doneSomething = true;
} else
skipFeature = false;
// ////////////////////////////////////////////////////////
//
// STEP 5
//
// release resources
//
// ////////////////////////////////////////////////////////
try {
inStream.close();
} catch (Exception e) {
// ignore exception
}
try {
r.dispose();
} catch (Exception e) {
// ignore exception
}
// release resources
reader.dispose();
} catch (IOException e) {
fireException(e);
break;
} catch (ArrayIndexOutOfBoundsException e) {
fireException(e);
break;
}
}
try {
if (fw != null)
fw.close();
t.commit();
t.close();
index.dispose();
} catch (IOException e) {
LOGGER.log(Level.SEVERE, e.getLocalizedMessage(), e);
}
createPropertiesFiles(globEnvelope, doneSomething);
} catch (SecurityException el) {
fireException(el);
return;
} catch (IOException el) {
fireException(el);
return;
}
finally{
try{
if(handler!=null)
handler.close();
}catch (Throwable e) {
// ignore
}
}
}
/**
* @param globEnvelope
* @param doneSomething
*/
private void createPropertiesFiles(GeneralEnvelope globEnvelope,
boolean doneSomething) {
StringBuffer message;
if (numFiles > 0 && doneSomething) {
// /////////////////////////////////////////////////////////////////////
//
// FINAL STEP
//
// CREATING GENERAL INFO FILE
//
// /////////////////////////////////////////////////////////////////////
message = new StringBuffer("Creating final properties file ");
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine(message.toString());
}
fireEvent(message.toString(), 99.9);
// envelope
final Properties properties = new Properties();
properties.setProperty("AbsolutePath", Boolean.toString(absolute));
properties.setProperty("NumFiles", Integer.toString(numFiles));
properties.setProperty("Envelope2D", new StringBuffer(Double
.toString(globEnvelope.getMinimum(0))).append(",").append(
Double.toString(globEnvelope.getMinimum(1))).append(" ")
.append(Double.toString(globEnvelope.getMaximum(0)))
.append(",").append(
Double.toString(globEnvelope.getMaximum(1)))
.toString());
properties.setProperty("LevelsNum", Integer
.toString(numberOfLevels));
final StringBuffer levels = new StringBuffer();
for (int k = 0; k < numberOfLevels; k++) {
levels.append(Double.toString(resolutionLevels[0][k])).append(
",").append(Double.toString(resolutionLevels[1][k]));
if (k < numberOfLevels - 1)
levels.append(" ");
}
properties.setProperty("Levels", levels.toString());
properties.setProperty("Name", indexName);
properties.setProperty("ExpandToRGB", Boolean
.toString(mustConvertToRGB));
OutputStream outStream=null;
try {
outStream=new BufferedOutputStream(new FileOutputStream(locationPath + "/" + indexName + ".properties"));
properties.store(outStream, "");
} catch (FileNotFoundException e) {
fireEvent(e.getLocalizedMessage(), 0);
} catch (IOException e) {
fireEvent(e.getLocalizedMessage(), 0);
}
finally{
try{
if(outStream!=null)
outStream.close();
}catch (Throwable e) {
if (LOGGER.isLoggable(Level.FINE))
LOGGER.log(Level.FINE, e.getLocalizedMessage(), e);
}
}
// processing information
message = new StringBuffer("Done!!!");
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine(message.toString());
}
fireEvent(message.toString(), 100);
} else {
// processing information
message = new StringBuffer("No file to process!!!");
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine(message.toString());
}
fireEvent(message.toString(), 100);
}
}
/**
* This method checks the {@link ColorModel} of the current image with the
* one of the first image in order to check if they are compatible or not in
* order to perform a mosaic operation.
*
* <p>
* It is worth to point out that we also check if, in case we have two index
* color model image, we also try to suggest whether or not we should do a
* color expansion.
*
* @param defaultCM
* @param defaultPalette
* @param actualCM
* @return a boolean asking to skip this feature.
*/
private boolean checkColorModels(ColorModel defaultCM,
byte[][] defaultPalette, ColorModel actualCM) {
// /////////////////////////////////////////////////////////////////////
//
//
// ComponentColorModel
//
//
// /////////////////////////////////////////////////////////////////////
if (defaultCM instanceof ComponentColorModel
&& actualCM instanceof ComponentColorModel) {
final ComponentColorModel defCCM = (ComponentColorModel) defaultCM, actualCCM = (ComponentColorModel) actualCM;
return !(defCCM.getNumColorComponents() == actualCCM
.getNumColorComponents()
&& defCCM.hasAlpha() == actualCCM.hasAlpha()
&& defCCM.getColorSpace().equals(actualCCM.getColorSpace())
&& defCCM.getTransparency() == actualCCM.getTransparency() && defCCM
.getTransferType() == actualCCM.getTransferType());
}
// /////////////////////////////////////////////////////////////////////
//
//
// IndexColorModel
//
//
// /////////////////////////////////////////////////////////////////////
if (defaultCM instanceof IndexColorModel
&& actualCM instanceof IndexColorModel) {
final IndexColorModel defICM = (IndexColorModel) defaultCM, actualICM = (IndexColorModel) actualCM;
if (defICM.getNumColorComponents() != actualICM
.getNumColorComponents()
|| defICM.hasAlpha() != actualICM.hasAlpha()
|| !defICM.getColorSpace()
.equals(actualICM.getColorSpace())
|| defICM.getTransferType() != actualICM.getTransferType())
return true;
// ///
//
// Suggesting expansion in the simplest case
//
// ///
if (defICM.getMapSize() != actualICM.getMapSize()
|| defICM.getTransparency() != actualICM.getTransparency()
|| defICM.getTransferType() != actualICM.getTransferType()
|| defICM.getTransparentPixel() != actualICM
.getTransparentPixel()) {
mustConvertToRGB = true;
return false;
}
// //
//
// Now checking palettes to see if we need to do a color convert
//
// //
// get the palette for this color model
int numBands = actualICM.getNumColorComponents();
byte[][] actualPalette = new byte[3][actualICM.getMapSize()];
actualICM.getReds(actualPalette[0]);
actualICM.getGreens(actualPalette[0]);
actualICM.getBlues(actualPalette[0]);
if (numBands == 4)
actualICM.getAlphas(defaultPalette[0]);
// compare them
for (int i = 0; i < defICM.getMapSize(); i++)
for (int j = 0; j < numBands; j++)
if (actualPalette[j][i] != defaultPalette[j][i]) {
mustConvertToRGB = true;
break;
}
return false;
}
// //
//
// if we get here this means that the two color models where completely
// different, hence skip this feature.
//
// //
return true;
}
/**
* Default constructor
*/
public MosaicIndexBuilder() {
super(NAME, VERSION);
// /////////////////////////////////////////////////////////////////////
// Options for the command line
// /////////////////////////////////////////////////////////////////////
locationOpt = optionBuilder.withShortName("s").withLongName(
"source_directory").withArgument(
argumentBuilder.withName("source").withMinimum(1)
.withMaximum(1).create()).withDescription(
"path where files are located").withRequired(true).create();
wildcardOpt = optionBuilder.withShortName("w").withLongName(
"wildcardOpt").withArgument(
argumentBuilder.withName("wildcardOpt").withMinimum(0)
.withMaximum(1).create()).withDescription(
"wildcardOpt to use for selecting files").withRequired(false)
.create();
nameOpt = optionBuilder.withShortName("name")
.withLongName("index_name").withArgument(
argumentBuilder.withName("name").withMinimum(0)
.withMaximum(1).create()).withDescription(
"name for the index file").withRequired(false).create();
relativePathOpt = optionBuilder.withShortName("abs").withLongName(
"absolute_path").withDescription(
"whether or not paths shuld be absolute").withRequired(false)
.create();
addOption(locationOpt);
addOption(wildcardOpt);
addOption(nameOpt);
addOption(relativePathOpt);
// /////////////////////////////////////////////////////////////////////
//
// Help Formatter
//
// /////////////////////////////////////////////////////////////////////
finishInitialization();
}
/**
* Entry point for the index builder.
*
* @param args
*/
public static void main(String[] args) {
final MosaicIndexBuilder mosaicIndexBuilder = new MosaicIndexBuilder();
mosaicIndexBuilder.addProcessingEventListener(mosaicIndexBuilder);
if (mosaicIndexBuilder.parseArgs(args)) {
final Thread t = new Thread(mosaicIndexBuilder,
"MosaicIndexBuilder");
t.setPriority(mosaicIndexBuilder.getPriority());
t.start();
try {
t.join();
} catch (InterruptedException e) {
LOGGER.log(Level.SEVERE, e.getLocalizedMessage(), e);
}
} else
LOGGER.fine("Exiting...");
}
public boolean parseArgs(String[] args) {
if (!super.parseArgs(args))
return false;
// ////////////////////////////////////////////////////////////////
//
// parsing command line parameters and setting up
// Mosaic Index Builder options
//
// ////////////////////////////////////////////////////////////////
locationPath = (String) getOptionValue(locationOpt);
final File inDir = new File(locationPath);
if (!inDir.isDirectory()) {
LOGGER.severe("Provided input dir does not exist or is not a dir!");
return false;
}
try {
locationPath = inDir.getCanonicalPath();
locationPath = locationPath.replace('\\', '/');
} catch (IOException e) {
LOGGER.log(Level.SEVERE, e.getLocalizedMessage(), e);
return false;
}
// wildcard
if (hasOption(wildcardOpt))
wildcardString = (String) getOptionValue(wildcardOpt);
// index name
if (hasOption(nameOpt))
indexName = (String) getOptionValue(nameOpt);
// //
//
// Type of path
//
// //
if (hasOption(relativePathOpt))
absolute = true;
return true;
}
/**
* This method is responsible for computing the resolutions in for the
* provided grid geometry in the provided crs.
*
* <P>
* It is worth to note that the returned resolution array is of length of 2
* and it always is lon, lat for the moment.<br>
* It might be worth to remove the axes reordering code when we are
* confident enough with the code to handle the north-up crs.
* <p>
* TODO use orthodromic distance?
*
* @param envelope
* the GeneralEnvelope
* @param dim
* @param crs
* @throws DataSourceException
*/
protected final double[] getResolution(GeneralEnvelope envelope,
Rectangle2D dim, CoordinateReferenceSystem crs)
throws DataSourceException {
double[] requestedRes = null;
try {
if (dim != null && envelope != null) {
// do we need to transform the originalEnvelope?
final CoordinateReferenceSystem crs2D = CRSUtilities
.getCRS2D(envelope.getCoordinateReferenceSystem());
if (crs != null && !CRS.equalsIgnoreMetadata(crs, crs2D)) {
final MathTransform tr = CRS.findMathTransform(crs2D, crs);
if (!tr.isIdentity())
envelope = CRS.transform(tr, envelope);
}
requestedRes = new double[2];
requestedRes[0] = envelope.getLength(0) / dim.getWidth();
requestedRes[1] = envelope.getLength(1) / dim.getHeight();
}
return requestedRes;
} catch (TransformException e) {
throw new DataSourceException("Unable to get the resolution", e);
} catch (FactoryException e) {
throw new DataSourceException("Unable to get the resolution", e);
}
}
/**
* This method is repsonbile for sending the process progress events to the
* logger.
*
* <p>
* It should be used to do normal logging when running this tools as command
* line tools but it should be disable when putting the tool behind a GUI.
* In such a case the GUI should register itself as a
* {@link ProcessingEventListener} and consume the processing events.
*
* @param event
* is a {@link ProcessingEvent} that informs the receiver on the
* precetnage of the progress as well as on what is happening.
*/
public void getNotification(ProcessingEvent event) {
LOGGER.info(new StringBuffer("Progress is at ").append(
event.getPercentage()).append("\n").append(
"attached message is: ").append(event.getMessage()).toString());
}
public void exceptionOccurred(ExceptionEvent event) {
LOGGER.log(Level.SEVERE, "An error occurred during processing", event
.getException());
}
/**
* @param locationPath
* the locationPath to set
*/
public final void setLocationPath(String locationPath) {
this.locationPath = locationPath;
final File inDir = new File(locationPath);
if (!inDir.isDirectory()) {
LOGGER.severe("Provided input dir does not exist or is not a dir!");
throw new IllegalArgumentException(
"Provided input dir does not exist or is not a dir!");
}
try {
locationPath = inDir.getCanonicalPath();
locationPath = locationPath.replace('\\', '/');
} catch (IOException e) {
LOGGER.log(Level.SEVERE, e.getLocalizedMessage(), e);
final IllegalArgumentException ex = new IllegalArgumentException();
ex.initCause(e);
throw ex;
}
}
/**
* @param wildcardString
* the wildcardString to set
*/
public final void setWildcardString(String wildcardString) {
this.wildcardString = wildcardString;
}
public String getIndexName() {
return indexName;
}
public void setIndexName(String indexName) {
this.indexName = indexName;
}
public double getResolutionX() {
return this.resolutionLevels[0][0];
}
public double getResolutionY() {
return this.resolutionLevels[1][0];
}
}