├── .gitignore
├── Config.pde
├── Functions.pde
├── Move.pde
├── MovesMapper_1_0.pde
├── Notes.pde
├── README.md
├── SampleScreen_1.png
├── SampleScreen_2.png
└── SampleScreen_3.png


/.gitignore:
--------------------------------------------------------------------------------
1 | # Ignore unneeded files.
2 | .DS_Store
3 | data/
4 | 


--------------------------------------------------------------------------------
/Config.pde:
--------------------------------------------------------------------------------
 1 | // - - - - - - - - - - - - - - - - - - - - - - - 
 2 | // PRIVATE GLOBAL VARIABLES
 3 | // - - - - - - - - - - - - - - - - - - - - - - - 
 4 | 
 5 | // Data
 6 | String accessToken = "<INSERT ACCESS TOKEN>";
 7 | 
 8 | // Time Zone
 9 | String tzOffsetLabel = "-4:00";
10 | int tzOffset = -14400;
11 | 


--------------------------------------------------------------------------------
/Functions.pde:
--------------------------------------------------------------------------------
  1 | 
  2 | // Initialize Empty Checkbox GUI 
  3 | // - - - - - - - - - - - - - - - - - - - - - - - 
  4 | void GUIcheckbox(String name_, int xpos_, int ypos_) {
  5 |   checkbox = cp5.addCheckBox(name_)
  6 |     .setPosition(xpos_, ypos_)
  7 |       .setColorForeground(color(190))
  8 |         .setColorBackground(color(60))
  9 |           .setColorActive(color(255, 128))
 10 |             .setColorLabel(color(255))
 11 |               .setSize(15, 15)
 12 |                 .setItemsPerRow(7)
 13 |                   .setSpacingColumn(20)
 14 |                     .setSpacingRow(10)
 15 |                       ;
 16 | }
 17 | 
 18 | // Initialize Empty Months Dropdown GUI
 19 | // - - - - - - - - - - - - - - - - - - - - - - - 
 20 | void GUIdropdownD1(String name_, int xpos_, int ypos_, String label_) {
 21 |   d1 = cp5.addDropdownList(name_)
 22 |     .setPosition(xpos_, ypos_)
 23 |       .setItemHeight(20)
 24 |         .setBarHeight(15)
 25 |           .setColorBackground(color(60))
 26 |             .setColorActive(color(255, 128))
 27 |               ;
 28 |   d1.captionLabel().style().marginTop = 3;
 29 |   d1.valueLabel().style().marginTop = 3;
 30 |   d1.captionLabel().set(label_);
 31 | }
 32 | 
 33 | 
 34 | // Initialize Empty Years Dropdown GUI 
 35 | // - - - - - - - - - - - - - - - - - - - - - - - 
 36 | void GUIdropdownD2(String name_, int xpos_, int ypos_, String label_) {
 37 |   d2 = cp5.addDropdownList(name_)
 38 |     .setPosition(xpos_, ypos_)
 39 |       .setItemHeight(20)
 40 |         .setBarHeight(15)
 41 |           .setColorBackground(color(60))
 42 |             .setColorActive(color(255, 128))
 43 |               ;
 44 |   d2.captionLabel().style().marginTop = 3;
 45 |   d2.valueLabel().style().marginTop = 3;
 46 |   d2.captionLabel().set(label_);
 47 | }
 48 | 
 49 | 
 50 | // Populate Months Dropdown 
 51 | // - - - - - - - - - - - - - - - - - - - - - - - 
 52 | void GUImonth(int year_, int month_, int monthSet) {
 53 |   if (year_ == year()) {
 54 |     for (int i=1; i<=month_; i++) {
 55 |       d1.addItem(monthNames[i-1], i);
 56 |     }
 57 |     d1.setValue(monthSet);
 58 |   } 
 59 |   else {
 60 |     for (int i=1; i<=monthNames.length; i++) {
 61 |       d1.addItem(monthNames[i-1], i);
 62 |     }
 63 |     d1.setValue(1);
 64 |   }
 65 | }
 66 | 
 67 | 
 68 | // Populate Years Dropdown 
 69 | // - - - - - - - - - - - - - - - - - - - - - - - 
 70 | void GUIyear(int year_) {
 71 |   for (int i=1; i+2011<=year_; i++) {
 72 |     d2.addItem(str(i+2011), i+2011);
 73 |   }
 74 |   d2.setValue(year_);
 75 | }
 76 | 
 77 | 
 78 | // Populate Days Dropdown 
 79 | // - - - - - - - - - - - - - - - - - - - - - - - 
 80 | void GUIday(int year_, int month_, int day_) {
 81 |   if (month_ == month() && year_ == year()) {
 82 |     for (int i=1; i<=day(); i++) {
 83 |       checkbox.addItem(str(i), i);
 84 |     }
 85 |     checkbox.toggle(day_-1);
 86 |   } 
 87 |   else {
 88 |     if (int(d2.getValue()) % 4 == 0) {
 89 |       for (int i=1; i<=int(monthDaysLeap[month_-1]); i++) {
 90 |         checkbox.addItem(str(i), i);
 91 |       }
 92 |       checkbox.toggle(0);
 93 |     } 
 94 |     else {
 95 |       for (int i=1; i<=int(monthDaysStandard[month_-1]); i++) {
 96 |         checkbox.addItem(str(i), i);
 97 |       }
 98 |       checkbox.toggle(0);
 99 |     }
100 |   }
101 | }
102 | 
103 | 
104 | // GUI Event Listener
105 | // - - - - - - - - - - - - - - - - - - - - - - - 
106 | void controlEvent(ControlEvent theEvent) {
107 |   if (theEvent.isFrom(checkbox)) {
108 |     listDates();
109 |     for (int i=0; i<movesDates.length; i++) {      
110 |       try {
111 |         moves.get(str(movesDates[i])).mapBounds();
112 |         moves.get(str(movesDates[i])).mapPaths();
113 |       }
114 |       catch (Exception e) {
115 |       }
116 |     }
117 |   } 
118 |   else if (theEvent.isFrom("d2-year") && frameCount > 2) {
119 |     checkbox.remove();
120 |     GUIday(int(d2.getValue()), 1, 1);
121 |     d1.clear();
122 |     GUImonth(int(d2.getValue()), month(), 1);
123 |   }
124 |   else if (theEvent.isFrom("d1-month") && frameCount > 2) {
125 |     checkbox.remove();
126 |     GUIcheckbox("checkbox", 150, height-135);
127 |     GUIday(int(d2.getValue()), int(d1.getValue()), 1);
128 |   }
129 | }
130 | 
131 | 
132 | // Format Events into Array of Dates 
133 | // - - - - - - - - - - - - - - - - - - - - - - - 
134 | void listDates() {
135 |   movesDates = new int[0];
136 |   for (int i=0; i<checkbox.getArrayValue().length; i++) {
137 |     if (checkbox.getArrayValue(i) != 0) {
138 |       if (d1.getValue() <= 9) {
139 |         month = "0" + str(int(d1.getValue()));
140 |       } 
141 |       else {
142 |         month = str(int(d1.getValue()));
143 |       }
144 |       if (i < 9) {
145 |         day = "0" + str(i+1);
146 |       } 
147 |       else {
148 |         day = str(i+1);
149 |       }
150 |       year = str(int(d2.getValue()));
151 |       date = year + month + day;
152 |       movesDates = append(movesDates, int(date));
153 |     }
154 |   }
155 |   println("- - - - - - - - - - - - - - -");
156 |   makeMoves();
157 | }
158 | 
159 | 
160 | // Add Elements as necessary to Moves hashmap
161 | // elements in hashmap that shouldn't be shown won't be called in display function
162 | // - - - - - - - - - - - - - - - - - - - - - - - 
163 | void makeMoves() {
164 |   for (int i=0; i<movesDates.length; i++) {
165 |     if ( moves.containsKey(str(movesDates[i])) ) {
166 |       //            println("Object key found: " + (movesDates[i]) +  " do nothing");
167 |     } 
168 |     else {
169 |       //            println("Object key not found: " + (movesDates[i]) +  " add to hashmap");
170 |       moves.put( str(movesDates[i]), new Move(str(movesDates[i])) );
171 |     }
172 |   }
173 | 
174 |   for (String k : moves.keySet()) {
175 |     moves.get(k).mapPaths();
176 |   }
177 | }
178 | 
179 | 
180 | // Format Minutes into Hour:Minute:Second Format for Time Scrubber 
181 | // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
182 | void timeLabel() {
183 |   String TimeOfDay_hour = str(floor(TimeOfDay/3600));
184 |   String TimeOfDay_min = str(floor((TimeOfDay-int(TimeOfDay_hour)*3600)/60));
185 |   String TimeOfDay_sec = str(TimeOfDay-int(TimeOfDay_hour)*3600-int(TimeOfDay_min)*60);
186 | 
187 |   if (TimeOfDay_hour.length() == 1) {
188 |     TimeOfDay_hour = "0" + TimeOfDay_hour;
189 |   } else if (TimeOfDay_min.length() == 1) {
190 |     TimeOfDay_min = "0" + TimeOfDay_min;
191 |   } else if (TimeOfDay_sec.length() == 1) {
192 |     TimeOfDay_sec = "0" + TimeOfDay_sec;
193 |   }
194 | 
195 | //  println(TimeOfDay_hour + ":" + TimeOfDay_min + ":" + TimeOfDay_sec);
196 |   TimeString = TimeOfDay_hour + ":" + TimeOfDay_min + ":" + TimeOfDay_sec + " UTC" + " " + tzOffsetLabel;
197 | 
198 |   cp5.getController("TimeOfDay").getValueLabel().setText(TimeString);
199 | }
200 | 
201 | 
202 | 
203 | 


