Merge changes to location blurring layers

blur_location2city.r2py

@@ -164,4 +164,4 @@ CHILD_CONTEXT_DEF["get_lastknown_location"] = {
 
 
 # Dispatch.
-secure_dispatch_module()
+secure_dispatch_module()

blur_location2country.r2py

@@ -1,185 +1,167 @@
-httpretrieve = dy_import_module("httpretrieve.r2py")
-math = dy_import_module("math.r2py")
-librepyfile = dy_import_module("librepyfile.r2py")
-
-statefilename = "states.txt"        # Database of states
-countryfilename = "countries.txt"   # Database of countries
-
-
-# Downloads the required file from the server
-def get_file_from_server(filename):
-
-  if filename not in listfiles(): # In case it already exists
-    if filename not in [statefilename, countryfilename]:
-      url = "http://sensibilityclearinghouse.poly.edu/data/quad/" + filename
-    else:
-      url = "http://sensibilityclearinghouse.poly.edu/data/" + filename
-    httpretrieve.httpretrieve_save_file(url, filename)
-
-
-# Returns a dictionary containing information about the point closest to
-# a given lat/lng pair, from the database.
-# {"city": closest_city, "statecode": closest_state_code, "countrycode":
-# closest_country_code, "coordinates": closest_point}
-def find_closest_point(lat, lng):
-
-  # Find the database file with coordinates closest to the given lat/lng pair
-  filename = get_filename(lat, lng)
-	# Get the list of coordinates from that file
-  listofpoints = load_lat_lng_from_file(filename)
-
-  min_dist = 9999
-  point1 = (lat, lng)
-
-  for city in listofpoints.keys():
-    data = listofpoints[city]
-    point2 = (data[0], data[1])
-    dist = find_distance(point1, point2)
-    if dist < min_dist:
-      min_dist = dist
-      closest_point = point2
-      closest_city = city
-      closest_state_code = data[3]
-      closest_country_code = data[2]
-
-  closest = {"city": closest_city, "statecode": closest_state_code, "countrycode": closest_country_code, "coordinates": closest_point}
-
-  return closest
-
-
-# Returns the filename in the database with coordinates closest to the given
-# lat/lng pair
-def get_filename(lat, lng):
-
-  # get ceiling as x/y index
-  x = int(math.math_ceil(lat))
-  y = int(math.math_ceil(lng))
-  filename = str(x) + '_' + str(y) + '.txt'
-  return filename
-
-
-# Returns a dictionary containing all the cities in the given file, along with
-# their corresponding data
-# {city1: [lat, lng, country_code, state_code], city2: [lat, lng, country_code,
-# state_code], ...}
-def load_lat_lng_from_file(filename):
-
-  get_file_from_server(filename)
-  listofpoints = {}
-  fileobj = librepyfile.open(filename, "r")
-
-  while True:
-    try:
-      line = fileobj.next().strip()
-    except StopIteration:
-      break
-    else:
-      line = line.split("\t")
-      city_name = line[0]
-      lat = line[1]
-      lng = line[2]
-      country_code = line[3]
-      state_code = line[4]
-      listofpoints[city_name] = [lat, lng, country_code, state_code]
-  fileobj.close()
-  return listofpoints
-
-
-# Returns the distance between two lat/lng points
-def find_distance(p1, p2):
-
-  (lat1, lng1) = p1
-  (lat2, lng2) = p2
-  lat2 = float(lat2)
-  lng2 = float(lng2)
-  lat_diff = (lat1-lat2) * (lat1-lat2)
-  lng_diff = (lng1-lng2) * (lng1-lng2)
-  # return squared distance
-  return lat_diff + lng_diff
-
-
-# To replace get_location()
-def get_country_location():
-
-  try:
-    location_data = get_location()
-  except Exception: # Not able to use LocationNotFoundException here
-    raise Exception
+"""
+A security layer for the functions get_location() and get_lastknown_location()
+defined in getsensor.r2py. This program blurs the latitude/longitude
+coordinates, received from the location sensors of an Android device,
+to the geographic center of the country to which it belongs.
+
+The blurring is done using a database lookup method. First, we use the
+get_geolocation() call to get the current address. The country code in
+the address returned is then used to find a match in the database
+"countries.txt", which is a list of all countries and their geodata.
+This database file is located at:
+http://sensibilityclearinghouse.poly.edu/data/countries.txt
+
+Usage:
+  start dylink.r2py encasementlib.r2py sensor_layer.r2py \
+    blur_location2country.r2py user-program.r2py
+"""
+
+
+
+location_blur_helper = dy_import_module("location_blur_helper.r2py")
+country_filename = "countries.txt"
+
+
+
+def load_country_geodata(address):
+  """
+  Loads the country (or countries) and corresponding geodata from the
+  given file into a dictionary.
+
+  Below is an example of a line from the file "countries.txt" with
+  fields - country code, country name, latitude and longitude:
+  US    United States    39.76    -98.5
+
+  The dictionary returned has the format:
+  {
+    country1: {"latitude": latitude, "longitude": longitude},
+    country2: {"latitude": latitude, "longitude": longitude},
+    ...
+  }
+
+  """
+  # Download the file from the country database.
+  location_blur_helper.get_country_file_from_server(country_filename)
+  # Obtain the list of countries and their geodata from the file.
+  countries_geodata = location_blur_helper.read_data_from_file(country_filename)
+
+  country_dict = {}
+
+  # Check if we can match the country code in the given address to that
+  # in the database. If there is a match, return a dict with that
+  # country and its geodata.
+  for line in countries_geodata:
+    # Ignore the empty line at the end of the file.
+    if line == "":
+      continue
+    country_geodata_record = line.split("\t")
+    if address["country_code"] == country_geodata_record[0]:
+      country_name = country_geodata_record[1]
+      country_dict[country_name] = {
+        "latitude": float(country_geodata_record[2]),
+        "longitude": float(country_geodata_record[3])
+      }
+      return country_dict
+
+  # If no match, return a dict of all countries and their geodata to
+  # find the closest country.
+  for line in countries_geodata:
+    # Ignore the empty line at the end of the file.
+    if line == "":
+      continue
+    country_geodata_record = line.split("\t")
+    country_name = country_geodata_record[1]
+    country_dict[country_name] = {
+      "latitude": float(country_geodata_record[2]),
+      "longitude": float(country_geodata_record[3]),
+    }
+
+  return country_dict
+
+
+def find_closest_country(lat, lon):
+  """
+  Finds the country closest to the given latitude/longitude pair from the
+  dictionary of countries returned by the load_country_geodata() function,
+  and returns that country's geodata in the format:
+  {
+    "country_name": country name (string),
+    "latitude": latitude of the center of the country (float)
+    "longitude": longitude of the center of the country (float)
+  }
+
+  Note: If the load_country_geodata() function returns only one country,
+  which happens when the country code from the get_geolocation() call
+  was successfully matched with one of the countries' code in the database,
+  then only that country's geodata is returned in the dictionary.
+
+  """
+  # Get the address for the given coordinates. Since get_geolocation()
+  # can possibly return more than one address, we take the first one.
+  address = get_geolocation(lat, lon, 1)[0]
+
+  # Load the state(s) and corresponding geodata from the file.
+  countries_dict = load_country_geodata(address)
+
+  return location_blur_helper.find_closest_location(lat, lon, countries_dict)
 
-  latitude = location_data["latitude"]
-  longitude = location_data["longitude"]
 
-  closest = find_closest_point(latitude, longitude)
-  country_code = closest["countrycode"]
 
-  # Download the Countries database
-  get_file_from_server(countryfilename)
+def get_country_location():
+  """
+  Blurring layer for the get_location() function. It replaces the exact
+  coordinates of the Android device with the coordinates for the
+  geographic center of the country to which they belong.
 
-  countryfile = librepyfile.open(countryfilename, "r")
+  """
+  location_data = get_location()
 
-  # Look for the country corresponding to the country code
-  while True:
-    try:
-      line = countryfile.next().strip()
-    except StopIteration:
-      break
-    else:
-      line = line.split("\t")
-      if country_code == line[0]:
-        clat = line[2]
-        clng = line[3]
-        break
-  countryfile.close()
+  closest_country = find_closest_country(location_data["latitude"],
+    location_data["longitude"])
 
-  location_data["latitude"] = clat
-  location_data["longitude"] = clng
+  location_data["latitude"] = closest_country["latitude"]
+  location_data["longitude"] = closest_country["longitude"]
 
   return location_data
 
+
+
 def get_country_lastknown_location():
-  # to replace get_lastknown_location()
-  try:
-    location_data = get_lastknown_location()
-  except Exception: # Not able to use LocationNotFoundException here
-    raise Exception
-
-  # Get the location from the the provider
-  for i in range(len(location_data.keys())):
-    provider = location_data.keys()[i]
-    location = location_data[provider]
-    if location != None:
-      latitude = location["latitude"]
-      longitude = location["longitude"]
-
-      closest = find_closest_point(latitude, longitude)
-
-      country_code = closest["countrycode"]
-
-      # Download the Countries database
-      get_file_from_server(countryfilename)
-
-      countryfile = librepyfile.open(countryfilename, "r")
-
-      # Look for the country corresponding to the country code
-      while True:
-        try:
-          line = countryfile.next().strip()
-        except StopIteration:
-          break
-        else:
-          line = line.split("\t")
-          if country_code == line[0]:
-            clat = line[2]
-            clng = line[3]
-            break
-      countryfile.close()
-
-      location_data[provider]["latitude"] = clat
-      location_data[provider]["longitude"] = clng
+  """
+  Blurring layer for the get_lastknown_location() function. It replaces
+  the last-known coordinates of the Android device with the coordinates
+  for the geographic center of the country to which they belong.
+
+  """
+  location_data = get_lastknown_location()
+
+  # Blur the coordinates of the first non-empty location data.
+  for location_provider, provider_location_data in location_data.items():
+    # Skip this provider's data if it doesn't contain a previous
+    # location.
+    if provider_location_data is None:
+      continue
+
+    closest_country = find_closest_country(provider_location_data["latitude"],
+      provider_location_data["longitude"])
+
+    break
+
+  # Copy the blurred coordinates into all providers' location data.
+  for location_provider, provider_location_data in location_data.items():
+    # Skip blurring this provider's data if it doesn't contain a previous
+    # location.
+    if provider_location_data is None:
+      continue
+
+    location_data[location_provider]["latitude"] = closest_country["latitude"]
+    location_data[location_provider]["longitude"] = closest_country["longitude"]
 
   return location_data
 
 
+
+# Mapping our blurring function get_country_location to get_location.
 CHILD_CONTEXT_DEF["get_location"] = {
     "type": "func",
     "args": None,
@@ -189,6 +171,8 @@ CHILD_CONTEXT_DEF["get_location"] = {
 }
 
 
+# Mapping our blurring function get_country_lastknown_location to
+# get_lastknown_location.
 CHILD_CONTEXT_DEF["get_lastknown_location"] = {
     "type": "func",
     "args": None,
@@ -197,4 +181,6 @@ CHILD_CONTEXT_DEF["get_lastknown_location"] = {
     "target": get_country_lastknown_location,
 }
 
+
+# Dispatch.
 secure_dispatch_module()