Merge pull request #79 from geosolutions-it/77-1.5.x-missing-support-jp2k

fix: missing jp2k support. close 77

src/main/java/it/geosolutions/geoserver/rest/encoder/coverage/GSImageMosaicEncoder.java

@@ -35,6 +35,7 @@ import org.jdom.Element;
 import org.jdom.filter.Filter;
 
 /**
+ * Use this encoder for ImageMosaic coverages.
  * 
  * @author Carlo Cancellieri - carlo.cancellieri@geo-solutions.it
  * 
@@ -42,6 +43,7 @@ import org.jdom.filter.Filter;
 public class GSImageMosaicEncoder extends GSCoverageEncoder {
 
     final private static String STRING = "string";
+
     final private static String ENTRY = "entry";
 
     final private NestedElementEncoder parameters = new NestedElementEncoder("parameters");
@@ -53,11 +55,13 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
 
     static class parametersFilter implements Filter {
         final String name;
+
         public parametersFilter(final String name) {
             this.name = name;
         }
 
         private static final long serialVersionUID = 1L;
+
         public boolean matches(Object obj) {
             if (obj instanceof Element) {
                 if (((Element) obj).getName().equals(ENTRY)) {
@@ -85,7 +89,17 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
         return false;
     }
 
+    private final Element getParameter(final Filter filter) {
+        final Iterator<Element> it = ElementUtils.search(getRoot(), filter).iterator();
+        if (it.hasNext()) {
+            final Element el = it.next();
+            return ElementUtils.contains(el, el);
+        }
+        return null;
+    }
+
     private final static String allowMultithreading = "AllowMultithreading";
+
     /**
      * @param val
      */
@@ -97,13 +111,30 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
         parameters.add(null, list);
     }
 
-	private final static Filter allowMultithreadingFilter=new parametersFilter(allowMultithreading);
+    private final static Filter allowMultithreadingFilter = new parametersFilter(
+            allowMultithreading);
+
     public void setAllowMultithreading(final boolean val) {
         removeParameter(allowMultithreadingFilter);
         addAllowMultithreading(val);
     }
 
+    public Boolean getAllowMultithreading() {
+        Element el = getParameter(allowMultithreadingFilter);
+        if (el != null) {
+            List<Element> values = el.getChildren();
+            for (Element elm : values) {
+                String value = elm.getValue();
+                if (!value.equalsIgnoreCase(allowMultithreading)) {
+                    return Boolean.valueOf(value);
+                }
+            }
+        }
+        return null;
+    }
+
     private final static String filter = "Filter";
+
     /**
      * @param val
      */
@@ -115,12 +146,14 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
     }
 
     private final static Filter filterFilter = new parametersFilter(filter);
+
     public void setFilter(final String val) {
         removeParameter(filterFilter);
         addFilter(val);
     }
 
     private final static String maxAllowedTiles = "MaxAllowedTiles";
+
     /**
      * @param val
      */
@@ -132,12 +165,14 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
     }
 
     private final static Filter maxAllowedTilesFilter = new parametersFilter(maxAllowedTiles);
+
     public void setMaxAllowedTiles(final int val) {
         removeParameter(maxAllowedTilesFilter);
         addMaxAllowedTiles(val);
     }
 
     private final static String inputTransparentColor = "InputTransparentColor";
+
     /**
      * @param val
      */
@@ -148,13 +183,16 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
         parameters.add(null, list);
     }
 
-	private final static Filter inputTransparentColorFilter=new parametersFilter(inputTransparentColor);
+    private final static Filter inputTransparentColorFilter = new parametersFilter(
+            inputTransparentColor);
+
     public void setInputTransparentColor(final String val) {
         removeParameter(inputTransparentColorFilter);
         addInputTransparentColor(val);
     }
 
     private final static String outputTransparentColor = "OutputTransparentColor";
+
     /**
      * @param val
      */
@@ -165,13 +203,16 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
         parameters.add(null, list);
     }
 