--------------------------------------------------------------------------------
/Move.pde:
--------------------------------------------------------------------------------
  1 | 
  2 | // - - - - - - - - - - - - - - - - - - - - - - - 
  3 | // MOVE OBJECT
  4 | // - - - - - - - - - - - - - - - - - - - - - - -  
  5 | 
  6 | class Move { 
  7 |   String jsonDate;
  8 |   String place_name[] = new String[0];
  9 |   float place_long[] = new float[0];
 10 |   float place_lat[] = new float[0];
 11 |   int place_time[] = new int[0];
 12 |   float path_long[] = new float[0];
 13 |   float path_lat[] = new float[0];
 14 |   int path_time[] = new int[0];
 15 |   float loc_x[];
 16 |   float loc_y[];
 17 |   float place_loc_x, place_loc_y, lat_delta, long_delta, dimensionDelta;
 18 |   String path_type[] = new String[0];
 19 |   String[] dateTime = new String[1];
 20 |   String[] PlaceDateTime = new String[1];
 21 |   int hours, mins, secs;
 22 |   int time_offset;
 23 |   int date_offset;
 24 |   String path_date;
 25 |   String place_date;
 26 |   float space_long, space_lat;
 27 | 
 28 |   Move(String jsonDate_) {
 29 |     jsonDate = jsonDate_;
 30 |     jsonFetch(jsonDate);
 31 |     // Parse JSON
 32 |     JSONArray moves = loadJSONArray(jsonDate + ".json");
 33 |     for (int i = 0; i < moves.size(); i++) {
 34 |       JSONObject day = moves.getJSONObject(0);
 35 |       //      println("Date: " + day.getString("date"));
 36 |       JSONArray segments = day.getJSONArray("segments");
 37 |       //      println(day.getString("date") + ": " + segments.size() + " SEGMENTS");
 38 |       for (int j = 0; j < segments.size(); j++) {
 39 |         //        println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
 40 |         //        println("Segment Number: " + j);
 41 |         JSONObject segment = segments.getJSONObject(j);
 42 |         //        println("Type: " + segment.getString("type"));
 43 |         //        println("Start Time: " + segment.getString("startTime"));
 44 |         //        println("End Time: " + segment.getString("endTime"));
 45 |         try {
 46 |           JSONArray activities = segment.getJSONArray("activities");
 47 |           for (int k = 0; k < activities.size(); k++) {
 48 |             JSONObject activity = activities.getJSONObject(k);
 49 |             //            println("Activity: " + activity.getString("activity"));
 50 |             //            println("Start Time: " + activity.getString("startTime"));
 51 |             //            println("End Time: " + activity.getString("endTime"));
 52 |             //            println("Duration: " + activity.getInt("duration"));
 53 |             if (activity.getString("activity").equals("wlk") || activity.getString("activity").equals("run")) {
 54 |               //              println("Distance: " + activity.getInt("distance"));
 55 |               //              println("Steps: " + activity.getInt("steps"));
 56 |             }
 57 |             JSONArray path = activity.getJSONArray("trackPoints");
 58 |             for (int l = 0; l < path.size(); l++) {
 59 |               JSONObject point = path.getJSONObject(l);
 60 |               //              println("- Lat: " + point.getFloat("lat"));
 61 |               //              println("- Long: " + point.getFloat("lon"));
 62 |               //              println("- Time: " + point.getString("time"));
 63 |               // build path array
 64 |               path_type = append(path_type, activity.getString("activity"));
 65 |               path_long = append(path_long, point.getFloat("lon"));
 66 |               path_lat = append(path_lat, point.getFloat("lat"));
 67 |               dateTime = split(point.getString("time"), 'T');
 68 |               path_date = dateTime[0];
 69 |               date_offset = ((int(path_date) - int(jsonDate)) < 0) ? -86400 : ((int(path_date) - int(jsonDate)) > 0) ? 86400 : 0;
 70 |               dateTime = split(dateTime[1], 'Z');
 71 |               path_time = append(path_time, int(dateTime[0]));
 72 |               // convert path_time to minutes
 73 |               hours = floor(path_time[path_time.length-1]*0.0001);
 74 |               mins = floor((path_time[path_time.length-1] - hours*10000)*0.01);
 75 |               secs = path_time[path_time.length-1] - hours*10000 - mins*100;
 76 |               time_offset = hours*3600 + mins*60 + secs + tzOffset;
 77 |               path_time[path_time.length-1] = (time_offset > 0) ? time_offset : time_offset + date_offset;
 78 |             }
 79 |           }
 80 |         }
 81 |         catch (Exception e) {
 82 |           //          println("error "+e);
 83 |         }
 84 |         try {
 85 |           JSONObject place = segment.getJSONObject("place");
 86 |           //          println("Start Time: " + segment.getString("startTime"));
 87 |           //          println("* " + place.getString("name"));
 88 |           //          println("* Type: " + place.getString("type"));
 89 |           //          println("* ID: " + place.getInt("id"));
 90 |           JSONObject location = place.getJSONObject("location");
 91 |           //          println("* Lat: " + location.getFloat("lat"));
 92 |           //          println("* Long: " + location.getFloat("lon"));
 93 |           // build unique places array
 94 |           place_name = append(place_name, place.getString("name"));
 95 |           place_long = append(place_long, location.getFloat("lon"));
 96 |           place_lat = append(place_lat, location.getFloat("lat"));
 97 |           // compute place_time in minutes
 98 |           PlaceDateTime = split(segment.getString("startTime"), 'T');
 99 |           place_date = PlaceDateTime[0];
100 |           date_offset = ((int(place_date) - int(jsonDate)) < 0) ? -86400 : ((int(place_date) - int(jsonDate)) > 0) ? 86400 : 0;
101 |           PlaceDateTime = split(PlaceDateTime[1], 'Z');
102 |           place_time = append(place_time, int(PlaceDateTime[0]));
103 |           // convert path_time to minutes
104 |           hours = floor(place_time[place_time.length-1]*0.0001);
105 |           mins = floor((place_time[place_time.length-1] - hours*10000)*0.01);
106 |           secs = place_time[place_time.length-1] - hours*10000 - mins*100;
107 |           time_offset = hours*3600 + mins*60 + secs + tzOffset;
108 |           place_time[place_time.length-1] = (time_offset > 0) ? time_offset : time_offset + date_offset;
109 |         }
110 |         catch (Exception e) {
111 |           //          println("error "+e);
112 |         }
113 |       }
114 |     }
115 |     
116 |     float min_path_lat = 90;
117 |     float min_path_long = 180;
118 | 
119 |     float min_place_lat = 90;
120 |     float min_place_long = 180;
121 | 
122 |     float max_path_lat = -90;
123 |     float max_path_long = -180;
124 |     
125 |     float max_place_lat = -90;
126 |     float max_place_long = -180;
127 |     
128 |     if (path_lat.length > 0 && path_long.length > 0) {
129 |       min_path_lat = min(path_lat);
130 |       max_path_lat = max(path_lat);
131 |       
132 |       min_path_long = min(path_long);
133 |       max_path_long = max(path_long);
134 |     }
135 |     
136 |     if (place_lat.length > 0 && place_long.length > 0) {
137 |       min_place_lat = min(place_lat);
138 |       max_place_lat = max(place_lat);
139 |       
140 |       min_place_long = min(place_long);
141 |       max_place_long = max(place_long);
142 |     }
143 | 
144 |     min_lats.set(jsonDate, min(min_path_lat, min_place_lat));
145 |     max_lats.set(jsonDate, max(max_path_lat, max_place_lat));
146 |     
147 |     min_longs.set(jsonDate, min(min_path_long, min_place_long));
148 |     max_longs.set(jsonDate, max(max_path_long, max_place_long));
149 |   }
150 | 
151 |   void display() {
152 |     // Draw Paths
153 |     noFill();
154 |     for (int i=0; i<path_long.length; i++) {
155 |       if (i > 0  && path_time[i] < TimeOfDay && path_time[i] > 0) {
156 |         if (path_type[i].equals("cyc") && cycle.booleanValue()) {
157 |           stroke(0, 255, 255, 100);
158 |           line(loc_x[i], loc_y[i], loc_x[i-1], loc_y[i-1]);
159 |         } 
160 |         else if (path_type[i].equals("run") && run.booleanValue()) {
161 |           stroke(255, 0, 255, 100);
162 |           line(loc_x[i], loc_y[i], loc_x[i-1], loc_y[i-1]);
163 |         }
164 |         else if (path_type[i].equals("wlk") && walk.booleanValue()) {
165 |           stroke(255, 255, 0, 100);
166 |           line(loc_x[i], loc_y[i], loc_x[i-1], loc_y[i-1]);
167 |         }
168 |         else if (path_type[i].equals("trp") && transportation.booleanValue()) {
169 |           stroke(255, 40);
170 |           line(loc_x[i], loc_y[i], loc_x[i-1], loc_y[i-1]);
171 |         }
172 |       }
173 |     }
174 |     // Draw Places
175 |     noStroke();
176 |     for (int i=0; i<place_long.length; i++) {
177 |       if (placesDrawn.hasKey(place_name[i])) {
178 |       } 
179 |       else if ( labels.booleanValue() && place_time[i] < TimeOfDay && place_time[i] > 0 ) {
180 |         place_loc_x = map(place_long[i], min_long, max_long, margin + space_long, canvasSize-margin - space_long);
181 |         place_loc_y = map(place_lat[i], max_lat, min_lat, top_margin + space_lat, canvasSize-margin - space_lat);
182 |         fill(255);
183 |         ellipse(place_loc_x, place_loc_y, placeSize, placeSize);
184 |         fill(255, 150);
185 |         textSize(9);
186 |         text(place_name[i], place_loc_x+placeSize, place_loc_y+3);
187 |         placesDrawn.set(place_name[i], "true");
188 |       }
189 |     }
190 |   }
191 | 
192 | 
193 |   void mapBounds() {
194 |     float max_lats_array[] = new float[0];
195 |     float min_lats_array[] = new float[0];
196 |     float max_longs_array[] = new float[0];
197 |     float min_longs_array[] = new float[0];
198 |     for (int i=0; i<movesDates.length; i++) {
199 |       try {
200 |         max_lats_array = append(max_lats_array, max_lats.get(str(movesDates[i])));
201 |         min_lats_array = append(min_lats_array, min_lats.get(str(movesDates[i])));
202 |         max_longs_array = append(max_longs_array, max_longs.get(str(movesDates[i])));
203 |         min_longs_array = append(min_longs_array, min_longs.get(str(movesDates[i])));
204 |       }
205 |       catch (Exception e) {
206 |       }
207 |     }
208 |     max_lat = max(max_lats_array);
209 |     min_lat = min(min_lats_array);
210 |     max_long = max(max_longs_array);
211 |     min_long = min(min_longs_array);
212 |     //    println(max_lat + " / " + min_lat + " / " + max_long + " / " + min_long);
213 |   }
214 | 
215 | 
216 |   void mapPaths() {
217 |     loc_x = new float[path_long.length];
218 |     loc_y = new float[path_lat.length];
219 |     computeSpace();
220 |     for (int i=0; i<path_long.length; i++) {
221 |       loc_x[i] = map(path_long[i], min_long, max_long, margin + space_long, canvasSize-margin - space_long);
222 |       loc_y[i] = map(path_lat[i], max_lat, min_lat, top_margin + space_lat, canvasSize-margin - space_lat);
223 |     }
224 |   }
225 | 
226 |   void computeSpace() {
227 |     // Compute relation coefficient between longitudes and latitudes
228 |     float ratio = (float) Math.sin((90.0 - ((max_lat + min_lat) / 2.0)) / 180.0 * Math.PI);
229 |     float coef = ratio / (float) (canvasSize - 2 * margin) * (float) (canvasSize - margin - top_margin);
230 |     long_delta = abs(max_long-min_long) * coef;
231 |     lat_delta = abs(max_lat-min_lat);
232 |     if (long_delta > lat_delta) {
233 |       space_long = 0;
234 |       space_lat = (canvasSize - margin - top_margin) * (1 - lat_delta / long_delta) / 2;
235 |     }
236 |     else {
237 |       space_lat = 0;
238 |       space_long = (canvasSize - 2 * margin) * (1 - long_delta / lat_delta) / 2;
239 |     }
240 |   }
241 | 
242 |   void jsonFetch(String fetchDate) {
243 |     String thisYear = str(year());
244 |     String thisMonth = str(month());
245 |     String thisDay = str(day());
246 |     if (int(thisMonth) <= 9) {
247 |       thisMonth = "0" + thisMonth;
248 |     }
249 |     if (int(thisDay) <= 9) {
250 |       thisDay = "0" + thisDay;
251 |     }
252 |     String thisDate = thisYear + thisMonth + thisDay;
253 |     File f = new File(dataPath( fetchDate + ".json" ));
254 |     if ( !f.exists() || fetchDate.equals(thisDate) ) { // Call API if data doesn't exist
255 |       try {
256 |         println("Querying… " + fetchDate);
257 |         apiCall = "https://api.moves-app.com/api/v1/user/storyline/daily/" + fetchDate + "?trackPoints=true&access_token=" + accessToken;
258 |         JSONArray result = loadJSONArray( apiCall );
259 |         if (result != null) { // unsure if this call works
260 |           saveJSONArray(result, dataPath(fetchDate + ".json"));
261 |         }
262 |       } 
263 |       catch (Exception e) {
264 |         println("No Data");
265 |       }
266 |     }
267 |   }
268 | }
269 | 


