Merge pull request #15 from tomasbedrich/dev

Added UTFGrid parsing, localization independant parsing

Author: tomasbedrich

README.rst

@@ -129,6 +129,21 @@ Find all caches on some adress
     for cache in geocaching.search(point, limit=10):
         print(cache.name)
 
+Find approximate location of caches in area
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+::
+
+    from pycaching import Geocaching, Point, Rectangle
+
+    geocaching = pycaching.Geocaching()
+    geocaching.login("user", "pass")
+    rect = Rectangle(Point(60.15, 24.95), Point(60.17, 25.00))
+    for c in geocaching.search_quick(rect, strict=True):
+        print('{:8} ({:.5f}, {:.5f}) (+- {:.1f} m); {}'.format(
+            c.wp, c.location.latitude, c.location.longitude,
+            c.location.precision, c.name))
+
 
 --------
 Appendix

pycaching/__init__.py

@@ -6,6 +6,7 @@
 from pycaching.cache import Cache  # NOQA
 from pycaching.util import Util  # NOQA
 from pycaching.point import Point  # NOQA
+from pycaching.area import Rectangle  # NOQA
 from pycaching.errors import *  # NOQA
 
 

pycaching/area.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+from pycaching.point import Point
+
+
+class Area:
+    """Geometrical area"""
+    pass
+
+
+class Polygon(Area):
+    """Area defined by bordering Point instances"""
+
+    def __init__(self, *points):
+        """Define polygon by list of consecutive Points"""
+        assert len(points) >= 3
+        self.points = points
+
+    @property
+    def bounding_box(self):
+        """Get extreme latitude and longitude values.
+
+        Return Rectangle that contains all points"""
+
+        lats = sorted([p.latitude for p in self.points])
+        lons = sorted([p.longitude for p in self.points])
+        return Rectangle(Point(min(lats), min(lons)),
+                         Point(max(lats), max(lons)))
+
+    @property
+    def mean_point(self):
+        """Return point with average latitude and longitude of points"""
+        lats = [p.latitude for p in self.points]
+        lons = [p.longitude for p in self.points]
+        return Point(sum(lats) / len(lats), sum(lons) / len(lons))
+
+    @property
+    def diagonal(self):
+        """Return bounding box diagonal"""
+        return self.bounding_box.diagonal
+
+
+class Rectangle(Polygon):
+    """Upright rectangle"""
+
+    def __init__(self, point_a, point_b):
+        """Create rectangle defined by opposite corners
+
+        Parameters point_a and point_b are Point instances."""
+
+        assert point_a != point_b, "Corner points cannot be the same"
+        self.corners = [point_a, point_b]
+        self.points = [point_a, Point(point_a.latitude, point_b.longitude),
+                       point_b, Point(point_b.latitude, point_a.longitude)]
+
+    def inside_area(self, point):
+        """Is point inside area?"""
+        lats = sorted([p.latitude for p in self.points])
+        lons = sorted([p.longitude for p in self.points])
+        if min(lats) <= point.latitude <= max(lats):
+            if min(lons) <= point.longitude <= max(lons):
+                return True
+        return False
+
+    @property
+    def diagonal(self):
+        """Return rectangle diagonal"""
+        return self.corners[0].distance(self.corners[1])

pycaching/cache.py

@@ -97,37 +97,36 @@ class Cache(object):
     }
 
     _possible_types = {
-        "Traditional Cache",
-        "Multi-Cache",
-        "Unknown Cache",
-        "Mystery Cache",
-        "Letterbox Hybrid",
-        "Event Cache",
-        "Mega-Event Cache",
-        "Giga-Event Cache",
-        "Earthcache",
-        "Cache In Trash Out Event",
-        "Webcam Cache",
-        "Virtual Cache",
-        "Wherigo Cache",
-        "Lost And Found Event Cache",
-        "Project Ape Cache",
-        "Groundspeak Hq",
-        "Gps Adventures Exhibit",
-        "Groundspeak Block Party",
-        "Locationless (Reverse) Cache",
+        # key is cache image url, used for parsing: http://www.geocaching.com/images/WptTypes/[KEY].gif
+        "2": "Traditional Cache",
+        "3": "Multi-cache",
+        "8": "Mystery Cache",
+        "__8": "Unknown Cache",  # same as Mystery, key not used
+        "5": "Letterbox hybrid",
+        "6": "Event Cache",
+        "mega": "Mega-Event Cache",
+        "giga": "Giga-Event Cache",
+        "earthcache": "Earthcache",
+        "13": "Cache in Trash out Event",
+        "11": "Webcam Cache",
+        "4": "Virtual Cache",
+        "1858": "Wherigo Cache",
+        "10Years_32": "Lost and Found Event Cache",
+        "ape_32": "Project Ape Cache",
+        "HQ_32": "Groundspeak HQ",
+        "1304": "GPS Adventures Exhibit",
+        "4738": "Groundspeak Block Party",
+        "12": "Locationless (Reverse) Cache",
     }
 
     _possible_sizes = {
-        "nano",
-        "micro",
-        "small",
-        "regular",
-        "large",
-        "very large",
-        "not chosen",
-        "virtual",
-        "other"
+        "micro": "micro",
+        "small": "small",
+        "regular": "regular",
+        "large": "large",
+        "not_chosen": "not chosen",
+        "virtual": "virtual",
+        "other": "other",
     }
 
     def __init__(self, wp, geocaching, *, name=None, cache_type=None, location=None, state=None,
@@ -225,11 +224,14 @@ def cache_type(self):
 
     @cache_type.setter
     def cache_type(self, cache_type):
-        cache_type = cache_type.strip().title()
+        cache_type = cache_type.strip()
         cache_type = cache_type.replace("Geocache", "Cache")
-        if cache_type not in self._possible_types:
+        if cache_type in self._possible_types.values():  # try to search in values
+            self._cache_type = cache_type
+        elif cache_type in self._possible_types.keys():  # not in values => it must be a key
+            self._cache_type = self._possible_types[cache_type]
+        else:
             raise ValueError("Cache type '{}' is not possible.".format(cache_type))
-        self._cache_type = cache_type
 
     @property
     @lazy_loaded
@@ -257,9 +259,12 @@ def size(self):
     @size.setter
     def size(self, size):
         size = size.strip().lower()
-        if size not in self._possible_sizes:
+        if size in self._possible_sizes.values():  # try to search in values
+            self._size = size
+        elif size in self._possible_sizes.keys():  # not in values => it must be a key
+            self._size = self._possible_sizes[size]
+        else:
             raise ValueError("Size '{}' is not possible.".format(size))
-        self._size = size
 
     @property
     @lazy_loaded
@@ -372,3 +377,7 @@ def pm_only(self):
     @pm_only.setter
     def pm_only(self, pm_only):
         self._pm_only = bool(pm_only)
+
+    def inside_area(self, area):
+        """Calculate if geocache is inside given area"""
+        return area.inside_area(self.location)