EarthquakeCityMap.java

package module6;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

import de.fhpotsdam.unfolding.UnfoldingMap;
import de.fhpotsdam.unfolding.data.Feature;
import de.fhpotsdam.unfolding.data.GeoJSONReader;
import de.fhpotsdam.unfolding.data.PointFeature;
import de.fhpotsdam.unfolding.geo.Location;
import de.fhpotsdam.unfolding.marker.AbstractShapeMarker;
import de.fhpotsdam.unfolding.marker.Marker;
import de.fhpotsdam.unfolding.marker.MultiMarker;
import de.fhpotsdam.unfolding.providers.Google;
import de.fhpotsdam.unfolding.providers.MBTilesMapProvider;
import de.fhpotsdam.unfolding.providers.Microsoft;
import de.fhpotsdam.unfolding.utils.MapUtils;
import parsing.ParseFeed;
import processing.core.PApplet;

/** EarthquakeCityMap
 * An application with an interactive map displaying earthquake data.
 * Author: UC San Diego Intermediate Software Development MOOC team
 * @author Your name here
 * Date: July 17, 2015
 * */
public class EarthquakeCityMap extends PApplet {
	
	// We will use member variables, instead of local variables, to store the data
	// that the setUp and draw methods will need to access (as well as other methods)
	// You will use many of these variables, but the only one you should need to add
	// code to modify is countryQuakes, where you will store the number of earthquakes
	// per country.
	
	// It's to get rid of eclipse warnings
	private static final long serialVersionUID = 1L;

	// IF YOU ARE WORKING OFFILINE, change the value of this variable to true
	private static final boolean offline = false;
	
	/** This is where to find the local tiles, for working without an Internet connection */
	public static String mbTilesString = "blankLight-1-3.mbtiles";
	
	

	//feed with magnitude 2.5+ Earthquakes
	private String earthquakesURL = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_week.atom";
	
	// The files containing city names and info and country names and info
	private String cityFile = "city-data.json";
	private String countryFile = "countries.geo.json";
	
	// The map
	private UnfoldingMap map;
	
	// my variables
	private int triangleRedCol = 150, triangleGreenCol = 30, triangleBlueCol = 30;
	Random rand = new Random();
	double triangleArea;
	private int shallRed = 255, shallGreen = 255, shallBlue = 0;
	private int intRed = 0, intGreen = 0, intBlue = 255;
	private int deepRed = 255, deepGreen = 0, deepBlue = 0;
	private int zoomLevel = 0;
	private float lat, lon;
	private boolean locationEntered = false;
	Scanner sc = new Scanner(System.in);
	//-------------------------------------
	
	// Markers for each city
	private List<Marker> cityMarkers;
	// Markers for each earthquake
	private List<Marker> quakeMarkers;

	// A List of country markers
	private List<Marker> countryMarkers;
	
	// NEW IN MODULE 5
	private CommonMarker lastSelected;
	private CommonMarker lastClicked;
	
	public void setup() {		
		// (1) Initializing canvas and map tiles
		size(1100, 700, OPENGL);
		if (offline) {
		    map = new UnfoldingMap(this, 200, 50, 650, 600, new MBTilesMapProvider(mbTilesString));
		    earthquakesURL = "2.5_week.atom";  // The same feed, but saved August 7, 2015
		}
		else {
			map = new UnfoldingMap(this, 180, 50, 900, 600, new Microsoft.HybridProvider());
			// TO TEST WITH A LOCAL FILE :
		    //earthquakesURL = "2.5_week.atom";
		}
		
		MapUtils.createDefaultEventDispatcher(this, map);
		
		// FOR TESTING: Set earthquakesURL to be one of the testing files by uncommenting
		// one of the lines below.  This will work whether you are online or offline
		//earthquakesURL = "test1.atom";
//		earthquakesURL = "test2.atom";
		
		earthquakesURL = "quiz2.atom";
		
		
		// (2) Reading in earthquake data and geometric properties
	    //     STEP 1: load country features and markers
		List<Feature> countries = GeoJSONReader.loadData(this, countryFile);
		countryMarkers = MapUtils.createSimpleMarkers(countries);
		
		//     STEP 2: read in city data
		List<Feature> cities = GeoJSONReader.loadData(this, cityFile);
		cityMarkers = new ArrayList<Marker>();
		for(Feature city : cities) {
		  cityMarkers.add(new CityMarker(city));
		}
	    
		//     STEP 3: read in earthquake RSS feed
	    List<PointFeature> earthquakes = ParseFeed.parseEarthquake(this, earthquakesURL);
	    quakeMarkers = new ArrayList<Marker>();
	    
	    for(PointFeature feature : earthquakes) {
		  //check if LandQuake
		  if(isLand(feature)) {
		    quakeMarkers.add(new LandQuakeMarker(feature));
		  }
		  // OceanQuakes
		  else {
		    quakeMarkers.add(new OceanQuakeMarker(feature));
		  }
	    }

	    // could be used for debugging
	    printQuakes();
	 		
	    // (3) Add markers to map
	    //     NOTE: Country markers are not added to the map.  They are used
	    //           for their geometric properties
	    map.addMarkers(quakeMarkers);
	    map.addMarkers(cityMarkers);
	    
	    sortAndPrint(20);
	    
		triangleArea = calculateArea(60,95,55, 105, 65, 105);
	    
	    
	}  // End setup
	
	
	public void draw() {
		background(0,0,0);
		map.draw();
		addKey();
		
	}
	
