Initial commit

Author: Ty Coghlan

LICENSE.txt

@@ -0,0 +1,21 @@
+Unfolding - Map Library
+
+Copyright (C) 2013 Till Nagel, and contributors
+
+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.

buildingDB.csv

@@ -0,0 +1,6 @@
+Manifest-Version: 1.0
+Class-Path: groovy-all-2.3.9.jar core.jar gluegen-rt.jar jogl-all.jar 
+ json4processing.jar libTUIO.jar log4j-1.2.15.jar sqlite-jdbc-3.7.2.ja
+ r unfolding.0.9.6.jar VisualizationIntelliJProjects.jar
+Main-Class: VisualizationMap.HelloUnfoldingWorld
+

lib/VisualizationIntelliJProjects.jar

@@ -0,0 +1,53 @@
+sID,Name,Abbreviation,bID
+0,Barletta Natatorium,BN,0
+1,Behrakis Center,BK,1
+2,Cabot Center,CB,2
+3,Cargill Hall,CG,3
+4,Churchill Hall,CH,4
+5,Columbus Place,CP,5
+6,Cullinane Hall,CN,6
+7,Curry Student Center,CSC,7
+8,Dana Research Center,DA,8
+9,Dockser Hall,DK,9
+10,Dodge Hall,DG,10
+11,Egan Research Center,EC,11
+12,Ell Hall,EL,12
+13,Fenway Center,FC,13
+14,Forsyth Visual.Building,FR,14
+15,Hayden Hall,HA,15
+16,Holmes/Meserve,HO/ME,16
+17,Hurtig Hall,HT,17
+18,International Village,INV,18
+19,Kariotis Hall,KA,19
+20,Knowles Center,KN,20
+21,Lake/Nightingale,LA/NI,21
+22,Levine Hall,LV,22
+23,Marino Recreation Center,MC,23
+24,Marino Vendor - ABP, MV-ABP,23
+25,Marino Vendor - NO, MV-NO,23
+26,Marino Vendor - SPTA, MV-SPTA,23
+27,Marino Vendor - Wollastons, MV-WO,23
+28,Marino Vendor - Wraps, MV-WR,23
+29,Matthews Arena,MA,24
+30,Mugar Visual.Building,MU,25
+31,Power Plant,PP,26
+32,Richards Hall,RI,27
+33,Robinson Hall,RB,28
+34,Ryder Hall,RY,29
+35,Shillman Hall,SH,30
+36,Snell Engineering Center,SN,31
+37,Snell Library,SL,32
+38,Speare Hall,SP,33
+39,Stearns Center,ST,34
+40,Stetson West,SW,35
+41,Stetson East,SE,36
+42,West Village A,WVA,37
+43,West Village B,WVB,38
+44,West Village B Vendor - Wollastons,WVBV-WO,38
+45,West Village C,WVC,39
+46,West Village E,WVE,40
+47,West Village F,WVF,41
+48,West Village G,WVG,42
+49,West Village H,WVH,43
+50,White Hall,WH,44
+51,Willis Hall,WI,45

lib/core.jar