--------------------------------------------------------------------------------
/MovesMapper_1_0.pde:
--------------------------------------------------------------------------------
  1 | // - - - - - - - - - - - - - - - - - - - - - - - 
  2 | // MOVES MAPPER v1.0
  3 | // Nicholas Felton — September 3, 2013
  4 | // - - - - - - - - - - - - - - - - - - - - - - - 
  5 | 
  6 | 
  7 | // - - - - - - - - - - - - - - - - - - - - - - - 
  8 | // LIBRARIES
  9 | // - - - - - - - - - - - - - - - - - - - - - - - 
 10 | import controlP5.*;
 11 | import java.util.Map;
 12 | 
 13 | 
 14 | // - - - - - - - - - - - - - - - - - - - - - - - 
 15 | // GLOBAL VARIABLES
 16 | // - - - - - - - - - - - - - - - - - - - - - - - 
 17 | 
 18 | // General
 19 | int canvasSize = 800; // 550 minimum value
 20 | 
 21 | // Data
 22 | String date, year, month, day;
 23 | int[] movesDates;
 24 | String apiCall;
 25 | HashMap<String, Move> moves = new HashMap<String, Move>();
 26 | 
 27 | // Draw
 28 | int placeSize = 6;
 29 | FloatDict max_lats = new FloatDict();
 30 | FloatDict min_lats = new FloatDict();
 31 | FloatDict max_longs = new FloatDict();
 32 | FloatDict min_longs = new FloatDict();
 33 | float max_lat, min_lat, max_long, min_long;
 34 | float mapOffset;
 35 | StringDict placesDrawn = new StringDict();
 36 | int margin = 30;
 37 | int top_margin = margin + 50;
 38 | 
 39 | // GUI
 40 | ControlP5 cp5;
 41 | DropdownList d1, d2;
 42 | CheckBox checkbox;
 43 | Button labels, walk, run, cycle, transportation;
 44 | String[] monthNames = {
 45 |   "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
 46 | };
 47 | String[] monthDaysStandard = {
 48 |   "31", "28", "31", "30", "31", "30", "31", "31", "30", "31", "30", "31"
 49 | };
 50 | String[] monthDaysLeap = {
 51 |   "31", "29", "31", "30", "31", "30", "31", "31", "30", "31", "30", "31"
 52 | };
 53 | int TimeOfDay;
 54 | String TimeString = "00:00:00";
 55 | 
 56 | 
 57 | // - - - - - - - - - - - - - - - - - - - - - - - 
 58 | // SETUP
 59 | // - - - - - - - - - - - - - - - - - - - - - - - 
 60 | void setup() {
 61 |   size(canvasSize, canvasSize+150);
 62 |   smooth();
 63 |   hint(ENABLE_STROKE_PURE);
 64 |   cp5 = new ControlP5(this);
 65 | 
 66 |   // Instantiate Date GUI
 67 |   GUIcheckbox("checkbox", 150, height-135);
 68 |   GUIdropdownD1("d1-month", 20, height-95, "MONTH");
 69 |   GUIdropdownD2("d2-year", 20, height-120, "YEAR");
 70 | 
 71 |   // Populate Date GUI
 72 |   GUImonth(year(), month(), month());
 73 |   GUIyear(year());
 74 |   GUIday(year(), month(), day());
 75 | 
 76 |   // Additional GUI
 77 |   labels = cp5.addButton("labels")
 78 |     .setPosition(width-120, height-135)
 79 |       .setSize(100, 20)
 80 |         .setHeight(15)
 81 |           .setColorForeground(color(190))
 82 |             .setColorBackground(color(60))
 83 |               .setColorActive(color(255, 128))
 84 |                 .setSwitch(true)
 85 |                   .setOn()
 86 |                   ;
 87 | 
 88 |   walk = cp5.addButton("walk")
 89 |     .setPosition(width-120, height-110)
 90 |       .setSize(100, 20)
 91 |         .setHeight(15)
 92 |           .setColorForeground(color(45))
 93 |             .setColorBackground(color(60))
 94 |               .setColorActive(color(255, 128))
 95 |                 .setSwitch(true)
 96 |                   .setOn()
 97 |                   ;
 98 | 
 99 |   run = cp5.addButton("run")
100 |     .setPosition(width-120, height-85)
101 |       .setSize(100, 20)
102 |         .setHeight(15)
103 |           .setColorForeground(color(190))
104 |             .setColorBackground(color(60))
105 |               .setColorActive(color(255, 128))
106 |                 .setSwitch(true)
107 |                   .setOn()
108 |                   ;
109 | 
110 |   cycle = cp5.addButton("cycle")
111 |     .setPosition(width-120, height-60)
112 |       .setSize(100, 20)
113 |         .setHeight(15)
114 |           .setColorForeground(color(190))
115 |             .setColorBackground(color(60))
116 |               .setColorActive(color(255, 128))
117 |                 .setSwitch(true)
118 |                   .setOn()
119 |                   ;
120 | 
121 |   transportation = cp5.addButton("transportation")
122 |     .setPosition(width-120, height-35)
123 |       .setSize(100, 20)
124 |         .setHeight(15)
125 |           .setColorForeground(color(190))
126 |             .setColorBackground(color(60))
127 |               .setColorActive(color(255, 128))
128 |                 .setSwitch(true)
129 |                   .setOn()
130 |                   ;
131 | 
132 |   // add a vertical slider
133 |   cp5.addSlider("TimeOfDay")
134 |     .setPosition(margin, margin)
135 |       .setSize(width-(2*margin), 10)
136 |         .setRange(0, 86400)
137 |           .setValue(86400)
138 |             .setColorForeground(color(190))
139 |               .setColorBackground(color(60))
140 |                 .setColorActive(color(255, 128))
141 |                   ;
142 | 
143 |   // reposition the Label for controller 'slider'
144 |   cp5.getController("TimeOfDay").getValueLabel().setText(TimeString).align(ControlP5.LEFT, ControlP5.BOTTOM_OUTSIDE).setPaddingX(0);
145 |   cp5.getController("TimeOfDay").getCaptionLabel().align(ControlP5.RIGHT, ControlP5.BOTTOM_OUTSIDE).setPaddingX(0);
146 | }
147 | 
148 | 
149 | // - - - - - - - - - - - - - - - - - - - - - - - 
150 | // DRAW LOOP
151 | // - - - - - - - - - - - - - - - - - - - - - - - 
152 | 
153 | void draw() {
154 |   frame.setTitle(int(frameRate) + " fps / " + frameCount + " frames");
155 |   background(40);
156 |   placesDrawn.clear();
157 |   timeLabel();
158 | 
159 |   // Draw Moves
160 |   for (int i=0; i<movesDates.length; i++) {      
161 |     try {
162 |       moves.get(str(movesDates[i])).display();
163 |     }
164 |     catch (Exception e) {
165 |     }
166 |   }
167 | }
168 | 


