late work

analytics.py

@@ -0,0 +1,156 @@
+import math
+
+from .point import Point
+
+def mean_center(points):
+    """
+    Given a set of points, compute the mean center
+
+    Parameters
+    ----------
+    points : list
+         A list of points in the form (x,y)
+
+    Returns
+    -------
+    x : float
+        Mean x coordinate
+
+    y : float
+        Mean y coordinate
+    """
+    x = None
+    y = None
+    sum_x=[]
+    sum_y=[]
+    for x_tmp,y_tmp in points:
+        sum_x.append(x_tmp)
+        sum_y.append(y_tmp)
+
+    x=float(sum(sum_x)/len(sum_x))
+    y=float(sum(sum_y)/len(sum_y))
+
+    return x, y
+
+def euclidean_distance(a, b):
+    """
+    Compute the Euclidean distance between two points
+
+    Parameters
+    ----------
+    a : tuple
+        A point in the form (x,y)
+
+    b : tuple
+        A point in the form (x,y)
+
+    Returns
+    -------
+
+    distance : float
+               The Euclidean distance between the two points
+    """
+    distance = math.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2)
+    return distance
+
+def average_nearest_neighbor_distance(points,mark=None):
+    """
+    Given a set of points, compute the average nearest neighbor.
+
+    Parameters
+    ----------
+    points : list
+             A list of points
+    mark   : str
+
+    Returns
+    -------
+    mean_d : float
+             Average nearest neighbor distance
+
+    References
+    ----------
+    Clark and Evan (1954 Distance to Nearest Neighbor as a
+     Measure of Spatial Relationships in Populations. Ecology. 35(4)
+     p. 445-453.
+    """
+    mean_d = 0
+    if mark==None:
+        points_tmp=points
+    else:
+        points_tmp=[ point for point in points if point.mark==mark]
+
+    length=len(points_tmp)
+    nearest_distances=[]
+    for i in range(length):
+        distance=[]
+        for j in range(length):
+            if i==j:
+                continue
+            else:
+                distance.append(euclidean_distance((points_tmp[i].x,points_tmp[i].y),(points_tmp[j].x,points_tmp[j].y)))
+        nearest_distances.append(min(distance))
+
+    mean_d=float(sum(nearest_distances)/len(nearest_distances))
+    return mean_d
+
+
+def minimum_bounding_rectangle(points):
+    """
+    Given a set of points, compute the minimum bounding rectangle.
+
+    Parameters
+    ----------
+    points : list
+             A list of points in the form (x,y)
+
+    Returns
+    -------
+     : list
+       Corners of the MBR in the form [xmin, ymin, xmax, ymax]
+    """
+
+    mbr = [0,0,0,0]
+
+    x_list=[]
+    y_list=[]
+    for x,y in points:
+        x_list.append(x)
+        y_list.append(y)
+    mbr=[min(x_list),min(y_list),max(x_list),max(y_list)]
+
+    return mbr
+
+
+def mbr_area(mbr):
+    """
+    Compute the area of a minimum bounding rectangle
+    """
+    area = 0
+    area=(mbr[2]-mbr[0])*(mbr[3]-mbr[1])
+    return area
+
+
+def expected_distance(area, n):
+    """
+    Compute the expected mean distance given
+    some study area.
+
+    This makes lots of assumptions and is not
+    necessarily how you would want to compute
+    this.  This is just an example of the full
+    analysis pipe, e.g. compute the mean distance
+    and the expected mean distance.
+
+    Parameters
+    ----------
+    area : float
+           The area of the study area
+
+    n : int
+        The number of points
+    """
+
+    expected = 0
+    expected =float((math.sqrt(area/n))/2)
+    return expected

io_geojson.py