@@ -0,0 +1,244 @@
+package VisualizationMap;
+
+import de.fhpotsdam.unfolding.geo.Location;
+import de.fhpotsdam.unfolding.marker.SimplePolygonMarker;
+import de.fhpotsdam.unfolding.utils.MapPosition;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+
+
+import Visual.Building;
+import Visual.LatLong;
+import processing.core.PGraphics;
+
+/**
+ * A marker used to represent a building on the map
+ */
+public final class BuildingMarker extends SimplePolygonMarker implements Comparable<BuildingMarker> {
+  Building building;
+  private Color c;
+  BuildingMarker(Building b/*, Color c*/) {
+    Objects.requireNonNull(b, "Building must be set");
+    building = b;
+    List<Location> locations = new ArrayList<>();
+    for (LatLong l : b.outline()) {
+      Location loc = new Location(l.longitude(), l.lat());
+      locations.add(loc);
+    }
+    this.addLocations(locations);
+    c = new Color(255, 255, 255, 0);
+  }
+
+  @Override
+  public int compareTo(BuildingMarker other) {
+    Objects.requireNonNull(other);
+    return this.building.compareTo(other.building);
+  }
+
+  public void draw(PGraphics pg, List<MapPosition> mapPositions) {
+    // marker
+    pg.pushStyle();
+    pg.strokeWeight(2);
+    pg.stroke(0, 0, 0);
+    pg.fill(c.r, c.g, c.b, c.alpha);
+    if (this.isSelected()) {
+      pg.fill(255, 255, 255, 255);
+    }
+    pg.beginShape();
+    for (MapPosition mapPosition : mapPositions) {
+      pg.vertex(mapPosition.x, mapPosition.y);
+    }
+    pg.endShape();
+    pg.popStyle();
+  }
+
+  /**
+   * Sets the fill color
+   * @param c the new fill color
+   */
+  public void newColor(Color c) {
+    this.c = c;
+  }
+
+  /**
+   * Balances out all of the colors according to the current time, from min to max.
+   *
+   * @param markers the list of markers to balance out
+   * @param time    the time to balance with
+   * @throws IllegalArgumentException if there are more than 255 markers
+   */
+  static void balanceColors(ArrayList<BuildingMarker> markers, long time) {
+    if (markers.size() > 255) {
+      throw new IllegalArgumentException("Too many markers, can only balance a total" +
+              "of 255 markers");
+    }
+    for (BuildingMarker marker : markers) {
+      marker.building.changeTime(time);
+    }
+    Collections.sort(markers);
+    for (int i = 0; i < markers.size(); i++) {
+      BuildingMarker bm = markers.get(i);
+      if (bm.building.currentWattage() == 0) {
+        bm.newColor(new Color(0, 128, 255, 225));
+      } else {
+        int diff = 255 / markers.size();
+        bm.newColor(new Color(255, 255 - (diff * i), 0, 175));
+      }
+    }
+  }
+
+  /**
+   * Creates an array of doubles for last specified number of readings differing among the
+   * specified number of times.
+   * @param minTime the minimum point which there are no times past
+   * @param timeDiff how much to offset the times by
+   * @param numberOfReadings how many times to count down
+   * @return the array of watts for the last specified times.
+   */
+  double[] lastReadings(long minTime, long timeDiff, int numberOfReadings) {
+    if (numberOfReadings < 1) {
+      throw new IllegalArgumentException("There must be a number of readings");
+    }
+    if (timeDiff < 1) {
+      throw new IllegalArgumentException("Must have a positive integer for time difference");
+    }
+    double[] result = new double[numberOfReadings];
+    for (int i = 0; i < numberOfReadings; i++) {
+      long time = building.currentTime() - (timeDiff * i);
+      if (time < minTime) {
+        result[i] = -1.0;
+      } else {
+        result[i] = building.wattage(time);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Identifies the maximum and minimum value in the array, and scales them down
+   * to [0, 1]
+   * @param toScale the array of doubles to scale
+   * @return an array of values between [0, 1] representing the relative size to the max
+   * and min value of the original array
+   */
+  double[] scaleDoubles(double[] toScale) {
+    double max = 0.0;
+    double min = 0.0;
+    if (toScale.length > 0) {
+      max = toScale[0];
+      min = toScale[0];
+    }
+    for (double d : toScale) {
+      if (d > max) {
+        max = d;
+      }
+      if (d < min) {
+        min = d;
+      }
+    }
+    max -= min;
+    double[] result = new double[toScale.length];
+    if (max == 0) {
+      return result;
+    }
+    for (int i = 0; i < toScale.length; i++) {
+      result[i] = (toScale[i] - min) / max;
+    }
+    return result;
+  }
+
+  /**
+   * Creates the string array containing the last week worth of power readings
+   * @param minTime the minimum time that there are no readings past.
+   * @return the week's worth of readings in a string array.
+   */
+  String[] lastWeek(long minTime) {
+    String[] result = new String[7];
+    long currentTime = this.building.currentTime();
+    long timeDiff = 86400;
+    SimpleDateFormat sdf = new SimpleDateFormat("MMMM d");
+    for (int i = 0; i < 7; i++) {
+      if (i == 0) {
+        String watt = Double.toString(building.currentWattage());
+        if (watt.length() > 9) {
+          watt = watt.substring(0, 9);
+        }
+        watt += " Watts";
+        result[i] = "Today: " + watt;
+      } else if ((currentTime - (timeDiff * i)) < minTime) {
+        result[i] = "No such time: ";
+      } else {
+        String watt = Double.toString(building.wattage(currentTime - (timeDiff * i)));
+        if (watt.length() > 9) {
+          watt = watt.substring(0, 9);
+        }
+        watt += " Watts";
+        result[i] = sdf.format((currentTime - (timeDiff * i)) * 1000) + ": " + watt;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Converts the given string date into unix time.
+   * @param givenDate the string to parse. Must be in "mmddyyyy"
+   * @return the unix time
+   */
+  static long stringToUnix(String givenDate) {
+    DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");
+    try {
+      Date date = dateFormat.parse(givenDate);
+      long unixTime = date.getTime() / 1000;
+      System.out.println(unixTime);
+      return unixTime;
+    } catch (ParseException e) {
+      throw new IllegalArgumentException("String must be formatted as \"DAYMONTHYEAR in" +
+              " numbers\"");
+    }
+  }
+
+  static String unixTostring(long unix) {
+    DateFormat dateFormat = new SimpleDateFormat("MMMM d, yyyy 'at' hh:mm");
+    return dateFormat.format(unix * 1000);
+  }
+
+  /**
+   * Clamps the given int between [0, 255]
+   * @param i the number to clamp
+   * @return the clamped number
+   */
+  private static int clamp(int i) {
+    if (i > 255) {
+      return 255;
+    } else if (i < 0) {
+      return 0;
+    } else {
+      return i;
+    }
+  }
+
+
+  /**
+   * A class to hold rgb values.
+   */
+  static class Color {
+    public final int r;
+    public final int g;
+    public final int b;
+    public final int alpha;
+
+    Color(int r, int g, int b, int alpha) {
+      this.r = clamp(r);
+      this.g = clamp(g);
+      this.b = clamp(b);
+      this.alpha = clamp(alpha);
+    }
+  }
+}