common/src/main/java/org/apache/flink/training/exercises/common/utils/GeoUtils.java - flink-training - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.flink.training.exercises.common.utils;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;

 /**
  * GeoUtils provides utility methods to deal with locations for the data streaming exercises.
  */
 public class GeoUtils {

 	// geo boundaries of the area of NYC
 	public static final double LON_EAST = -73.7;
 	public static final double LON_WEST = -74.05;
 	public static final double LAT_NORTH = 41.0;
 	public static final double LAT_SOUTH = 40.5;

 	// area width and height
 	public static final double LON_WIDTH = 74.05 - 73.7;
 	public static final double LAT_HEIGHT = 41.0 - 40.5;

 	// delta step to create artificial grid overlay of NYC
 	public static final double DELTA_LON = 0.0014;
 	public static final double DELTA_LAT = 0.00125;

 	// ( |LON_WEST| - |LON_EAST| ) / DELTA_LAT
 	public static final int NUMBER_OF_GRID_X = 250;
 	// ( LAT_NORTH - LAT_SOUTH ) / DELTA_LON
 	public static final int NUMBER_OF_GRID_Y = 400;

 	public static final float DEG_LEN = 110.25f;

 	/**
 	 * Checks if a location specified by longitude and latitude values is
 	 * within the geo boundaries of New York City.
 	 *
 	 * @param lon longitude of the location to check
 	 * @param lat latitude of the location to check
 	 *
 	 * @return true if the location is within NYC boundaries, otherwise false.
 	 */
 	public static boolean isInNYC(float lon, float lat) {

 		return !(lon > LON_EAST || lon < LON_WEST) &&
 				!(lat > LAT_NORTH || lat < LAT_SOUTH);
 	}

 	/**
 	 * Maps a location specified by latitude and longitude values to a cell of a
 	 * grid covering the area of NYC.
 	 * The grid cells are roughly 100 x 100 m and sequentially number from north-west
 	 * to south-east starting by zero.
 	 *
 	 * @param lon longitude of the location to map
 	 * @param lat latitude of the location to map
 	 *
 	 * @return id of mapped grid cell.
 	 */
 	public static int mapToGridCell(float lon, float lat) {
 		int xIndex = (int) Math.floor((Math.abs(LON_WEST) - Math.abs(lon)) / DELTA_LON);
 		int yIndex = (int) Math.floor((LAT_NORTH - lat) / DELTA_LAT);

 		return xIndex + (yIndex * NUMBER_OF_GRID_X);
 	}

 	/**
 	 * Maps the direct path between two locations specified by longitude and latitude to a list of
 	 * cells of a grid covering the area of NYC.
 	 * The grid cells are roughly 100 x 100 m and sequentially number from north-west
 	 * to south-east starting by zero.
 	 *
 	 * @param lon1 longitude of the first location
 	 * @param lat1 latitude of the first location
 	 * @param lon2 longitude of the second location
 	 * @param lat2 latitude of the second location
 	 *
 	 * @return A list of cell ids
 	 */
 	public static List<Integer> mapToGridCellsOnWay(float lon1, float lat1, float lon2, float lat2) {

 		int x1 = (int) Math.floor((Math.abs(LON_WEST) - Math.abs(lon1)) / DELTA_LON);
 		int y1 = (int) Math.floor((LAT_NORTH - lat1) / DELTA_LAT);

 		int x2 = (int) Math.floor((Math.abs(LON_WEST) - Math.abs(lon2)) / DELTA_LON);
 		int y2 = (int) Math.floor((LAT_NORTH - lat2) / DELTA_LAT);

 		int startX, startY, endX, endY;
 		if (x1 <= x2) {
 			startX = x1;
 			startY = y1;
 			endX = x2;
 			endY = y2;
 		}
 		else {
 			startX = x2;
 			startY = y2;
 			endX = x1;
 			endY = y1;
 		}

 		double slope = (endY - startY) / ((endX - startX) + 0.00000001);

 		int curX = startX;
 		int curY = startY;

 		ArrayList<Integer> cellIds = new ArrayList<>(64);
 		cellIds.add(curX + (curY * NUMBER_OF_GRID_X));

 		while (curX < endX || curY != endY) {

 			if (slope > 0) {
 				double y = (curX - startX + 0.5) * slope + startY - 0.5;

 				if (y > curY - 0.05 && y < curY + 0.05) {
 					curX++;
 					curY++;
 				}
 				else if (y < curY) {
 					curX++;
 				}
 				else {
 					curY++;
 				}
 			}
 			else {
 				double y = (curX - startX + 0.5) * slope + startY + 0.5;

 				if (y > curY - 0.05 && y < curY + 0.05) {
 					curX++;
 					curY--;
 				}
 				if (y > curY) {
 					curX++;
 				}
 				else {
 					curY--;
 				}

 			}

 			cellIds.add(curX + (curY * NUMBER_OF_GRID_X));
 		}

 		return cellIds;
 	}

 	/**
 	 * Returns the longitude of the center of a grid cell.
 	 *
 	 * @param gridCellId The grid cell.
 	 *
 	 * @return The longitude value of the cell's center.
 	 */
 	public static float getGridCellCenterLon(int gridCellId) {

 		int xIndex = gridCellId % NUMBER_OF_GRID_X;

 		return (float) (Math.abs(LON_WEST) - (xIndex * DELTA_LON) - (DELTA_LON / 2)) * -1.0f;
 	}

 	/**
 	 * Returns the latitude of the center of a grid cell.
 	 *
 	 * @param gridCellId The grid cell.
 	 *
 	 * @return The latitude value of the cell's center.
 	 */
 	public static float getGridCellCenterLat(int gridCellId) {

 		int xIndex = gridCellId % NUMBER_OF_GRID_X;
 		int yIndex = (gridCellId - xIndex) / NUMBER_OF_GRID_X;

 		return (float) (LAT_NORTH - (yIndex * DELTA_LAT) - (DELTA_LAT / 2));

 	}

 	/**
 	 * Returns a random longitude within the NYC area.
 	 *
 	 * @param rand A random number generator.
 	 * @return A random longitude value within the NYC area.
 	 */
 	public static float getRandomNYCLon(Random rand) {
 		return (float) (LON_EAST - (LON_WIDTH * rand.nextFloat()));
 	}

 	/**
 	 * Returns a random latitude within the NYC area.
 	 *
 	 * @param rand A random number generator.
 	 * @return A random latitude value within the NYC area.
 	 */
 	public static float getRandomNYCLat(Random rand) {
 		return (float) (LAT_SOUTH + (LAT_HEIGHT * rand.nextFloat()));
 	}

 	/**
 	 * Returns the Euclidean distance between two locations specified as lon/lat pairs.
 	 *
 	 * @param lon1 Longitude of first location
 	 * @param lat1 Latitude of first location
 	 * @param lon2 Longitude of second location
 	 * @param lat2 Latitude of second location
 	 * @return The Euclidean distance between the specified locations.
 	 */
 	public static double getEuclideanDistance(float lon1, float lat1, float lon2, float lat2) {
 		double x = lat1 - lat2;
 		double y = (lon1 - lon2) * Math.cos(lat2);
 		return (DEG_LEN * Math.sqrt(x * x + y * y));
 	}

 	/**
 	 * Returns the angle in degrees between the vector from the start to the destination
 	 * and the x-axis on which the start is located.
 	 *
 	 * <p>The angle describes in which direction the destination is located from the start, i.e.,
 	 * 0° -> East, 90° -> South, 180° -> West, 270° -> North
 	 *
 	 * @param startLon longitude of start location
 	 * @param startLat latitude of start location
 	 * @param destLon longitude of destination
 	 * @param destLat latitude of destination
 	 * @return The direction from start to destination location
 	 */
 	public static int getDirectionAngle(
 			float startLon, float startLat, float destLon, float destLat) {

 		double x = destLat - startLat;
 		double y = (destLon - startLon) * Math.cos(startLat);

 		return (int) Math.toDegrees(Math.atan2(x, y)) + 179;
 	}

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.flink.training.exercises.common.utils;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Random;

	/**
	* GeoUtils provides utility methods to deal with locations for the data streaming exercises.
	*/
	public class GeoUtils {

	// geo boundaries of the area of NYC
	public static final double LON_EAST = -73.7;
	public static final double LON_WEST = -74.05;
	public static final double LAT_NORTH = 41.0;
	public static final double LAT_SOUTH = 40.5;

	// area width and height
	public static final double LON_WIDTH = 74.05 - 73.7;
	public static final double LAT_HEIGHT = 41.0 - 40.5;

	// delta step to create artificial grid overlay of NYC
	public static final double DELTA_LON = 0.0014;
	public static final double DELTA_LAT = 0.00125;

	// ( \|LON_WEST\| - \|LON_EAST\| ) / DELTA_LAT
	public static final int NUMBER_OF_GRID_X = 250;
	// ( LAT_NORTH - LAT_SOUTH ) / DELTA_LON
	public static final int NUMBER_OF_GRID_Y = 400;

	public static final float DEG_LEN = 110.25f;

	/**
	* Checks if a location specified by longitude and latitude values is
	* within the geo boundaries of New York City.
	*
	* @param lon longitude of the location to check
	* @param lat latitude of the location to check
	*
	* @return true if the location is within NYC boundaries, otherwise false.
	*/
	public static boolean isInNYC(float lon, float lat) {

	return !(lon > LON_EAST \|\| lon < LON_WEST) &&
	!(lat > LAT_NORTH \|\| lat < LAT_SOUTH);
	}

	/**
	* Maps a location specified by latitude and longitude values to a cell of a
	* grid covering the area of NYC.
	* The grid cells are roughly 100 x 100 m and sequentially number from north-west
	* to south-east starting by zero.
	*
	* @param lon longitude of the location to map
	* @param lat latitude of the location to map
	*
	* @return id of mapped grid cell.
	*/
	public static int mapToGridCell(float lon, float lat) {
	int xIndex = (int) Math.floor((Math.abs(LON_WEST) - Math.abs(lon)) / DELTA_LON);
	int yIndex = (int) Math.floor((LAT_NORTH - lat) / DELTA_LAT);

	return xIndex + (yIndex * NUMBER_OF_GRID_X);
	}

	/**
	* Maps the direct path between two locations specified by longitude and latitude to a list of
	* cells of a grid covering the area of NYC.
	* The grid cells are roughly 100 x 100 m and sequentially number from north-west
	* to south-east starting by zero.
	*
	* @param lon1 longitude of the first location
	* @param lat1 latitude of the first location
	* @param lon2 longitude of the second location
	* @param lat2 latitude of the second location
	*
	* @return A list of cell ids
	*/
	public static List<Integer> mapToGridCellsOnWay(float lon1, float lat1, float lon2, float lat2) {

	int x1 = (int) Math.floor((Math.abs(LON_WEST) - Math.abs(lon1)) / DELTA_LON);
	int y1 = (int) Math.floor((LAT_NORTH - lat1) / DELTA_LAT);

	int x2 = (int) Math.floor((Math.abs(LON_WEST) - Math.abs(lon2)) / DELTA_LON);
	int y2 = (int) Math.floor((LAT_NORTH - lat2) / DELTA_LAT);

	int startX, startY, endX, endY;
	if (x1 <= x2) {
	startX = x1;
	startY = y1;
	endX = x2;
	endY = y2;
	}
	else {
	startX = x2;
	startY = y2;
	endX = x1;
	endY = y1;
	}

	double slope = (endY - startY) / ((endX - startX) + 0.00000001);

	int curX = startX;
	int curY = startY;

	ArrayList<Integer> cellIds = new ArrayList<>(64);
	cellIds.add(curX + (curY * NUMBER_OF_GRID_X));

	while (curX < endX \|\| curY != endY) {

	if (slope > 0) {
	double y = (curX - startX + 0.5) * slope + startY - 0.5;

	if (y > curY - 0.05 && y < curY + 0.05) {
	curX++;
	curY++;
	}
	else if (y < curY) {
	curX++;
	}
	else {
	curY++;
	}
	}
	else {
	double y = (curX - startX + 0.5) * slope + startY + 0.5;

	if (y > curY - 0.05 && y < curY + 0.05) {
	curX++;
	curY--;
	}
	if (y > curY) {
	curX++;
	}
	else {
	curY--;
	}

	}

	cellIds.add(curX + (curY * NUMBER_OF_GRID_X));
	}

	return cellIds;
	}

	/**
	* Returns the longitude of the center of a grid cell.
	*
	* @param gridCellId The grid cell.
	*
	* @return The longitude value of the cell's center.
	*/
	public static float getGridCellCenterLon(int gridCellId) {

	int xIndex = gridCellId % NUMBER_OF_GRID_X;

	return (float) (Math.abs(LON_WEST) - (xIndex * DELTA_LON) - (DELTA_LON / 2)) * -1.0f;
	}

	/**
	* Returns the latitude of the center of a grid cell.
	*
	* @param gridCellId The grid cell.
	*
	* @return The latitude value of the cell's center.
	*/
	public static float getGridCellCenterLat(int gridCellId) {

	int xIndex = gridCellId % NUMBER_OF_GRID_X;
	int yIndex = (gridCellId - xIndex) / NUMBER_OF_GRID_X;

	return (float) (LAT_NORTH - (yIndex * DELTA_LAT) - (DELTA_LAT / 2));

	}

	/**
	* Returns a random longitude within the NYC area.
	*
	* @param rand A random number generator.
	* @return A random longitude value within the NYC area.
	*/
	public static float getRandomNYCLon(Random rand) {
	return (float) (LON_EAST - (LON_WIDTH * rand.nextFloat()));
	}

	/**
	* Returns a random latitude within the NYC area.
	*
	* @param rand A random number generator.
	* @return A random latitude value within the NYC area.
	*/
	public static float getRandomNYCLat(Random rand) {
	return (float) (LAT_SOUTH + (LAT_HEIGHT * rand.nextFloat()));
	}

	/**
	* Returns the Euclidean distance between two locations specified as lon/lat pairs.
	*
	* @param lon1 Longitude of first location
	* @param lat1 Latitude of first location
	* @param lon2 Longitude of second location
	* @param lat2 Latitude of second location
	* @return The Euclidean distance between the specified locations.
	*/
	public static double getEuclideanDistance(float lon1, float lat1, float lon2, float lat2) {
	double x = lat1 - lat2;
	double y = (lon1 - lon2) * Math.cos(lat2);
	return (DEG_LEN * Math.sqrt(x * x + y * y));
	}

	/**
	* Returns the angle in degrees between the vector from the start to the destination
	* and the x-axis on which the start is located.
	*
	* <p>The angle describes in which direction the destination is located from the start, i.e.,
	* 0° -> East, 90° -> South, 180° -> West, 270° -> North
	*
	* @param startLon longitude of start location
	* @param startLat latitude of start location
	* @param destLon longitude of destination
	* @param destLat latitude of destination
	* @return The direction from start to destination location
	*/
	public static int getDirectionAngle(
	float startLon, float startLat, float destLon, float destLat) {

	double x = destLat - startLat;
	double y = (destLon - startLon) * Math.cos(startLat);

	return (int) Math.toDegrees(Math.atan2(x, y)) + 179;
	}

	}