@@ -0,0 +1,79 @@
+import json
+
+
+def read_geojson(input_file):
+    """
+    Read a geojson file
+
+    Parameters
+    ----------
+    input_file : str
+                 The PATH to the data to be read
+
+    Returns
+    -------
+    gj : dict
+         An in memory version of the geojson
+    """
+    # Please use the python json module (imported above)
+    # to solve this one.
+    gj = None
+    fp = open(input_file, 'r')
+    gj = json.loads(fp.read())
+    fp.close()
+    return gj
+
+def find_largest_city(gj):
+    """
+    Iterate through a geojson feature collection and
+    find the largest city.  Assume that the key
+    to access the maximum population is 'pop_max'.
+
+    Parameters
+    ----------
+    gj : dict
+         A GeoJSON file read in as a Python dictionary
+
+    Returns
+    -------
+    city : str
+           The largest city
+
+    population : int
+                 The population of the largest city
+    """
+    city = None
+    max_population = 0
+    for feature in gj["features"]:
+        if feature["properties"]["pop_max"]>max_population:
+            max_population=feature["properties"]["pop_max"]
+            city=feature["properties"]["nameascii"]
+
+    return city, max_population
+
+
+def write_your_own(gj):
+    """
+    Here you will write your own code to find
+    some attribute in the supplied geojson file.
+
+    Take a look at the attributes available and pick
+    something interesting that you might like to find
+    or summarize.  This is totally up to you.
+
+    Do not forget to write the accompanying test in
+    tests.py!
+
+    To find the average of pop_max and pop_min.
+
+    """
+
+    sum_pop_max=0
+    sum_pop_min=0
+    num=0
+    for feature in gj["features"]:
+        sum_pop_max+=feature["properties"]["pop_max"]
+        sum_pop_min+=feature["properties"]["pop_min"]
+        num+=1
+
+    return float(sum_pop_max/num),float(sum_pop_min/num)

point.py

@@ -0,0 +1,19 @@
+
+
+
+class Point():
+
+    def __init__(self,x,y,mark=None):
+        self.x=x
+        self.y=y
+        self.mark=mark
+
+    def check_coincident(self, peer_p):
+
+        return (self.x == peer_p.x and self.y == peer_p.y and self.mark == peer_p.mark)
+
+    def shift_point(self, x_shift, y_shift):
+
+        self.x += x_shift
+        self.y += y_shift
+

tests/functional_test.py

@@ -1,35 +1,40 @@
 import random
 import unittest
 
+from .. import point
 from .. import analytics
 from .. import io_geojson
 from .. import utils
 
 
+
 class TestFunctionalPointPattern(unittest.TestCase):
 
     def setUp(self):
+        random.seed(123)
+        self.marks=['red','blue','green']
+        mark_list=[ random.choice(self.marks) for i in range(100)]
         random.seed(12345)
         i = 0
         self.points = []
         while i < 100:
             seed = (round(random.random(),2), round(random.random(),2))
-            self.points.append(seed)
+            self.points.append(point.Point(seed[0],seed[1],mark_list[i]))
             n_additional = random.randint(5,10)
             i += 1
             c = random.choice([0,1])
             if c:
                 for j in range(n_additional):
                     x_offset = random.randint(0,10) / 100
                     y_offset = random.randint(0,10) / 100
-                    pt = (round(seed[0] + x_offset, 2), round(seed[1] + y_offset,2))
+                    pt =point.Point(round(seed[0] + x_offset, 2), round(seed[1] + y_offset,2),mark_list[i])
                     self.points.append(pt)
                     i += 1
                     if i == 100:
                         break
             if i == 100:
                 break
-
+        #print([(points.x,points.y)for points in self.points])
     def test_point_pattern(self):
         """
         This test checks that the code can compute an observed mean
@@ -40,28 +45,81 @@ def test_point_pattern(self):
         """
         random.seed()  # Reset the random number generator using system time
         # I do not know where you have moved avarege_nearest_neighbor_distance, so update the point_pattern module
