From 4c234fcd557a07284f683805e3430d948b352c87 Mon Sep 17 00:00:00 2001
From: jpcaram <jpcaram@gmail.com>
Date: Wed, 14 Jan 2015 20:24:37 -0500
Subject: [PATCH] Fixes polygon finding for painting. Function find_polygon
 made a method of Geometry. Solves Issue #96.

---
 FlatCAMObj.py |  5 ++--
 camlib.py     | 79 +++++++++++++++++++++++++++++++++++++++------------
 2 files changed, 64 insertions(+), 20 deletions(-)

diff --git a/FlatCAMObj.py b/FlatCAMObj.py
index 1b819a8c..4481c39a 100644
--- a/FlatCAMObj.py
+++ b/FlatCAMObj.py
@@ -957,12 +957,13 @@ class FlatCAMGeometry(FlatCAMObj, Geometry):
     def paint_poly(self, inside_pt, tooldia, overlap):
 
         # Which polygon.
-        poly = find_polygon(self.solid_geometry, inside_pt)
+        #poly = find_polygon(self.solid_geometry, inside_pt)
+        poly = self.find_polygon(inside_pt)
 
         # No polygon?
         if poly is None:
             self.app.log.warning('No polygon found.')
-            self.app.inform('[warning] No polygon found.')
+            self.app.inform.emit('[warning] No polygon found.')
             return
 
         # Initializes the new geometry object
diff --git a/camlib.py b/camlib.py
index f01a537e..c39c034e 100644
--- a/camlib.py
+++ b/camlib.py
@@ -172,7 +172,7 @@ class Geometry(object):
 
         return self.flat_geometry
 
-    def make2Dindex(self):
+    def make2Dstorage(self):
 
         self.flatten()
 
@@ -187,11 +187,11 @@ class Geometry(object):
                 pts += list(o.coords)
             return pts
 
-        idx = FlatCAMRTreeStorage()
-        idx.get_points = get_pts
+        storage = FlatCAMRTreeStorage()
+        storage.get_points = get_pts
         for shape in self.flat_geometry:
-            idx.insert(shape)
-        return idx
+            storage.insert(shape)
+        return storage
 
     # def flatten_to_paths(self, geometry=None, reset=True):
     #     """
@@ -441,6 +441,36 @@ class Geometry(object):
         """
         self.solid_geometry = [cascaded_union(self.solid_geometry)]
 
+    def find_polygon(self, point, geoset=None):
+        """
+        Find an object that object.contains(Point(point)) in
+        poly, which can can be iterable, contain iterable of, or
+        be itself an implementer of .contains().
+
+        :param poly: See description
+        :return: Polygon containing point or None.
+        """
+
+        if geoset is None:
+            geoset = self.solid_geometry
+
+        try:  # Iterable
+            for sub_geo in geoset:
+                p = self.find_polygon(point, geoset=sub_geo)
+                if p is not None:
+                    return p
+
+        except TypeError:  # Non-iterable
+
+            try:  # Implements .contains()
+                if geoset.contains(Point(point)):
+                    return geoset
+
+            except AttributeError:  # Does not implement .contains()
+                return None
+
+        return None
+
 
 class ApertureMacro:
     """
@@ -2908,19 +2938,32 @@ def arc_angle(start, stop, direction):
     return angle
 
 
-def find_polygon(poly_set, point):
-    """
-    Return the first polygon in the list of polygons poly_set
-    that contains the given point.
-    """
-    if poly_set is None:
-        return None
-
-    p = Point(point)
-    for poly in poly_set:
-        if poly.contains(p):
-            return poly
-    return None
+# def find_polygon(poly, point):
+#     """
+#     Find an object that object.contains(Point(point)) in
+#     poly, which can can be iterable, contain iterable of, or
+#     be itself an implementer of .contains().
+#
+#     :param poly: See description
+#     :return: Polygon containing point or None.
+#     """
+#
+#     if poly is None:
+#         return None
+#
+#     try:
+#         for sub_poly in poly:
+#             p = find_polygon(sub_poly, point)
+#             if p is not None:
+#                 return p
+#     except TypeError:
+#         try:
+#             if poly.contains(Point(point)):
+#                 return poly
+#         except AttributeError:
+#             return None
+#
+#     return None
 
 
 def to_dict(obj):