/**
* Returns the set of supported formats by the available JAI library, or the empty set if not
* available.
*
* @return Set<String> of the MIME types the available JAI library supports, or the empty
* set if it is not available.
*/
public static Set getSupportedFormats() {
if (supportedFormats == null) {
String[] mimeTypes = null;
try {
mimeTypes = ImageIO.getWriterMIMETypes();
} catch (NoClassDefFoundError ncdfe) {
supportedFormats = Collections.EMPTY_SET;
LOGGER.warning("could not find jai: " + ncdfe);
// this will occur if JAI is not present, so please do not
// delete, or we get really nasty messages on getCaps for wms.
}
if (mimeTypes == null) {
LOGGER.info("Jai not found? Should be always there");
supportedFormats = Collections.EMPTY_SET;
} else {
supportedFormats = new HashSet();
List formatsList = Arrays.asList(mimeTypes);
for (Iterator it = formatsList.iterator(); it.hasNext(); ) {
String curFormat = it.next().toString();
if (!curFormat.equals("")) {
// DJB: check to see if the JAI format has been tested to work!
if (testedFormats.contains(curFormat)) {
supportedFormats.add(curFormat);
}
}
}
if (LOGGER.isLoggable(Level.CONFIG)) {
StringBuffer sb = new StringBuffer("Supported JAIMapResponse's MIME Types: [");
for (Iterator it = supportedFormats.iterator(); it.hasNext(); ) {
sb.append(it.next());
if (it.hasNext()) {
sb.append(", ");
}
}
sb.append("]");
LOGGER.config(sb.toString());
}
}
}
return supportedFormats;
}
public BufferedImageHttpMessageConverter() {
String[] readerMediaTypes = ImageIO.getReaderMIMETypes();
for (String mediaType : readerMediaTypes) {
if (StringUtils.hasText(mediaType)) {
this.readableMediaTypes.add(MediaType.parseMediaType(mediaType));
}
}
String[] writerMediaTypes = ImageIO.getWriterMIMETypes();
for (String mediaType : writerMediaTypes) {
if (StringUtils.hasText(mediaType)) {
this.defaultContentType = MediaType.parseMediaType(mediaType);
break;
}
}
}
public PKMRasterWriter() {
super(javax.imageio.ImageIO.getWriterMIMETypes(), getImageIOWriterSuffixes());
}
/**
* Utilities methods that provide conversion functionnalities between real objects and queries (in
* both ways).
*
* @author Cédric Briançon (Geomatys)
* @author Johann Sorel (Geomatys)
*/
public final class RequestsUtilities {
/** List of supported mime-types. */
private static final Set<String> SUPPORTED_FORMATS =
new HashSet<String>(Arrays.asList(ImageIO.getWriterMIMETypes()));
static {
SUPPORTED_FORMATS.addAll(Arrays.asList(ImageIO.getWriterFormatNames()));
}
private RequestsUtilities() {}
/**
* Returns a string representation of the {@code Bounding Box}. It is a comma-separated list
* matching with this pattern: minx,miny,maxx,maxy.
*
* @param envelope The envelope to return the string representation.
*/
public static String toBboxValue(final Envelope envelope) {
final StringBuilder builder = new StringBuilder();
final int dimEnv = envelope.getDimension();
for (int i = 0; i < dimEnv; i++) {
builder.append(envelope.getMinimum(i)).append(',');
}
for (int j = 0; j < dimEnv; j++) {
if (j > 0) {
builder.append(',');
}
builder.append(envelope.getMaximum(j));
}
return builder.toString();
}
/**
* Parse a boolean from a string value.
*
* @param strTransparent
* @return
*/
public static boolean toBoolean(final String strTransparent) {
if (strTransparent == null) {
return false;
}
return Boolean.parseBoolean(strTransparent.trim());
}
/**
* Get the {@link Color} object matching with the given string.
*
* @param background A string representing the color. It will be given to {@link
* Color#decode(String)}.
* @return The color object, or {@code null} if the given string is {@code null}.
* @throws NumberFormatException if the specified string cannot be interpreted as a decimal,
* octal, or hexidecimal integer.
*/
public static Color toColor(String background) throws NumberFormatException {
Color color = null;
if (background != null) {
background = background.trim();
color = Color.decode(background);
}
return color;
}
/**
* Returns the CRS code for the specified envelope, or {@code null} if not found.
*
* @param envelope The envelope to return the CRS code.
*/
public static String toCrsCode(final Envelope envelope) {
if (org.geotoolkit.referencing.CRS.equalsIgnoreMetadata(
envelope.getCoordinateReferenceSystem(), CommonCRS.WGS84.normalizedGeographic())) {
return "EPSG:4326";
}
final Set<Identifier> identifiers = envelope.getCoordinateReferenceSystem().getIdentifiers();
if (identifiers != null && !identifiers.isEmpty()) {
return identifiers.iterator().next().toString();
}
return null;
}
/**
* Extends the {@link Double#valueOf(String)} method, in removing the leading and trailing
* whitespace.
*
* @param value A string representing a double value.
* @return A double representation of the given string, or {@code NaN} if the given string is
* null.
* @throws NumberFormatException if the string can't be parsed as an double value.
*/
public static double toDouble(String value) throws NumberFormatException {
if (value == null) {
return Double.NaN;
}
value = value.trim();
return Double.parseDouble(value);
}
/**
* Converts a string representing the bbox coordinates into a {@link GeneralEnvelope}.
*
* @param bbox Coordinates of the bounding box, seperated by comas.
* @param crs The {@linkplain CoordinateReferenceSystem coordinate reference system} in which the
* envelope is expressed. Must not be {@code null}.
* @return The enveloppe for the bounding box specified, or an {@linkplain
* GeneralEnvelope#setToInfinite infinite envelope} if the bbox is {@code null}.
* @throws IllegalArgumentException if the given CRS is {@code null}, or if the bbox string
* contains too much parameters to fill the CRS ranges.
*/
public static Envelope toEnvelope(final String bbox, final CoordinateReferenceSystem crs)
throws IllegalArgumentException {
if (crs == null) {
throw new IllegalArgumentException("The CRS must not be null");
}
if (bbox == null) {
final GeneralEnvelope infinite = new GeneralEnvelope(crs);
infinite.setToInfinite();
return infinite;
}
final GeneralEnvelope envelope = new GeneralEnvelope(crs);
final int dimension = envelope.getDimension();
final StringTokenizer tokens = new StringTokenizer(bbox, ",;");
final double[] coordinates = new double[dimension * 2];
int index = 0;
while (tokens.hasMoreTokens()) {
final double value = toDouble(tokens.nextToken());
if (index >= coordinates.length) {
throw new IllegalArgumentException(
Errors.format(Errors.Keys.IllegalCsDimension_1, coordinates.length));
}
coordinates[index++] = value;
}
if ((index & 1) != 0) {
throw new IllegalArgumentException(Errors.format(Errors.Keys.OddArrayLength_1, index));
}
// Fallthrough in every cases.
switch (index) {
default:
{
while (index >= 6) {
final double maximum = coordinates[--index];
final double minimum = coordinates[--index];
envelope.setRange(index >> 1, minimum, maximum);
}
}
case 4:
envelope.setRange(1, coordinates[1], coordinates[3]);
case 3:
case 2:
envelope.setRange(0, coordinates[0], coordinates[2]);
case 1:
case 0:
break;
}
/*
* Checks the envelope validity. Given that the parameter order in the bounding box
* is a little-bit counter-intuitive, it is worth to perform this check in order to
* avoid a NonInvertibleTransformException at some later stage.
*/
for (index = 0; index < dimension; index++) {
final double minimum = envelope.getMinimum(index);
final double maximum = envelope.getMaximum(index);
if (!(minimum < maximum)) {
throw new IllegalArgumentException(
Errors.format(Errors.Keys.IllegalRange_2, minimum, maximum));
}
}
return envelope;
}
/**
* Converts a string representing the bbox coordinates into a {@link GeneralEnvelope}.
*
* @param bbox Coordinates of the bounding box, seperated by comas.
* @param crs The {@linkplain CoordinateReferenceSystem coordinate reference system} in which the
* envelope is expressed. Must not be {@code null}.
* @return The enveloppe for the bounding box specified, or an {@linkplain
* GeneralEnvelope#setToInfinite infinite envelope} if the bbox is {@code null}.
*/
public static Envelope toEnvelope(
final String bbox,
final CoordinateReferenceSystem crs,
final String strElevation,
final String strTime)
throws IllegalArgumentException, ParseException, FactoryException {
final CoordinateReferenceSystem horizontalCRS = CRS.getHorizontalComponent(crs);
final VerticalCRS verticalCRS;
final TemporalCRS temporalCRS;
final double[] dimX = new double[] {Double.NaN, Double.NaN};
final double[] dimY = new double[] {Double.NaN, Double.NaN};
final double[] dimZ = new double[] {Double.NaN, Double.NaN};
final double[] dimT = new double[] {Double.NaN, Double.NaN};
// parse bbox -----------------------------------------------------------
if (bbox == null) {
// set to infinity
dimX[0] = dimY[0] = Double.NEGATIVE_INFINITY;
dimX[1] = dimY[1] = Double.POSITIVE_INFINITY;
} else {
final StringTokenizer tokens = new StringTokenizer(bbox, ",;");
final double[] values = new double[4];
int index = 0;
while (tokens.hasMoreTokens()) {
values[index] = toDouble(tokens.nextToken());
if (index >= 4) {
throw new IllegalArgumentException(Errors.format(Errors.Keys.IndexOutOfBounds_1, index));
}
index++;
}
if (index != 5) {
throw new IllegalArgumentException(Errors.format(Errors.Keys.IllegalArgument_1, index));
}
dimX[0] = values[0];
dimX[1] = values[2];
dimY[0] = values[1];
dimY[1] = values[3];
}
// parse elevation ------------------------------------------------------
if (strElevation != null) {
final double elevation = toDouble(strElevation);
dimZ[0] = dimZ[1] = elevation;
final VerticalCRS zCRS = CRS.getVerticalComponent(crs, true);
verticalCRS = (zCRS != null) ? zCRS : CommonCRS.Vertical.MEAN_SEA_LEVEL.crs();
} else {
verticalCRS = null;
}
// parse temporal -------------------------------------------------------
if (strTime != null) {
final Date date = TemporalUtilities.parseDateSafe(strTime, true);
final TemporalCRS tCRS = CRS.getTemporalComponent(crs);
temporalCRS = (tCRS != null) ? tCRS : CommonCRS.Temporal.MODIFIED_JULIAN.crs();
dimT[0] = dimT[1] = ((DefaultTemporalCRS) temporalCRS).toValue(date);
} else {
temporalCRS = null;
}
// create the 2/3/4 D BBox ----------------------------------------------
if (verticalCRS != null && temporalCRS != null) {
final CoordinateReferenceSystem finalCRS =
new GeodeticObjectBuilder()
.addName("rendering bbox")
.createCompoundCRS(horizontalCRS, verticalCRS, temporalCRS);
final GeneralEnvelope envelope = new GeneralEnvelope(finalCRS);
envelope.setRange(0, dimX[0], dimX[1]);
envelope.setRange(1, dimY[0], dimY[1]);
envelope.setRange(2, dimZ[0], dimZ[1]);
envelope.setRange(3, dimT[0], dimT[1]);
return envelope;
} else if (verticalCRS != null) {
final CoordinateReferenceSystem finalCRS =
new GeodeticObjectBuilder()
.addName("rendering bbox")
.createCompoundCRS(horizontalCRS, verticalCRS);
final GeneralEnvelope envelope = new GeneralEnvelope(finalCRS);
envelope.setRange(0, dimX[0], dimX[1]);
envelope.setRange(1, dimY[0], dimY[1]);
envelope.setRange(2, dimZ[0], dimZ[1]);
return envelope;
} else if (temporalCRS != null) {
final CoordinateReferenceSystem finalCRS =
new GeodeticObjectBuilder()
.addName("rendering bbox")
.createCompoundCRS(horizontalCRS, temporalCRS);
final GeneralEnvelope envelope = new GeneralEnvelope(finalCRS);
envelope.setRange(0, dimX[0], dimX[1]);
envelope.setRange(1, dimY[0], dimY[1]);
envelope.setRange(2, dimT[0], dimT[1]);
return envelope;
} else {
final GeneralEnvelope envelope = new GeneralEnvelope(horizontalCRS);
envelope.setRange(0, dimX[0], dimX[1]);
envelope.setRange(1, dimY[0], dimY[1]);
return envelope;
}
}
/**
* Returns the format if it is a known format, that can be used for writting.
*
* @param format The format chosen, as a string.
* @return The supported format, or {@code null} if the given format is {@code null}.
* @throws IllegalArgumentException if the given string is not a known format.
*/
public static String toFormat(String format) throws IllegalArgumentException {
if (format == null) {
return null;
}
format = format.trim();
if (!SUPPORTED_FORMATS.contains(format)) {
throw new IllegalArgumentException("Invalid format specified.");
}
return format;
}
/**
* Extends the {@link Integer#valueOf(String)} method, in removing the leading and trailing
* whitespace.
*
* @param value A string representing an integer value.
* @return An integer representation of the given string.
* @throws NumberFormatException if the given value is {@code null}, or if the string can't be
* parsed as an integer value.
*/
public static int toInt(String value) throws NumberFormatException {
if (value == null) {
throw new NumberFormatException("Int value not defined.");
}
value = value.trim();
return Integer.parseInt(value);
}
/**
* Takes a string with the pattern: beginVal,lastVal/otherVal. That string will be splitted in
* order to return a list of ranges.
*
* @param ranges A string representing a list of ranges.
*/
public static List<Double[]> toCategoriesRange(final String ranges) {
final List<Double[]> exts = new ArrayList<Double[]>();
final String[] blocks = ranges.split("/");
for (final String block : blocks) {
final String[] parts = block.split(",");
if (parts.length == 1) {
// single value range
final Double d = Double.valueOf(parts[0]);
exts.add(new Double[] {d, d});
} else if (parts.length == 2) {
// interval range
final Double d1 = Double.valueOf(parts[0]);
final Double d2 = Double.valueOf(parts[1]);
exts.add(new Double[] {d1, d2});
} else {
// not possible, invalid string
throw new IllegalArgumentException("Range definition is not valid : " + ranges);
}
}
Collections.sort(
exts,
new Comparator<Double[]>() {
@Override
public int compare(Double[] t, Double[] t1) {
double res = t[0] - t1[0];
if (res < 0) {
return -1;
}
if (res > 0) {
return 1;
}
res = t[1] - t1[1];
if (res < 0) {
return -1;
}
if (res > 0) {
return 1;
}
return 0;
}
});
return exts;
}
}