remove duplicate code (#10)

Author: kip-hart

aabbtree.py

@@ -445,76 +445,7 @@ def does_overlap(self, aabb, method='DFS'):
         Returns:
             bool: True if overlaps with a leaf node of tree.
         """
-        if isinstance(aabb, AABB):
-            tree = AABBTree(aabb=aabb)
-        else:
-            tree = aabb
-
-        if method == 'DFS':
-            if self.is_leaf and tree.is_leaf:
-                return self.aabb.overlaps(tree.aabb)
-
-            if self.is_leaf:
-                left_over = tree.left.aabb.overlaps(self.aabb)
-                right_over = tree.right.aabb.overlaps(self.aabb)
-
-                if left_over and tree.left.does_overlap(self, method):
-                    return True
-                if right_over and tree.right.does_overlap(self, method):
-                    return True
-                return False
-            if tree.is_leaf:
-                left_over = self.left.aabb.overlaps(tree.aabb)
-                right_over = self.right.aabb.overlaps(tree.aabb)
-
-                if left_over and self.left.does_overlap(tree, method):
-                    return True
-                if right_over and self.right.does_overlap(tree, method):
-                    return True
-                return False
-
-            # If both `self` and `tree` are trees
-            if not self.aabb.overlaps(tree.aabb):
-                return False
-
-            left_left = self.left.aabb.overlaps(tree.left.aabb)
-            left_right = self.left.aabb.overlaps(tree.right.aabb)
-            right_left = self.right.aabb.overlaps(tree.left.aabb)
-            right_right = self.right.aabb.overlaps(tree.right.aabb)
-
-            if left_left and self.left.does_overlap(tree.left, method):
-                return True
-            if left_right and self.left.does_overlap(tree.right, method):
-                return True
-            if right_left and self.right.does_overlap(tree.left, method):
-                return True
-            if right_right and self.right.does_overlap(tree.right, method):
-                return True
-            return False
-
-        if method == 'BFS':
-            q = deque()
-            q.append((self, tree))
-            while len(q) > 0:
-                s_node, t_node = q.popleft()
-                overlaps = s_node.aabb.overlaps(t_node.aabb)
-                if overlaps and s_node.is_leaf and t_node.is_leaf:
-                    return True
-                if overlaps and s_node.is_leaf:
-                    q.append((s_node, t_node.left))
-                    q.append((s_node, t_node.right))
-                elif overlaps and t_node.is_leaf:
-                    q.append((s_node.left, t_node))
-                    q.append((s_node.right, t_node))
-                elif overlaps:
-                    q.append((s_node.left, t_node.left))
-                    q.append((s_node.left, t_node.right))
-                    q.append((s_node.right, t_node.left))
-                    q.append((s_node.right, t_node.right))
-            return False
-
-        e_str = "method should be 'DFS' or 'BFS', not " + str(method)
-        raise ValueError(e_str)
+        return len(self._overlap_pairs(aabb, method, halt=True)) > 0
 
     def overlap_aabbs(self, aabb, method='DFS'):
         """Get overlapping AABBs
@@ -566,7 +497,7 @@ def overlap_values(self, aabb, method='DFS'):
         _, values = zip(*pairs)
         return list(values)
 
-    def _overlap_pairs(self, aabb, method='DFS'):
+    def _overlap_pairs(self, aabb, method='DFS', halt=False):
         """Get overlapping AABBs and values in (AABB, value) pairs
 
         *New  in version 2.6.0*
@@ -578,6 +509,8 @@ def _overlap_pairs(self, aabb, method='DFS'):
             method (str): {'DFS'|'BFS'} Method for traversing the tree.
                 Setting 'DFS' performs a depth-first search and 'BFS' performs
                 a breadth-first search. Defaults to 'DFS'.
+            halt (bool):  Return the list immediately once a pair has been
+                added.
 
         Returns:
             list: (AABB, value) pairs in AABBTree that overlap with the input.
@@ -590,17 +523,30 @@ def _overlap_pairs(self, aabb, method='DFS'):
         pairs = []
 
         if method == 'DFS':
-            if self.is_leaf and self.does_overlap(tree, method):
-                pairs.append((self.aabb, self.value))
+            if self.is_leaf and self.aabb.overlaps(tree.aabb):
+                if tree.is_leaf:
+                    pairs.append((self.aabb, self.value))
+                    if halt:
+                        return pairs
+                else:
+                    for branch in (tree.left, tree.right):
+                        pairs.extend(self._overlap_pairs(branch, method, halt))
+                        if halt and len(pairs) > 0:
+                            return pairs
             elif self.is_leaf:
                 pass
             elif tree.is_leaf:
                 for branch in (self.left, self.right):
-                    pairs.extend(branch._overlap_pairs(tree, method))
+                    pairs.extend(branch._overlap_pairs(tree, method, halt))
+                    if halt and len(pairs) > 0:
+                        return pairs
             else:
                 for s_branch in (self.left, self.right):
                     for t_branch in (tree.left, tree.right):
-                        pairs.extend(s_branch._overlap_pairs(t_branch, method))
+                        p = s_branch._overlap_pairs(t_branch, method, halt)
+                        pairs.extend(p)
+                        if halt and len(pairs) > 0:
+                            return pairs
 
         elif method == 'BFS':
             q = deque()
@@ -610,6 +556,8 @@ def _overlap_pairs(self, aabb, method='DFS'):
                 if s_node.aabb.overlaps(t_node.aabb):
                     if s_node.is_leaf and t_node.is_leaf:
                         pairs.append((s_node.aabb, s_node.value))
+                        if halt:
+                            return pairs
                     elif s_node.is_leaf:
                         q.append((s_node, t_node.left))
                         q.append((s_node, t_node.right))

setup.py

@@ -15,7 +15,7 @@ def read(fname):
 
 setup(
     name='aabbtree',
-    version='2.6.0',
+    version='2.6.1',
     license='MIT',
     description='Pure Python implementation of d-dimensional AABB tree.',
     long_description=read('README.rst'),