-	private final static Filter outputTransparentColorFilter=new parametersFilter(outputTransparentColor);
+    private final static Filter outputTransparentColorFilter = new parametersFilter(
+            outputTransparentColor);
+
     public void setOutputTransparentColor(final String val) {
         removeParameter(outputTransparentColorFilter);
         addInputTransparentColor(val);
     }
 
     private final static String SUGGESTED_TILE_SIZE = "SUGGESTED_TILE_SIZE";
+
     /**
      * @param val
      */
@@ -182,13 +223,31 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
         parameters.add(null, list);
     }
 
-	private final static Filter SUGGESTED_TILE_SIZEFilter=new parametersFilter(SUGGESTED_TILE_SIZE);
+    private final static Filter SUGGESTED_TILE_SIZEFilter = new parametersFilter(
+            SUGGESTED_TILE_SIZE);
+
     public void setSUGGESTED_TILE_SIZE(final String val) {
         removeParameter(SUGGESTED_TILE_SIZEFilter);
         addSUGGESTED_TILE_SIZE(val);
     }
 
+    public String getSuggestedTileSize() {
+        Element el = getParameter(SUGGESTED_TILE_SIZEFilter);
+        if (el != null) {
+            List<Element> values = el.getChildren();
+            for (Element elm : values) {
+                String value = elm.getValue();
+                if (!value.equalsIgnoreCase(SUGGESTED_TILE_SIZE)) {
+                    return value;
+                }
+            }
+
+        }
+        return null;
+    }
+
     private final static String USE_JAI_IMAGEREAD = "USE_JAI_IMAGEREAD";
+
     /**
      * @param val
      */
@@ -200,12 +259,28 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
     }
 
     private final static Filter USE_JAI_IMAGEREADFilter = new parametersFilter(USE_JAI_IMAGEREAD);
+
     public void setUSE_JAI_IMAGEREAD(final boolean val) {
         removeParameter(USE_JAI_IMAGEREADFilter);
         addUSE_JAI_IMAGEREAD(val);
     }
 
+    public Boolean getUseJaiImageRead() {
+        Element el = getParameter(USE_JAI_IMAGEREADFilter);
+        if (el != null) {
+            List<Element> values = el.getChildren();
+            for (Element elm : values) {
+                String value = elm.getValue();
+                if (!value.equalsIgnoreCase(USE_JAI_IMAGEREAD)) {
+                    return Boolean.valueOf(value);
+                }
+            }
+        }
+        return null;
+    }
+
     private final static String backgroundValues = "BackgroundValues";
+
     /**
      * @param val
      */
@@ -217,6 +292,7 @@ public class GSImageMosaicEncoder extends GSCoverageEncoder {
     }
 
     private final static Filter backgroundValuesFilter = new parametersFilter(backgroundValues);