	public void keyPressed() {
		if(locationEntered == false || key == 'c') {
			System.out.println("Enter latitude : ");
			lat = sc.nextFloat();
			System.out.println("Enter longitude : ");
			lon = sc.nextFloat();
			locationEntered = true;
			zoomLevel += 2;
			zoomIt();
		}
		if(key == 'z') {
			if(zoomLevel <= 10) {
				zoomLevel += 1;
				zoomIt();
			}
		}
		else if(key == 'x') {
			if(zoomLevel >= 1) {
				System.out.println(zoomLevel);
				zoomLevel -= 1;
				zoomIt();
			}
		}
	}
	
	private void zoomIt() {
		map.zoomAndPanTo(zoomLevel, new Location(lat, lon));
	}
	
	private void sortAndPrint(int numToPrint) {
		Object[] quakes = quakeMarkers.toArray();
		int len = quakes.length, j, i;
		EarthquakeMarker tmp;
		for(i = 1; i<len; i++) {
			j = i;
			while(j > 0) {
				if(((EarthquakeMarker)quakes[j]).compareTo(((EarthquakeMarker)quakes[j-1])) == 1) {
					tmp = ((EarthquakeMarker)quakes[j-1]);
					quakes[j-1] = ((EarthquakeMarker)quakes[j]);
					quakes[j] = tmp;
					j--;
				}
				else {
					break;
				}
			}
		}
		i = 0;
		System.out.println("Printing out quakes");
		while((i < len) && (i < numToPrint)) {
			System.out.println(quakes[i]);
			i++;
		}
	}
	
	/** Event handler that gets called automatically when the 
	 * mouse moves.
	 */
	@Override
	public void mouseMoved()
	{
		// clear the last selection
		if (lastSelected != null) {
			lastSelected.setSelected(false);
			lastSelected = null;
		}
		selectMarkerIfHover(quakeMarkers);
		selectMarkerIfHover(cityMarkers);
		//loop();
	}
	
	// If there is a marker selected 
	private void selectMarkerIfHover(List<Marker> markers)
	{
		// Abort if there's already a marker selected
		if (lastSelected != null) {
			return;
		}
		
		for (Marker m : markers) 
		{
			CommonMarker marker = (CommonMarker)m;
			if (marker.isInside(map,  mouseX, mouseY)) {
				lastSelected = marker;
				marker.setSelected(true);
				return;
			}
		}
	}
	
	/** The event handler for mouse clicks
	 * It will display an earthquake and its threat circle of cities
	 * Or if a city is clicked, it will display all the earthquakes 
	 * where the city is in the threat circle
	 */
	@Override
	public void mouseClicked()
	{
		if (lastClicked != null) {
			unhideMarkers();
			lastClicked = null;
		}
		else if (lastClicked == null) 
		{
			checkEarthquakesForClick();
			if (lastClicked == null) {
				checkCitiesForClick();
			}
		}
		
		changeColorForIcon();
	}
	
	private void changeColorForIcon() {
		mouseInsideTriangle();
		mouseInsideShallowCircle();
		mouseInsideInterCircle();
		mouseInsideDeepCircle();
	}
	// helper method to draw key in GUI
	
	private boolean mouseInsideCircle(int x1, int y1) {
		double radiusSquare = 12 * 12;
		if(((double)((x1 - mouseX) * (x1 - mouseX) + (y1 - mouseY) * (y1 - mouseY))) <= radiusSquare) {
			return true;
		}
		else
			return false;		
	}
	