--------------------------------------------------------------------------------
/Notes.pde:
--------------------------------------------------------------------------------
 1 | 
 2 | // SETUP
 3 | // 1. Open Moves app and make sure that your activity is up to date.
 4 | // 2. In the settings, go to the Apps section and click the add a PIN button.
 5 | // 3. Visit http://shielded-sierra-8807.herokuapp.com to get the PIN and enter this in the app.
 6 | // 4. Once you've given the app permission to access your data, the web page will refresh and dislay your access token.
 7 | // 5. Set the accessToken string on line 25 in the Processing sketch.
 8 | // 6. Run the sketch.
 9 | 
10 | 
11 | // REQUIREMENTS
12 | // Please make sure that you are using Processing 2.0 and have installed the ControlP5 GUI 2.0 library for this sketch to run properly.
13 | // Processing 2.0 https://processing.org/download/
14 | // ControlP5 2.0 Library http://www.sojamo.de/libraries/controlP5/
15 | 
16 | 
17 | // CAVEATS
18 | // If an incomplete day is cached and it's no longer the current day, the local file will not be refreshed. 
19 | // Delete the file to force MovesMapper to query for a complete file.
20 | // If you have not synced the app before running, it may fetch a malformed response that will cause the sketch to crash. If this happens, sync the app, delete the JSON data file and re-run the sketch.
21 | 
22 | 
23 | // DEVELOPMENT CHANGELOG
24 | // draw paths as lines
25 | // make each day an object
26 | // separate drawing and parsing into separate blocks
27 | // scale viewport to fit data
28 | // only draw markers & labels 1x
29 | // color walk, cycle and run lines appropriately
30 | // poll API directly for data
31 | // look to local data before polling API
32 | // GUI: months / days / years
33 | // Convert caching logic into a function
34 | // Don't rebuild Moves data structure every time a day is added (switch to hashmap)
35 | // prevent out of bounds error when querying for days without data
36 | // move map() computation out of draw() loop
37 | // GUI: labels
38 | // GUI: transportation type
39 | // reset map scaling to fit data
40 | // time of day slider for lines
41 | // switch slider to minutes
42 | // GUI: Start in ON state
43 | // only show places after correct time
44 | // implement time zone support (merged from https://github.com/yonoleo/MMapper)
45 | 
46 | 
47 | // HIGH PRI
48 | // preserve aspect ratio of map
49 | 
50 | 
51 | // MID PRI
52 | // steps / miles / etc display
53 | // move labeling map function out of draw loop
54 | // Requery the current day on launch?
55 | // GUI: location blobs
56 | // GUI: PDF export
57 | // GUI: All On / All Off
58 | // improve error handling of requests for days without data
59 | 
60 | 
61 | // LOW PRI
62 | // add basemap (use symbols?)
63 | // add ability to pan and zoom map
64 | 
65 | 
66 | // FIRST ACCOMPLISHMENTS
67 | // first time using dictionary structures like StringDict and HashMap
68 | // first time implementing live queries of an API
69 | // first time using JSON objects
70 | 
71 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | MovesMapper
 2 | ===========
 3 | 
 4 | A processing sketch for rendering location and activity data from the Moves iPhone or Android app.
 5 | 
 6 | 
 7 | ## Requirements
 8 | Make sure that you are using Processing 2.0 and have installed the ControlP5 GUI 2.0 library for this sketch to run properly.
 9 | * Processing 2.0 `https://processing.org/download/`
