View difference between Paste ID: e8L9Ezrq and WddebtBA

 import time
-from functools import partial
+
-from itertools import chain, imap
+
 
 
 def iter_points(layer):
     for feature in layer:
         exterior_ring = feature.GetGeometryRef().GetGeometryRef(0)
         for i in xrange(exterior_ring.GetPointCount()):
             yield exterior_ring.GetPoint(i)
 
 
 def clean_points(points):
     #
     # Delete the last point of each triangle (we only need three point for our
     # calculations)
     #
     # TODO: The code below has the effect of the original code but it doesn't
     #       match the description above and it repeats points which will get
     #       filtered out in a later processing step anyway.  I guess the
     #       `drop_every_nth()` function below is actually wanted here instead.
     #
     points = iter(points)
     try:
         while True:
             yield next(points)
             next(points)
             point = next(points)
             yield point
             yield point
             next(points)
     except StopIteration:
         pass  # Ignored intentionally.
 
 
 def drop_every_nth(nth, iterable):
     return (item for i, item in enumerate(iterable, 1) if i % nth != 0)
-def drop_every_nth(iterable, nth):
+
-    return (item for i, item in enumerate(iterable) if i % nth != 0)
+
 def distance(point_a, point_b):
     #
-def calculate_mid_value(a, b):
+    # TODO: To be the usual euklidean distance formula it lacks a `math.sqrt()`
-    return min(a, b) + abs(b - a) / 2.0
+    #       call!
     #
     return sum((a - b)**2 for a, b in zip(point_a, point_b))
-def partition_points(points, bounding_box):
+
-    bbox_xmin, bbox_xmax, bbox_ymin, bbox_ymax = bounding_box
+
-    vertical_middle = calculate_mid_value(bbox_xmin, bbox_xmax)
+
-    horizontal_middle = calculate_mid_value(bbox_ymin, bbox_ymax)
+
-    result = [[list(), list()], [list(), list()]]
+    # TODO: The reversing is only neccessary if the points have to be looked
     #       at in the order they are given to this function.  If going through
-        x, y, _ = point
+    #       them in reverse would be okay we could spare this step.
     #
-        # TODO: Points *on* the lines won't get filtered out here.  If that's
+    points = list(reversed(points))
-        #       a bug we need an extra test here.
+    while points:
         point = points.pop()
-        result[y < horizontal_middle][x < vertical_middle].append(point)
+        point_count = len(points)
         points = [p for p in points if distance(point, p) >= minimal_distance]
-    for row in result:
+        if len(points) == point_count:
-        for cell in row:
+
-            yield cell
+
 
 def create_geometry(points):
     geometry = ogr.Geometry(ogr.wkbMultiPoint)
     wkb_point = ogr.Geometry(ogr.wkbPoint)
     for point in points:
         wkb_point.AddPoint(*point)
         geometry.AddGeometry(wkb_point)
-    seen = set()
+
 
-        if (
+
-            point not in seen
+
-            and all(distance(point, p) >= minimal_distance for p in points)
+
-        ):
+
-            seen.add(point)
+
             identifier=__name__,
             title='Pollmueller Tin-Reducer',
             version = '0.1',
             storeSupported='true',
             statusSupported='true',
             abstract=(
                 'reduces the points of a given triangulated irregular network'
                 ' by a variable factor'
             ),
             grassLocation=False
         )
         self.data_output = self.addComplexOutput(
             identifier='output',
             title='Output vector data',
             formats=[{'mimeType': 'text/xml'}]
         )
         self.time_output = self.addLiteralOutput(
             identifier='output2',
             title='computation time (to compare different approaches)'
         )
         self.data_filename_input = self.addComplexInput(
             identifier='data',
             title='Input vector data',
             formats=[{'mimeType': 'text/xml'}]
         )
         self.minimal_distance_input = self.addLiteralInput(
             identifier='input2', title='minimal distance between points'
         )
 
     def execute(self):
         #
         # TODO: Different operating systems have different semantics and
         #       resolutions for `time()` and `clock()`.  Make sure `clock()` is
         #       the correct one here.
         #
         start_timestamp = time.clock()
 
         shape_file = ogr.Open(self.data_filename_input.getValue())
         if shape_file is None:
             raise Exception('failed to open shape file.')
         #
         # Get the first layer.
         #
         layer = shape_file.GetLayer(0)
         layer.ResetReading()
         points = filter_close_points(
             self.minimal_distance_input.getValue(),
             clean_points(iter_points(layer))
         )
         gml = create_geometry(points).ExportToGML()
 
         elapsed_time = time.clock() - start_timestamp
         self.data_output.setValue(gml)
         self.time_output.setValue(elapsed_time)