+
     public void setBackgroundValues(final String val) {
         removeParameter(backgroundValuesFilter);
         addBackgroundValues(val);

src/main/java/it/geosolutions/geoserver/rest/encoder/coverage/GSJP2KEncoder.java

@@ -0,0 +1,208 @@
+/*
+ *  GeoServer-Manager - Simple Manager Library for GeoServer
+ *  
+ *  Copyright (C) 2007,2011 GeoSolutions S.A.S.
+ *  http://www.geo-solutions.it
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package it.geosolutions.geoserver.rest.encoder.coverage;
+
+import it.geosolutions.geoserver.rest.encoder.utils.ElementUtils;
+import it.geosolutions.geoserver.rest.encoder.utils.NestedElementEncoder;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.jdom.Element;
+import org.jdom.filter.Filter;
+
+/**
+ * Should be used to encode a Jpeg2K coverage.
+ * 
+ * @author Carlo Cancellieri - carlo.cancellieri@geo-solutions.it
+ * 
+ */
+public class GSJP2KEncoder extends GSCoverageEncoder {
+
+    final private static String STRING = "string";
+
+    final private static String ENTRY = "entry";
+
+    final private NestedElementEncoder parameters = new NestedElementEncoder("parameters");
+
+    public GSJP2KEncoder() {
+        // Link members to the parent
+        addContent(parameters.getRoot());
+    }
+
+    static class parametersFilter implements Filter {
+        final String name;
+
+        public parametersFilter(final String name) {
+            this.name = name;
+        }
+
+        private static final long serialVersionUID = 1L;
+
+        public boolean matches(Object obj) {
+            if (obj instanceof Element) {
+                if (((Element) obj).getName().equals(ENTRY)) {
+                    List<Element> values=((Element) obj).getChildren(STRING);
+                    for (Element el : values){
+                        if (el == null)
+                            return false;
+                        if (el.getText().equals(this.name)) {
+                            return true;
+                        }
+                    }
+//                    final Element el = ((Element) obj).getChild(STRING);
+//                    if (el == null)
+//                        return false;
+//                    if (el.getText().equals(this.name)) {
+//                        return true;
+//                    }
+                }
+            }
+            return false;
+        }
+    };
+
+    private final boolean removeParameter(final Filter filter) {
+        final Iterator<Element> it = ElementUtils.search(getRoot(), filter).iterator();
+        if (it.hasNext()) {
+            final Element el = it.next();
+            return ElementUtils.remove(el, el);
+        }
+        return false;
+    }
+    
+    private final Element getParameter(final Filter filter) {
+        final Iterator<Element> it = ElementUtils.search(getRoot(), filter).iterator();
+        if (it.hasNext()) {
+            final Element el = it.next();
+            return ElementUtils.contains(el, el);
+        }
+        return null;
+    }
+
+    private final static String useMultithreading = "USE_MULTITHREADING";
+
+    /**
+     * @param val
+     */
+    protected void addUseMultithreading(final boolean val) {
+        final List<Element> list = new ArrayList<Element>(2);
+        list.add(new Element(STRING).setText(useMultithreading));
+        list.add(new Element(STRING).setText((val) ? "true" : "false"));
+
+        parameters.add(null, list);
+    }
+
+    private final static Filter useMultithreadingFilter = new parametersFilter(useMultithreading);
+
+    public void setUseMultithreading(final boolean val) {
+        removeParameter(useMultithreadingFilter);
+        addUseMultithreading(val);
+    }
+    
+    public Boolean getUseMultithreading() {
+        Element el=getParameter(useMultithreadingFilter);
+        if (el!=null){
+            List<Element> values=el.getChildren();
+            for (Element elm : values){
+                String value=elm.getValue();
+                if (!value.equalsIgnoreCase(useMultithreading)){
+                    return Boolean.valueOf(value);
+                }
+            }
+        }
+        return null;
+    }
+
+    private final static String SUGGESTED_TILE_SIZE = "SUGGESTED_TILE_SIZE";
+
+    /**
+     * @param val
+     */
+    protected void addSuggestedTileSize(final String val) {
+        final List<Element> list = new ArrayList<Element>(2);
+        list.add(new Element(STRING).setText(SUGGESTED_TILE_SIZE));
+        list.add(new Element(STRING).setText(val));
+        parameters.add(null, list);
+    }
+
+    private final static Filter SUGGESTED_TILE_SIZEFilter = new parametersFilter(
+            SUGGESTED_TILE_SIZE);
+
+    public void setSuggestedTileSize(final String val) {
+        removeParameter(SUGGESTED_TILE_SIZEFilter);
+        addSuggestedTileSize(val);
+    }
+    
+    public String getSuggestedTileSize() {
+        Element el=getParameter(SUGGESTED_TILE_SIZEFilter);
+        if (el!=null){
+            List<Element> values=el.getChildren();
+            for (Element elm : values){
+                String value=elm.getValue();
+                if (!value.equalsIgnoreCase(SUGGESTED_TILE_SIZE)){
+                    return value;
+                }
+            }
+             
+        }
+        return null;
+    }
+
+    private final static String USE_JAI_IMAGEREAD = "USE_JAI_IMAGEREAD";
+
+    /**
+     * @param val
+     */
+    protected void addUseJaiImageRead(final boolean val) {
+        final List<Element> list = new ArrayList<Element>(2);
+        list.add(new Element(STRING).setText(USE_JAI_IMAGEREAD));
+        list.add(new Element(STRING).setText((val) ? "true" : "false"));
+        parameters.add(null, list);
+    }
+
+    private final static Filter USE_JAI_IMAGEREADFilter = new parametersFilter(USE_JAI_IMAGEREAD);
+
+    public void setUseJaiImageRead(final boolean val) {
+        removeParameter(USE_JAI_IMAGEREADFilter);
+        addUseJaiImageRead(val);
+    }
+    
+    public Boolean getUseJaiImageRead() {
+        Element el=getParameter(USE_JAI_IMAGEREADFilter);
+        if (el!=null){
+            List<Element> values=el.getChildren();
+            for (Element elm : values){
+                String value=elm.getValue();
+                if (!value.equalsIgnoreCase(USE_JAI_IMAGEREAD)){
+                    return Boolean.valueOf(value);
+                }
+            }
+        }
+        return null;
+    }
+
+}

src/test/java/it/geosolutions/geoserver/rest/encoder/coverage/GSImageMosaicEncoderTest.java

@@ -24,6 +24,7 @@ import junit.framework.TestCase;
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.util.Assert;
 
 /**
  * 
@@ -46,14 +47,23 @@ public class GSImageMosaicEncoderTest extends TestCase {
     public void testAll() {
         final GSImageMosaicEncoder encoder = new GSImageMosaicEncoder();
 
-    	encoder.addAllowMultithreading(true);
+        Assert.isNull(encoder.getUseJaiImageRead());
-    	LOGGER.info(encoder.toString());
-    	encoder.setAllowMultithreading(false);
-    	LOGGER.info(encoder.toString());
 
+        encoder.setAllowMultithreading(true);
+
+        Assert.isTrue(encoder.getAllowMultithreading());
+
+        encoder.setAllowMultithreading(false);
+
+        Assert.isTrue(!encoder.getAllowMultithreading());
+
+        encoder.setSUGGESTED_TILE_SIZE("512,512");
+
+        Assert.isTrue(encoder.getSuggestedTileSize().equalsIgnoreCase("512,512"));
+
+        LOGGER.info(encoder.toString());
 
         encoder.addSUGGESTED_TILE_SIZE("512,512");
 
-    	
     }
 }

src/test/java/it/geosolutions/geoserver/rest/encoder/coverage/GSJP2KEncoderTest.java

@@ -0,0 +1,67 @@
+/*
+ *  Copyright (C) 2007 - 2011 GeoSolutions S.A.S.
+ *  http://www.geo-solutions.it
+ * 
+ *  GPLv3 + Classpath exception
+ * 
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package it.geosolutions.geoserver.rest.encoder.coverage;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.Assert;
+
+/**
+ *
+ * @author Carlo Cancellieri - carlo.cancellieri@geo-solutions.it
+ */
+public class GSJP2KEncoderTest extends TestCase {
+
+    public GSJP2KEncoderTest() {
+    }
+
+    /**
+     * Default logger
+     */
+    protected final static Logger LOGGER = LoggerFactory.getLogger(GSJP2KEncoderTest.class);
+    
+    /**
+     * TODO implement this test
+     */
+    @Test
+    public void testAll() {
+    	final GSJP2KEncoder encoder=new GSJP2KEncoder();
+    
+    	Assert.isNull(encoder.getUseJaiImageRead());
+    	
+    	encoder.setUseMultithreading(true);
+    	LOGGER.info(encoder.toString());
+    	Assert.isTrue(encoder.getUseMultithreading());
+    	
+    	encoder.setUseMultithreading(false);
+    	
+    	Assert.isTrue(!encoder.getUseMultithreading());
+    	
+    	encoder.setSuggestedTileSize("512,512");
+    	
+    	Assert.isTrue(encoder.getSuggestedTileSize().equalsIgnoreCase("512,512"));
+    	
+    	LOGGER.info(encoder.toString());
+    	
+    }
+}