390 lines
15 KiB
Java
390 lines
15 KiB
Java
package org.gcube.dataanalysis.geo.algorithms;
|
|
|
|
import java.awt.Image;
|
|
import java.io.BufferedWriter;
|
|
import java.io.File;
|
|
import java.io.FileWriter;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
|
|
import org.gcube.common.scope.api.ScopeProvider;
|
|
import org.gcube.contentmanagement.lexicalmatcher.utils.AnalysisLogger;
|
|
import org.gcube.dataanalysis.ecoengine.configuration.ALG_PROPS;
|
|
import org.gcube.dataanalysis.ecoengine.configuration.AlgorithmConfiguration;
|
|
import org.gcube.dataanalysis.ecoengine.datatypes.DatabaseType;
|
|
import org.gcube.dataanalysis.ecoengine.datatypes.PrimitiveType;
|
|
import org.gcube.dataanalysis.ecoengine.datatypes.StatisticalType;
|
|
import org.gcube.dataanalysis.ecoengine.datatypes.enumtypes.PrimitiveTypes;
|
|
import org.gcube.dataanalysis.ecoengine.interfaces.ActorNode;
|
|
import org.gcube.dataanalysis.ecoengine.utils.IOHelper;
|
|
import org.gcube.dataanalysis.ecoengine.utils.Transformations;
|
|
import org.gcube.dataanalysis.ecoengine.utils.Tuple;
|
|
import org.gcube.dataanalysis.executor.generators.D4ScienceDistributedProcessing;
|
|
|
|
import org.gcube.dataanalysis.geo.connectors.netcdf.NetCDFDataExplorer;
|
|
import org.gcube.dataanalysis.geo.infrastructure.GeoNetworkInspector;
|
|
import org.gcube.dataanalysis.geo.matrixmodel.MatrixExtractor;
|
|
import org.gcube.dataanalysis.geo.matrixmodel.XYExtractor;
|
|
import org.opengis.metadata.Metadata;
|
|
|
|
import ucar.nc2.dt.GridDatatype;
|
|
import ucar.nc2.dt.grid.GridDataset;
|
|
|
|
import com.thoughtworks.xstream.XStream;
|
|
|
|
public class MapsComparatorNode extends ActorNode{
|
|
|
|
static String layer1 = "Layer_1";
|
|
static String layer2 = "Layer_2";
|
|
static String resolutionS = "resolution";
|
|
static String x1S = "x1";
|
|
static String y1S = "y1";
|
|
static String x2S = "x2";
|
|
static String y2S = "y2";
|
|
|
|
static String zString = "Z";
|
|
static String t1 = "TimeIndex_1";
|
|
static String t2 = "TimeIndex_2";
|
|
static String valuesThr = "ValuesComparisonThreshold";
|
|
float status = 0;
|
|
AlgorithmConfiguration config;
|
|
Tuple<Double> extent;
|
|
public int prevbroadcastTimePeriod;
|
|
public int prevmaxNumberOfStages;
|
|
public int prevmaxMessages;
|
|
int numberofslices = 0;
|
|
|
|
public List<StatisticalType> inputs = new ArrayList<StatisticalType>();
|
|
public LinkedHashMap<String, String> outputParameters = new LinkedHashMap<String, String>();
|
|
|
|
@Override
|
|
public String getDescription() {
|
|
return "An algorithm for comparing two OGC/NetCDF maps in seamless way to the user. Supported maps can only be in WFS, Opendap or ASC formats. The algorithm assesses the similarities between two geospatial maps by comparing them in a point-to-point fashion. It accepts as input the two geospatial maps (via their UUIDs in the infrastructure spatial data repository - recoverable through the Geoexplorer portlet) and some parameters affecting the comparison such as the z-index, the time index, the comparison threshold.";
|
|
}
|
|
|
|
@Override
|
|
public List<StatisticalType> getInputParameters(){
|
|
|
|
IOHelper.addStringInput(inputs,layer1, "First Layer Title or UUID: The title or the UUID (preferred) of a layer indexed in the e-Infrastructure on GeoNetwork - You can retrieve it from GeoExplorer", "");//"Sarda australis");
|
|
IOHelper.addStringInput(inputs, layer2, "Second Layer Title or UUID: The title or the UUID (preferred) of a second layer indexed in the e-Infrastructure on GeoNetwork - You can retrieve it from GeoExplorer", "");//"Sarda orientalis");
|
|
IOHelper.addIntegerInput(inputs, zString, "value of Z. Default is 0, that means comparison will be at surface level", "0");
|
|
IOHelper.addDoubleInput(inputs, valuesThr, "A comparison threshold for the values in the map. Null equals to 0.1", "0.1");
|
|
IOHelper.addIntegerInput(inputs, t1, "First Layer Time Index. The default is the first", "0");
|
|
IOHelper.addIntegerInput(inputs, t2, "Second Layer Time Index. The default is the first", "0");
|
|
IOHelper.addDoubleInput(inputs, "KThreshold", "Threshold for K-Statistic: over this threshold values will be considered 1 for agreement calculation. Default is 0.5","0.5");
|
|
|
|
DatabaseType.addDefaultDBPars(inputs);
|
|
|
|
return inputs;
|
|
}
|
|
|
|
@Override
|
|
public StatisticalType getOutput() {
|
|
|
|
// set the output map containing values
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Producing Gaussian Distribution for the errors");
|
|
|
|
// build image:
|
|
HashMap<String, Image> producedImages = new HashMap<String, Image>();
|
|
double mean = Double.parseDouble(outputParameters.get("MEAN"));
|
|
double variance = Double.parseDouble(outputParameters.get("VARIANCE"));
|
|
PrimitiveType images = new PrimitiveType("Images", producedImages, PrimitiveTypes.IMAGES, "Distribution of the Error", "The distribution of the error along with variance");
|
|
|
|
LinkedHashMap<String, StatisticalType> map = new LinkedHashMap<String, StatisticalType>();
|
|
|
|
for (String key:outputParameters.keySet()){
|
|
String value = outputParameters.get(key);
|
|
PrimitiveType val = new PrimitiveType(String.class.getName(), "" + value, PrimitiveTypes.STRING, key, key);
|
|
map.put(key, val);
|
|
}
|
|
|
|
// collect all the outputs
|
|
map.put("Images", images);
|
|
|
|
// generate a primitive type for the collection
|
|
PrimitiveType output = new PrimitiveType(HashMap.class.getName(), map, PrimitiveTypes.MAP, "ResultsMap", "Results Map");
|
|
|
|
return output;
|
|
}
|
|
|
|
@Override
|
|
public ALG_PROPS[] getProperties() {
|
|
ALG_PROPS[] p = { ALG_PROPS.PHENOMENON_VS_PARALLEL_PHENOMENON };
|
|
return p;
|
|
}
|
|
|
|
|
|
@Override
|
|
public String getName() {
|
|
return "MAPS_COMPARISON";
|
|
}
|
|
|
|
|
|
@Override
|
|
public void initSingleNode(AlgorithmConfiguration config) {
|
|
|
|
}
|
|
|
|
|
|
@Override
|
|
public float getInternalStatus() {
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
private double calcResolution(String layerT1, String layerT2) throws Exception{
|
|
|
|
String scope = config.getGcubeScope();
|
|
if (scope == null){
|
|
scope = ScopeProvider.instance.get();
|
|
config.setGcubeScope(scope);
|
|
}
|
|
MatrixExtractor intersector = new MatrixExtractor(config);
|
|
AnalysisLogger.getLogger().debug("MapsComparator: GeoIntersector initialized");
|
|
|
|
double x1 = -180;
|
|
double x2 = 180;
|
|
double y1 = -90;
|
|
double y2 = 90;
|
|
|
|
status = 10;
|
|
GeoNetworkInspector fm = intersector.getFeaturer();
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Taking info for the layer: " + layerT1);
|
|
Metadata meta1 = fm.getGNInfobyUUIDorName(layerT1);
|
|
if (meta1==null) throw new Exception("No Correspondence with Layer 1");
|
|
double resolution1 = 0;
|
|
try {
|
|
resolution1 = GeoNetworkInspector.getResolution(meta1);
|
|
} catch (Exception e) {
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Undefined resolution");
|
|
}
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Resolution: " + resolution1);
|
|
|
|
if (fm.isNetCDFFile(meta1)){
|
|
AnalysisLogger.getLogger().debug("MapsComparator: recalculating the spatial extent of the comparison");
|
|
String fileurl = fm.getOpenDapLink(meta1);
|
|
GridDataset gds = ucar.nc2.dt.grid.GridDataset.open(fileurl);
|
|
List<GridDatatype> gridTypes = gds.getGrids();
|
|
GridDatatype gdt = gridTypes.get(0);
|
|
x1 = NetCDFDataExplorer.getMinX(gdt.getCoordinateSystem());
|
|
x2 = NetCDFDataExplorer.getMaxX(gdt.getCoordinateSystem());
|
|
y1 = NetCDFDataExplorer.getMinY(gdt.getCoordinateSystem());
|
|
y2 = NetCDFDataExplorer.getMaxY(gdt.getCoordinateSystem());
|
|
}
|
|
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Spatial extent of the comparison: x1: "+x1+" x2: "+x2+" y1: "+y1+" y2: "+y2);
|
|
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Taking info for the layer: " + layerT2);
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Trying with UUID..." + layerT2);
|
|
Metadata meta2 = fm.getGNInfobyUUIDorName(layerT2);
|
|
if (meta2==null) throw new Exception("No Correspondence with Layer 2");
|
|
|
|
double resolution2 = 0;
|
|
try {
|
|
resolution2 = GeoNetworkInspector.getResolution(meta2);
|
|
} catch (Exception e) {
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Undefined resolution");
|
|
}
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Resolution: " + resolution2);
|
|
// take the lowest resolution to perform the comparison
|
|
double resolution = Math.max(resolution1, resolution2);
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Theoretical Resolution: " + resolution);
|
|
if (resolution == 0)
|
|
resolution = 0.5d;
|
|
// I added the following control to limit the amount of calculations
|
|
if (resolution<0.5 && resolution>0.01)
|
|
resolution = 0.5d;
|
|
else if (resolution<0.01)
|
|
resolution = 0.01d;
|
|
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Evaluation Indeed at Resolution: " + resolution);
|
|
extent = new Tuple<Double>(x1,y1,x2,y2);
|
|
return resolution;
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public int executeNode(int leftStartIndex, int numberOfLeftElementsToProcess, int rightStartIndex, int numberOfRightElementsToProcess, boolean duplicate, String sandboxFolder, String nodeConfigurationFileObject, String logfileNameToProduce) {
|
|
try {
|
|
status = 0;
|
|
System.out.println("Restoring configuration");
|
|
AlgorithmConfiguration config = Transformations.restoreConfig(new File(sandboxFolder, nodeConfigurationFileObject).getAbsolutePath());
|
|
config.setConfigPath(sandboxFolder);
|
|
|
|
AnalysisLogger.setLogger(config.getConfigPath() + AlgorithmConfiguration.defaultLoggerFile);
|
|
long t0 = System.currentTimeMillis();
|
|
String layerT1 = IOHelper.getInputParameter(config,layer1);
|
|
String layerT2 = IOHelper.getInputParameter(config,layer2);
|
|
String z$ = IOHelper.getInputParameter(config,zString);
|
|
String valuesthr$ = IOHelper.getInputParameter(config,valuesThr);
|
|
String time1$ = IOHelper.getInputParameter(config,t1);
|
|
String time2$ = IOHelper.getInputParameter(config,t2);
|
|
int time1 = ((time1$ != null) && (time1$.trim().length() > 0)) ? Integer.parseInt(time1$) : 0;
|
|
int time2 = ((time2$ != null) && (time2$.trim().length() > 0)) ? Integer.parseInt(time2$) : 0;
|
|
|
|
double resolution = Double.parseDouble(IOHelper.getInputParameter(config,resolutionS));
|
|
double x1 = Double.parseDouble(IOHelper.getInputParameter(config,x1S));
|
|
double y1 = Double.parseDouble(IOHelper.getInputParameter(config,y1S));
|
|
double x2 = Double.parseDouble(IOHelper.getInputParameter(config,x2S));
|
|
double y2 = Double.parseDouble(IOHelper.getInputParameter(config,y2S));
|
|
|
|
if (time1 < 0)
|
|
time1 = 0;
|
|
|
|
if (time2 < 0)
|
|
time2 = 0;
|
|
|
|
double valuesthreshold = 0.1;
|
|
if ((valuesthr$ != null) && (valuesthr$.trim().length() > 0))
|
|
try {
|
|
valuesthreshold = Double.parseDouble(valuesthr$);
|
|
} catch (Exception ee) {
|
|
}
|
|
|
|
double z = 0;
|
|
if ((z$ != null) && (z$.trim().length() > 0))
|
|
try {
|
|
z = Double.parseDouble(z$);
|
|
} catch (Exception ee) {
|
|
}
|
|
|
|
String scope = config.getGcubeScope();
|
|
double slicey1 = y1+(((float)rightStartIndex)*resolution);
|
|
double slicey2 = slicey1;
|
|
if (IOHelper.getInputParameter(config,"full")!=null){
|
|
slicey1=y1;
|
|
slicey2=y2;
|
|
}
|
|
|
|
int positivescount = 0;
|
|
if (slicey1<=y2){
|
|
XYExtractor intersector = new XYExtractor(config);
|
|
AnalysisLogger.getLogger().debug("MapsComparator: GeoIntersector initialized");
|
|
AnalysisLogger.getLogger().debug("MapsComparator: ****Rasterizing map 1 in the range: ("+x1+" , "+slicey1+"; "+x2+" , "+slicey2+") with res "+resolution);
|
|
double[][] slice1 = intersector.extractXYGrid(layerT1, time1, x1, x2, slicey1, slicey2, z, resolution, resolution);
|
|
AnalysisLogger.getLogger().debug("MapsComparator: ****Rasterizing map 2 in the range: ("+x1+" , "+slicey1+"; "+x2+" , "+slicey2+") with res "+resolution);
|
|
double[][] slice2 = intersector.extractXYGrid(layerT2, time1, x1, x2, slicey1, slicey2, z, resolution, resolution);
|
|
int xsize = slice1[0].length;
|
|
int ysize = slice1.length;
|
|
|
|
AnalysisLogger.getLogger().debug("Comparing maps...");
|
|
for (int j=0;j<ysize;j++){
|
|
for (int i=0;i<xsize;i++){
|
|
double discrepancy = Math.abs(slice1[j][i]-slice2[j][i]);
|
|
if (discrepancy<valuesthreshold)
|
|
positivescount++;
|
|
}
|
|
}
|
|
}else
|
|
AnalysisLogger.getLogger().debug("MapsComparator: warning - Y out of range : "+slicey1+" max:"+y2);
|
|
|
|
elapsedt += (System.currentTimeMillis()-t0);
|
|
|
|
AnalysisLogger.getLogger().debug("MapsComparator: Finished: " + positivescount+" in "+(System.currentTimeMillis()-t0));
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
AnalysisLogger.getLogger().debug("MapsComparator: ERROR!: " + e.getLocalizedMessage());
|
|
} finally {
|
|
status = 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static long elapsedt = 0;
|
|
@Override
|
|
public void setup(AlgorithmConfiguration config) throws Exception {
|
|
|
|
//calc resolution
|
|
this.config = config;
|
|
String layerT1 = IOHelper.getInputParameter(config,layer1);
|
|
String layerT2 = IOHelper.getInputParameter(config,layer2);
|
|
double resolution = calcResolution(layerT1, layerT2);
|
|
|
|
config.setParam(resolutionS,""+resolution);
|
|
config.setParam(x1S,""+extent.getElements().get(0));
|
|
config.setParam(y1S,""+extent.getElements().get(1));
|
|
config.setParam(x2S,""+extent.getElements().get(2));
|
|
config.setParam(y2S,""+extent.getElements().get(3));
|
|
double ymax = extent.getElements().get(3);
|
|
double ymin = extent.getElements().get(1);
|
|
int numberofslices = (int) Math.round(((ymax-ymin)/resolution)+1);
|
|
|
|
prevmaxMessages=D4ScienceDistributedProcessing.maxMessagesAllowedPerJob;
|
|
D4ScienceDistributedProcessing.maxMessagesAllowedPerJob=1;
|
|
|
|
AnalysisLogger.getLogger().info("Destination Table Created! Addressing " + numberofslices + " slices");
|
|
}
|
|
|
|
|
|
@Override
|
|
public int getNumberOfRightElements() {
|
|
return numberofslices;
|
|
}
|
|
|
|
|
|
@Override
|
|
public int getNumberOfLeftElements() {
|
|
return numberofslices;
|
|
}
|
|
|
|
|
|
@Override
|
|
public void stop() {
|
|
AnalysisLogger.getLogger().debug("Shutdown");
|
|
}
|
|
|
|
|
|
@Override
|
|
public void postProcess(boolean manageDuplicates, boolean manageFault) {
|
|
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
AlgorithmConfiguration config = new AlgorithmConfiguration();
|
|
|
|
config.setConfigPath("./cfg/");
|
|
String sandbox = "./PARALLEL_PROCESSING";
|
|
String configfile = "testconfig.cfg";
|
|
config.setPersistencePath(sandbox);
|
|
|
|
config.setParam(zString,"0");
|
|
config.setParam(valuesThr,"0.1");
|
|
config.setParam(t1,"0");
|
|
config.setParam(t2,"0");
|
|
config.setParam("KThreshold","0.5");
|
|
config.setGcubeScope("/gcube");
|
|
|
|
//config.setParam(layer1,"b040894b-c5db-47fc-ba9c-d4fafcdcf620"); //goblin shark
|
|
//config.setParam(layer2,"c9a31223-cc00-4acd-bc5b-a0c76a7f79c7"); //humbolt squid
|
|
|
|
config.setParam(layer1,"1265fce4-f331-4459-bed5-3747039c7bd9");
|
|
config.setParam(layer2,"1265fce4-f331-4459-bed5-3747039c7bd9");
|
|
|
|
config.setParam("full","true"); //full comparison
|
|
|
|
AnalysisLogger.setLogger(config.getConfigPath() + AlgorithmConfiguration.defaultLoggerFile);
|
|
|
|
new MapsComparatorNode().setup(config);
|
|
|
|
BufferedWriter oos = new BufferedWriter(new FileWriter(new File(sandbox, configfile)));
|
|
oos.write(new XStream().toXML(config));
|
|
oos.close();
|
|
int ncomp = 1;
|
|
int nslices = 361;
|
|
for (int i=0;i<ncomp;i++){
|
|
int randi = (int)(Math.random()*(float)nslices);
|
|
System.out.println("->Comparing for index "+randi);
|
|
new MapsComparatorNode().executeNode(0, 0, randi, randi, false, sandbox, configfile, "test.log");
|
|
}
|
|
float el = (float)(elapsedt/(float)ncomp);
|
|
System.out.println("Mean time:" +el);
|
|
System.out.println("Mean time on 21 nodes:" +(el*(float)nslices/21f));
|
|
}
|
|
|
|
}
|