	private void mouseInsideShallowCircle() {
		if(mouseInsideCircle(60, 190)) {
			shallRed = rand.nextInt(255);
			shallGreen = rand.nextInt(255);
			shallBlue = rand.nextInt(255);
			EarthquakeMarker.updateShallowColor(shallRed, shallGreen, shallBlue);
		}
	}
	
	private void mouseInsideInterCircle() {
		if(mouseInsideCircle(60, 210)) {
			intRed = rand.nextInt(255);
			intGreen = rand.nextInt(255);
			intBlue = rand.nextInt(255);
			EarthquakeMarker.updateIntermediateColor(intRed, intGreen, intBlue);
		}
	}
	
	private void mouseInsideDeepCircle() {
		if(mouseInsideCircle(60, 230)) {
			deepRed = rand.nextInt(255);
			deepGreen = rand.nextInt(255);
			deepBlue = rand.nextInt(255);
			EarthquakeMarker.updateDeepColor(deepRed, deepGreen, deepBlue);
		}
	}
	
	private void mouseInsideTriangle() {
		double tArea1 = calculateArea(mouseX, mouseY, 55, 105, 65, 105);
		double tArea2 = calculateArea(60, 95 ,mouseX, mouseY, 65, 105);
		double tArea3 = calculateArea(60, 95, 55, 105, mouseX, mouseY);
		
		if((tArea1 + tArea2 + tArea3) == triangleArea) {
			triangleRedCol = rand.nextInt(255);
			triangleBlueCol = rand.nextInt(255);
			triangleGreenCol = rand.nextInt(255);
			CityMarker.setColor(triangleRedCol, triangleBlueCol, triangleGreenCol);
		}
	}
	
	private static double calculateArea(int x1, int y1, int x2, int y2, int x3, int y3) {
		int a1 = x1 * (y2 - y3);
		int a2 = x2 * (y3 - y1);
		int a3 = x3 * (y1 - y2);
		
		return Math.abs(((double)(a1 + a2 + a3))/2);
		
	}

	
	// Helper method that will check if a city marker was clicked on
	// and respond appropriately
	private void checkCitiesForClick()
	{
		if (lastClicked != null) return;
		// Loop over the earthquake markers to see if one of them is selected
		for (Marker marker : cityMarkers) {
			if (!marker.isHidden() && marker.isInside(map, mouseX, mouseY)) {
				lastClicked = (CommonMarker)marker;
				// Hide all the other earthquakes and hide
				for (Marker mhide : cityMarkers) {
					if (mhide != lastClicked) {
						mhide.setHidden(true);
					}
				}
				for (Marker mhide : quakeMarkers) {
					EarthquakeMarker quakeMarker = (EarthquakeMarker)mhide;
					if (quakeMarker.getDistanceTo(marker.getLocation()) 
							> quakeMarker.threatCircle()) {
						quakeMarker.setHidden(true);
					}
				}
				return;
			}
		}		
	}
	
	// Helper method that will check if an earthquake marker was clicked on
	// and respond appropriately
	private void checkEarthquakesForClick()
	{
		if (lastClicked != null) return;
		// Loop over the earthquake markers to see if one of them is selected
		for (Marker m : quakeMarkers) {
			EarthquakeMarker marker = (EarthquakeMarker)m;
			if (!marker.isHidden() && marker.isInside(map, mouseX, mouseY)) {
				lastClicked = marker;
				// Hide all the other earthquakes and hide
				for (Marker mhide : quakeMarkers) {
					if (mhide != lastClicked) {
						mhide.setHidden(true);
					}
				}
				for (Marker mhide : cityMarkers) {
					if (mhide.getDistanceTo(marker.getLocation()) 
							> marker.threatCircle()) {
						mhide.setHidden(true);
					}
				}
				return;
			}
		}
	}
	
	// loop over and unhide all markers
	private void unhideMarkers() {
		for(Marker marker : quakeMarkers) {
			marker.setHidden(false);
		}
			
		for(Marker marker : cityMarkers) {
			marker.setHidden(false);
		}
	}

