/* (c) 2014 Open Source Geospatial Foundation - all rights reserved
* (c) 2001 - 2013 OpenPlans
* This code is licensed under the GPL 2.0 license, available at the root
* application directory.
*/
package org.geoserver.wcs2_0.eo.response;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.media.jai.ImageLayout;
import org.geoserver.util.ISO8601Formatter;
import org.geotools.coverage.grid.GridCoverage2D;
import org.geotools.coverage.grid.io.DimensionDescriptor;
import org.geotools.coverage.grid.io.GranuleSource;
import org.geotools.coverage.grid.io.HarvestedSource;
import org.geotools.coverage.grid.io.OverviewPolicy;
import org.geotools.coverage.grid.io.StructuredGridCoverage2DReader;
import org.geotools.factory.Hints;
import org.geotools.geometry.GeneralEnvelope;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.opengis.coverage.grid.Format;
import org.opengis.coverage.grid.GridEnvelope;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.parameter.GeneralParameterValue;
import org.opengis.parameter.ParameterDescriptor;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.datum.PixelInCell;
import org.opengis.referencing.operation.MathTransform;
import com.vividsolutions.jts.geom.Geometry;
/**
* Provides a view of a single granule to the DescribeCoverage encoder (to be used in
* DescribeOECoverageSet response)
*
* @author Andrea Aime - GeoSolutions
*/
public class SingleGranuleGridCoverageReader implements StructuredGridCoverage2DReader {
private StructuredGridCoverage2DReader reader;
private SimpleFeature feature;
GeneralEnvelope granuleEnvelope;
ISO8601Formatter formatter = new ISO8601Formatter();
Map<String, DimensionDescriptor> dimensionDescriptors;
public SingleGranuleGridCoverageReader(StructuredGridCoverage2DReader reader,
SimpleFeature feature, List<DimensionDescriptor> dimensionDescriptors) {
this.reader = reader;
this.feature = feature;
this.dimensionDescriptors = new HashMap<String, DimensionDescriptor>();
for (DimensionDescriptor descriptor : dimensionDescriptors) {
this.dimensionDescriptors.put(descriptor.getName().toUpperCase(), descriptor);
}
Geometry featureGeometry = lookupFeatureGeometry();
ReferencedEnvelope re = new ReferencedEnvelope(featureGeometry.getEnvelopeInternal(),
reader.getCoordinateReferenceSystem());
this.granuleEnvelope = new GeneralEnvelope(re);
}
private Geometry lookupFeatureGeometry() {
return (Geometry) feature.getDefaultGeometry();
}
public Format getFormat() {
return reader.getFormat();
}
public Object getSource() {
return reader.getSource();
}
public String[] getMetadataNames() throws IOException {
return reader.getMetadataNames();
}
public GranuleSource getGranules(String coverageName, boolean readOnly) throws IOException,
UnsupportedOperationException {
return reader.getGranules(coverageName, readOnly);
}
public String[] getMetadataNames(String coverageName) throws IOException {
return reader.getMetadataNames(coverageName);
}
public boolean isReadOnly() {
return reader.isReadOnly();
}
public void createCoverage(String coverageName, SimpleFeatureType schema) throws IOException,
UnsupportedOperationException {
throw new UnsupportedOperationException();
}
public boolean removeCoverage(String coverageName) throws IOException,
UnsupportedOperationException {
return reader.removeCoverage(coverageName);
}
public boolean removeCoverage(String coverageName, boolean delete) throws IOException,
UnsupportedOperationException {
return reader.removeCoverage(coverageName, delete);
}
public String getMetadataValue(String name) throws IOException {
if(name.endsWith("_DOMAIN_MINIMUM") || name.endsWith("_DOMAIN_MAXIMUM") || name.endsWith("_DOMAIN")) {
String dimensionName = name.substring(0, name.indexOf("_DOMAIN"));
DimensionDescriptor descriptor = dimensionDescriptors.get(dimensionName);
if(descriptor != null) {
Object start = feature.getAttribute(descriptor.getStartAttribute());
Object end = null;
if(descriptor.getEndAttribute() != null) {
end = feature.getAttribute(descriptor.getEndAttribute());
}
if(dimensionName.equalsIgnoreCase("TIME")) {
start = formatter.format((Date) start);
if(end != null) {
end = formatter.format((Date) end);
}
}
if (name.endsWith("_DOMAIN_MINIMUM")) {
return String.valueOf(start);
}
if (name.endsWith("_DOMAIN_MAXIMUM")) {
if(end != null) {
return String.valueOf(end);
} else {
return String.valueOf(start);
}
}
if (name.endsWith("_DOMAIN")) {
if(end != null) {
return start + "/" + end;
} else {
return String.valueOf(start);
}
}
}
}
return reader.getMetadataValue(name);
}
public List<HarvestedSource> harvest(String defaultTargetCoverage, Object source, Hints hints)
throws IOException, UnsupportedOperationException {
throw new UnsupportedOperationException();
}
public String getMetadataValue(String coverageName, String name) throws IOException {
throw new UnsupportedOperationException();
}
public String[] listSubNames() throws IOException {
return reader.listSubNames();
}
public GeneralEnvelope getOriginalEnvelope() {
return granuleEnvelope;
}
public GeneralEnvelope getOriginalEnvelope(String coverageName) {
throw new UnsupportedOperationException();
}
public String[] getGridCoverageNames() throws IOException {
return reader.getGridCoverageNames();
}
public CoordinateReferenceSystem getCoordinateReferenceSystem() {
return reader.getCoordinateReferenceSystem();
}
public int getGridCoverageCount() throws IOException {
return reader.getGridCoverageCount();
}
public CoordinateReferenceSystem getCoordinateReferenceSystem(String coverageName) {
return reader.getCoordinateReferenceSystem(coverageName);
}
public String getCurrentSubname() throws IOException {
return reader.getCurrentSubname();
}
public GridEnvelope getOriginalGridRange() {
return reader.getOriginalGridRange();
}
public boolean hasMoreGridCoverages() throws IOException {
return reader.hasMoreGridCoverages();
}
public GridEnvelope getOriginalGridRange(String coverageName) {
return reader.getOriginalGridRange(coverageName);
}
public MathTransform getOriginalGridToWorld(PixelInCell pixInCell) {
return reader.getOriginalGridToWorld(pixInCell);
}
public MathTransform getOriginalGridToWorld(String coverageName, PixelInCell pixInCell) {
return reader.getOriginalGridToWorld(coverageName, pixInCell);
}
public GridCoverage2D read(GeneralParameterValue[] parameters) throws IOException {
return reader.read(parameters);
}
public GridCoverage2D read(String coverageName, GeneralParameterValue[] parameters)
throws IOException {
return reader.read(coverageName, parameters);
}
public void skip() throws IOException {
reader.skip();
}
public void dispose() throws IOException {
reader.dispose();
}
public Set<ParameterDescriptor<List>> getDynamicParameters() throws IOException {
return reader.getDynamicParameters();
}
public Set<ParameterDescriptor<List>> getDynamicParameters(String coverageName)
throws IOException {
return reader.getDynamicParameters(coverageName);
}
public double[] getReadingResolutions(OverviewPolicy policy, double[] requestedResolution)
throws IOException {
return reader.getReadingResolutions(policy, requestedResolution);
}
public double[] getReadingResolutions(String coverageName, OverviewPolicy policy,
double[] requestedResolution) throws IOException {
return reader.getReadingResolutions(coverageName, policy, requestedResolution);
}
public int getNumOverviews() {
return reader.getNumOverviews();
}
public int getNumOverviews(String coverageName) {
return reader.getNumOverviews(coverageName);
}
public ImageLayout getImageLayout() throws IOException {
throw new UnsupportedOperationException();
}
public ImageLayout getImageLayout(String coverageName) throws IOException {
throw new UnsupportedOperationException();
}
public double[][] getResolutionLevels() throws IOException {
return reader.getResolutionLevels();
}
public double[][] getResolutionLevels(String coverageName) throws IOException {
return reader.getResolutionLevels(coverageName);
}
@Override
public List<DimensionDescriptor> getDimensionDescriptors(String coverageName) throws IOException {
return reader.getDimensionDescriptors(coverageName);
}
@Override
public void delete(boolean deleteData) throws IOException, UnsupportedOperationException {
reader.delete(deleteData);
}
}