-        observed_avg = point_pattern.average_nearest_neighbor_distance(self.points)
+        observed_avg = analytics.average_nearest_neighbor_distance(self.points)
         self.assertAlmostEqual(0.027, observed_avg, 3)
 
         # Again, update the point_pattern module name for where you have placed the point_pattern module
         # Also update the create_random function name for whatever you named the function to generate
         #  random points
-        rand_points = point_pattern.create_random(100)
+        rand_points = utils.generate_random_points(100)
         self.assertEqual(100, len(rand_points))
 
         # As above, update the module and function name.
-        permutations = point_pattern.permutations(99)
+        permutations = utils.permutation(99)
         self.assertEqual(len(permutations), 99)
         self.assertNotEqual(permutations[0], permutations[1])
 
         # As above, update the module and function name.
-        lower, upper = point_pattern.compute_critical(permutations)
+        lower, upper = utils.critical_points(permutations)
         self.assertTrue(lower > 0.03)
         self.assertTrue(upper < 0.07)
         self.assertTrue(observed_avg < lower or observed_avg > upper)
 
         # As above, update the module and function name.
-        significant = point_pattern.check_significant(lower, upper, observed)
+        significant = utils.is_observed_distance_significant(lower, upper, observed_avg)
+        self.assertTrue(significant)
+
+        self.assertTrue(True)
+
+    def test_mark_point_pattern(self):
+
+        random.seed(12345)
+        # I do not know where you have moved avarege_nearest_neighbor_distance, so update the point_pattern module
+        observed_avg_red = analytics.average_nearest_neighbor_distance(self.points,self.marks[0])
+        self.assertAlmostEqual(0.041, observed_avg_red, 3)
+
+        observed_avg_blue = analytics.average_nearest_neighbor_distance(self.points,self.marks[1])
+        self.assertAlmostEqual(0.045, observed_avg_blue, 3)
+        observed_avg_green = analytics.average_nearest_neighbor_distance(self.points,self.marks[2])
+        self.assertAlmostEqual(0.059, observed_avg_green, 3)
+
+        # Again, update the point_pattern module name for where you have placed the point_pattern module
+        # Also update the create_random function name for whatever you named the function to generate
+        #  random points
+        rand_points = utils.create_random_marked_points(100,self.marks)
+        self.assertEqual(100, len(rand_points))
+
+        # As above, update the module and function name.
+        permutations = utils.permutation_mark(99,marks=self.marks)
+        self.assertEqual(len(permutations), 99)
+        self.assertNotEqual(permutations[0], permutations[1])
+
+        # As above, update the module and function name.
+        permutations = utils.permutation_mark(99,marks=self.marks,mark=self.marks[0])
+        lower, upper = utils.critical_points(permutations)
+        self.assertTrue(lower > 0.03)
+        self.assertTrue(upper < 0.20)
+        self.assertTrue(observed_avg_red < lower or observed_avg_red > upper)
+
+        significant = utils.is_observed_distance_significant(lower, upper, observed_avg_red)
+        self.assertTrue(significant)
+
+        permutations = utils.permutation_mark(99,marks=self.marks,mark=self.marks[1])
+        lower, upper = utils.critical_points(permutations)
+        self.assertTrue(lower > 0.03)
+        self.assertTrue(upper < 0.20)
+        self.assertTrue(observed_avg_blue < lower or observed_avg_blue > upper)
+        significant = utils.is_observed_distance_significant(lower, upper, observed_avg_blue)
+        self.assertTrue(significant)
+
+
+        permutations = utils.permutation_mark(99,marks=self.marks,mark=self.marks[2])
+        lower, upper = utils.critical_points(permutations)
+
+        self.assertTrue(lower > 0.03)
+        self.assertTrue(upper < 0.20)
+        self.assertTrue(observed_avg_green < lower or observed_avg_green > upper)
+        significant = utils.is_observed_distance_significant(lower, upper, observed_avg_green)
         self.assertTrue(significant)
 
-        self.assertTrue(False)
+        self.assertTrue(True)