	private void addKey() {	
		// Remember you can use Processing's graphics methods here
		fill(255, 250, 240);
		
		int xbase = 25;
		int ybase = 50;
		
		rect(xbase, ybase, 150, 250);
		
		fill(0);
		textAlign(LEFT, CENTER);
		textSize(12);
		text("Earthquake Key", xbase+25, ybase+25);
		
		fill(triangleRedCol, triangleGreenCol, triangleBlueCol);
		int tri_xbase = xbase + 35;
		int tri_ybase = ybase + 50;
		triangle(tri_xbase, tri_ybase-CityMarker.TRI_SIZE, tri_xbase-CityMarker.TRI_SIZE, 
				tri_ybase+CityMarker.TRI_SIZE, tri_xbase+CityMarker.TRI_SIZE, 
				tri_ybase+CityMarker.TRI_SIZE);

		fill(0, 0, 0);
		textAlign(LEFT, CENTER);
		text("City Marker", tri_xbase + 15, tri_ybase);
		
		text("Land Quake", xbase+50, ybase+70);
		text("Ocean Quake", xbase+50, ybase+90);
		text("Size ~ Magnitude", xbase+25, ybase+110);
		
		fill(255, 255, 255);
		ellipse(xbase+35, 
				ybase+70, 
				10, 
				10);
		rect(xbase+35-5, ybase+90-5, 10, 10);
		
		fill(color(shallRed, shallGreen, shallBlue));
		ellipse(xbase+35, ybase+140, 12, 12);
		fill(color(intRed, intGreen, intBlue));
		ellipse(xbase+35, ybase+160, 12, 12);
		fill(color(deepRed, deepGreen, deepBlue));
		ellipse(xbase+35, ybase+180, 12, 12);
		
		textAlign(LEFT, CENTER);
		fill(0, 0, 0);
		text("Shallow", xbase+50, ybase+140);
		text("Intermediate", xbase+50, ybase+160);
		text("Deep", xbase+50, ybase+180);

		text("Past hour", xbase+50, ybase+200);
		
		fill(255, 255, 255);
		int centerx = xbase+35;
		int centery = ybase+200;
		ellipse(centerx, centery, 12, 12);

		strokeWeight(2);
		line(centerx-8, centery-8, centerx+8, centery+8);
		line(centerx-8, centery+8, centerx+8, centery-8);
		
		
	}

	
	
	// Checks whether this quake occurred on land.  If it did, it sets the 
	// "country" property of its PointFeature to the country where it occurred
	// and returns true.  Notice that the helper method isInCountry will
	// set this "country" property already.  Otherwise it returns false.
	private boolean isLand(PointFeature earthquake) {
		
		// loop over all countries to check if location is in any of them
		// If it is, add 1 to the entry in countryQuakes corresponding to this country.
		for (Marker country : countryMarkers) {
			if (isInCountry(earthquake, country)) {
				return true;
			}
		}
		
		// not inside any country
		return false;
	}
	
	// prints countries with number of earthquakes
	// You will want to loop through the country markers or country features
	// (either will work) and then for each country, loop through
	// the quakes to count how many occurred in that country.
	// Recall that the country markers have a "name" property, 
	// And LandQuakeMarkers have a "country" property set.
	private void printQuakes() {
		int totalWaterQuakes = quakeMarkers.size();
		for (Marker country : countryMarkers) {
			String countryName = country.getStringProperty("name");
			int numQuakes = 0;
			for (Marker marker : quakeMarkers)
			{
				EarthquakeMarker eqMarker = (EarthquakeMarker)marker;
				if (eqMarker.isOnLand()) {
					if (countryName.equals(eqMarker.getStringProperty("country"))) {
						numQuakes++;
					}
				}
			}
			if (numQuakes > 0) {
				totalWaterQuakes -= numQuakes;
				System.out.println(countryName + ": " + numQuakes);
			}
		}
		System.out.println("OCEAN QUAKES: " + totalWaterQuakes);
	}
	
	
	
	// helper method to test whether a given earthquake is in a given country
	// This will also add the country property to the properties of the earthquake feature if 
	// it's in one of the countries.
	// You should not have to modify this code
	private boolean isInCountry(PointFeature earthquake, Marker country) {
		// getting location of feature
		Location checkLoc = earthquake.getLocation();

		// some countries represented it as MultiMarker
		// looping over SimplePolygonMarkers which make them up to use isInsideByLoc
		if(country.getClass() == MultiMarker.class) {
				
			// looping over markers making up MultiMarker
			for(Marker marker : ((MultiMarker)country).getMarkers()) {
					
				// checking if inside
				if(((AbstractShapeMarker)marker).isInsideByLocation(checkLoc)) {
					earthquake.addProperty("country", country.getProperty("name"));
						
					// return if is inside one
					return true;
				}
			}
		}
			
		// check if inside country represented by SimplePolygonMarker
		else if(((AbstractShapeMarker)country).isInsideByLocation(checkLoc)) {
			earthquake.addProperty("country", country.getProperty("name"));
			
			return true;
		}
		return false;
	}

}