Adding ability to process coordinates before drawing. Adding the ability to AltitudeProcessor

Author: CodingPupper3033

src/main/java/com/codingpupper3033/codebtekml/events/KeyPressed.java

@@ -1,7 +1,7 @@
 package com.codingpupper3033.codebtekml.events;
 
 import com.codingpupper3033.codebtekml.KeyInit;
-import com.codingpupper3033.codebtekml.gui.screens.GuiDrawKML;
+import com.codingpupper3033.codebtekml.helpers.map.altitude.AltitudeProcessor;
 import net.minecraft.client.Minecraft;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent.ClientTickEvent;
@@ -15,7 +15,8 @@ public class KeyPressed {
     public void clientTick(ClientTickEvent event) {
         if (Minecraft.getMinecraft().currentScreen == null) { // Keystrokes that only work on the default game menu
             // Open KML Menu
-            if (KeyInit.openKMLMenuKeybind.isPressed()) Minecraft.getMinecraft().displayGuiScreen(new GuiDrawKML(null));
+            //if (KeyInit.openKMLMenuKeybind.isPressed()) Minecraft.getMinecraft().displayGuiScreen(new GuiDrawKML(null));
+            if (KeyInit.openKMLMenuKeybind.isPressed()) AltitudeProcessor.defaultProcessor.processCoordinateQueue();
         }
     }
 }

src/main/java/com/codingpupper3033/codebtekml/helpers/map/Coordinate.java