10 | * ControlP5 2.0 Library `http://www.sojamo.de/libraries/controlP5/`
11 | 
12 | 
13 | ## Setup
14 | 1. Open Moves app and make sure that your activity is up to date.
15 | 1. In the settings, go to the Apps section and click the add a PIN button.
16 | 1. Visit http://shielded-sierra-8807.herokuapp.com to get the PIN and enter this in the app.
17 | 1. Once you've given the app permission to access your data, the web page will refresh and display your access token.
18 | 1. Set the accessToken string in config.pde.
19 | 1. Run the sketch.
20 | 
21 | 
22 | ## Caveats
23 | * If an incomplete day is cached and it's no longer the current day, the local file will not be refreshed. Delete the file to force MovesMapper to query for a complete file.
24 | * If you have not synced the app before running, it may fetch a malformed response that will cause the sketch to crash. If this happens, sync the app, delete the JSON data file and re-run the sketch.
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/SampleScreen_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/feltron/MMapper/c887e98021b2a89bb5ab5ef2b8a532e208fd6d54/SampleScreen_1.png


--------------------------------------------------------------------------------
/SampleScreen_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/feltron/MMapper/c887e98021b2a89bb5ab5ef2b8a532e208fd6d54/SampleScreen_2.png


--------------------------------------------------------------------------------
/SampleScreen_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/feltron/MMapper/c887e98021b2a89bb5ab5ef2b8a532e208fd6d54/SampleScreen_3.png


--------------------------------------------------------------------------------