@@ -19,6 +19,22 @@ public class Coordinate {
 
     private final AltitudeMode altitudeMode;
 
+    /**
+     * Instantiates a new Coordinate.
+     *
+     * @param lat          the latitude
+     * @param lon          the longitude
+     * @param elv          the elevation
+     * @param altitudeMode the altitude mode
+     * @see AltitudeMode
+     */
+    public Coordinate(double lat, double lon, double elv, AltitudeMode altitudeMode) {
+        this.lon = lon;
+        this.lat = lat;
+        this.elv = elv;
+        this.altitudeMode = altitudeMode;
+    }
+
     public double getLongitude() {
         return lon;
     }
@@ -35,21 +51,8 @@ public AltitudeMode getAltitudeMode() {
         return altitudeMode;
     }
 
-
-    /**
-     * Instantiates a new Coordinate.
-     *
-     * @param lat          the latitude
-     * @param lon          the longitude
-     * @param elv          the elevation
-     * @param altitudeMode the altitude mode
-     * @see AltitudeMode
-     */
-    public Coordinate(double lat, double lon, double elv, AltitudeMode altitudeMode) {
-        this.lon = lon;
-        this.lat = lat;
-        this.elv = elv;
-        this.altitudeMode = altitudeMode;
+    public void setGroundLevel(Double groundLevel) {
+        this.groundLevel = groundLevel;
     }
 
     @Override
@@ -58,6 +61,7 @@ public String toString() {
                 ", " + lon +
                 ", " + elv +
                 ", " + altitudeMode.getNodeName() +
+                ", " + groundLevel +
                 ']';
     }
 
@@ -74,7 +78,7 @@ public double getAltitude() throws NoAltitudeException, IOException {
             case RELATIVE_TO_GROUND:
             case DEFAULT:
                 if (groundLevel == null) {
-                    groundLevel = AltitudeProcessor.defaultProcessor.getAltitude(this);
+                    groundLevel = AltitudeProcessor.defaultProcessor.getGroundLevel(this);
                 }
                 return groundLevel + getElevation();
             default:

src/main/java/com/codingpupper3033/codebtekml/helpers/map/altitude/AltitudeProcessor.java

@@ -3,6 +3,8 @@
 import com.codingpupper3033.codebtekml.helpers.map.Coordinate;
 
 import java.io.IOException;
+import java.util.LinkedList;
+import java.util.Queue;
 
 /**
  * Class that will process the altitude of a coordinate, based upon an AltitudeMode.
@@ -11,17 +13,34 @@
  * @author Joshua Miller
  */
 public class AltitudeProcessor {
+    /**
+     * Default Altitude Processor
+     * Currently it uses Open Elevation, as there appears to be no way to get ground level in java.
+     * The downside is that it requires internet access to make API requests.
+     */
+    public static AltitudeProcessor defaultProcessor = new OpenElevationAltitudeProcessor();
+
+    /**
+     * Can we use this?
+     */
+    public boolean enabled = true;
+
+    /**
+     * List of coordinates to process
+     */
+    public Queue<Coordinate> coordinateProcessorQueue = new LinkedList<>();
+
     /**
      * Default altitude method. Should not be used.
      * @param coordinate Coordinate containing the given altitude
      * @return
      * @throws IOException
      * @throws NoAltitudeException
      */
-    public double getAltitude(Coordinate coordinate) throws IOException, NoAltitudeException {
+    public double getGroundLevel(Coordinate coordinate) throws IOException, NoAltitudeException {
         if (!enabled) throw new NoAltitudeException();
         return 0;
-    };
+    }
 
     /**
      * Default altitude method. Should not be used.
@@ -30,20 +49,26 @@ public double getAltitude(Coordinate coordinate) throws IOException, NoAltitudeE
      * @throws IOException
      * @throws NoAltitudeException
      */
-    public double[] getAltitudes(Coordinate[] coordinates) throws IOException, NoAltitudeException {
+    public double[] getGroundLevels(Coordinate[] coordinates) throws IOException, NoAltitudeException {
         if (!enabled) throw new NoAltitudeException();
         return new double[]{};
-    };
+    }
 
-    /**
-     * Default Altitude Processor
-     * Currently it uses Open Elevation, as there appears to be no way to get ground level in java.
-     * The downside is that it requires internet access to make API requests.
-     */
-    public static AltitudeProcessor defaultProcessor = new OpenElevationAltitudeProcessor();
+    public void addCoordinateToProcessQueue(Coordinate coordinate) {
+        coordinateProcessorQueue.add(coordinate);
+    }
+
+    public Queue<Coordinate> getCoordinateProcessorQueue() {
+        return coordinateProcessorQueue;
+    }
 
     /**
-     * Can we use this?
+     * Empties the process coordinate queue
+     *
+     * @return
      */
-    public boolean enabled = true;
+    public boolean processCoordinateQueue() {
+
+        return false;
+    }
 }

src/main/java/com/codingpupper3033/codebtekml/helpers/map/altitude/OpenElevationAltitudeProcessor.java

@@ -24,14 +24,17 @@ public class OpenElevationAltitudeProcessor extends AltitudeProcessor {
     public static final String RESULTS_KEY = "results"; // JSON Key to get the results
     public static final String ELEVATION_KEY = "elevation"; // JSON Key to get the elevation
 
+    // Max amount of locations to ask for per request
+    public static final int MAX_COORDINATES_PER_REQUEST = 16;
+
     /**
      * @param coordinate Coordinate to get the altitude of
      * @return elevation of the ground at the coordinate
      * @throws IOException
      */
     @Override
-    public double getAltitude(Coordinate coordinate) throws IOException {
-        return getAltitudes(new Coordinate[]{coordinate})[0];
+    public double getGroundLevel(Coordinate coordinate) throws IOException {
+        return getGroundLevels(new Coordinate[]{coordinate})[0];
     }
 
     /**
@@ -40,7 +43,7 @@ public double getAltitude(Coordinate coordinate) throws IOException {
      * @throws IOException
      */
     @Override
-    public double[] getAltitudes(Coordinate[] coordinates) throws IOException {
+    public double[] getGroundLevels(Coordinate[] coordinates) throws IOException {
         StringBuffer coordsBuffer = new StringBuffer(); // Buffer of the coordinates to request from the API
 
         for (int i = 0; i < coordinates.length; i++) { // Add all coordinates
@@ -83,4 +86,41 @@ public double[] getAltitudes(Coordinate[] coordinates) throws IOException {
 
         return out;
     }
+
+
+    /**
+     * Processes the ground level for all Coordinates in the queue
+     * @return
+     */
+    @Override
+    public boolean processCoordinateQueue() {
+        super.processCoordinateQueue();
+
+        for (int i = 0; i <17; i++) {
+            coordinateProcessorQueue.add(new Coordinate(42.7264177662084, -73.67230722692297,0,AltitudeMode.RELATIVE_TO_GROUND));
+        }
+
+        while (!coordinateProcessorQueue.isEmpty()) { // Keep working until all out
+            Coordinate[] setOfLocationsToProcess = new Coordinate[Math.min(MAX_COORDINATES_PER_REQUEST,coordinateProcessorQueue.size())]; // Make it only as big as needed
+            int i = 0;
+            while (!coordinateProcessorQueue.isEmpty() && i < setOfLocationsToProcess.length) { // Only do the max size at a time
+                setOfLocationsToProcess[i] = coordinateProcessorQueue.poll();
+                i++;
+            }
+
+            // Process them
+            try {
+                double[] groundLevels = getGroundLevels(setOfLocationsToProcess);
+
+                for (int j = 0; j < setOfLocationsToProcess.length; j++) { // Add the result to the coordinate
+                    setOfLocationsToProcess[j].setGroundLevel(groundLevels[j]);
+                }
+                return true;
+            } catch (IOException e) {
+                return false;
+            }
+        }
+
+        return false;
+    }
 }