style cleanup: pep8, also use float literals when comparing floats and pass tuples to mathutils.Vector() rather then list.

release/scripts/freestyle/style_modules/parameter_editor.py

@@ -38,24 +38,29 @@ from PredicatesU1D import pyNatureUP1D
 from logical_operators import AndUP1D, NotUP1D, OrUP1D
 from shaders import pyBluePrintCirclesShader, pyBluePrintEllipsesShader, pyBluePrintSquaresShader
 
+
 class ColorRampModifier(StrokeShader):
     def __init__(self, blend, influence, ramp):
         StrokeShader.__init__(self)
         self.__blend = blend
         self.__influence = influence
         self.__ramp = ramp
+
     def evaluate(self, t):
         col = freestyle.evaluateColorRamp(self.__ramp, t)
-        col = col.xyz # omit alpha
+        col = col.xyz  # omit alpha
         return col
+
     def blend_ramp(self, a, b):
         return freestyle.blendRamp(self.__blend, a, self.__influence, b)
 
+
 class ScalarBlendModifier(StrokeShader):
     def __init__(self, blend, influence):
         StrokeShader.__init__(self)
         self.__blend = blend
         self.__influence = influence
+
     def blend(self, v1, v2):
         fac = self.__influence
         facm = 1.0 - fac
@@ -64,7 +69,7 @@ class ScalarBlendModifier(StrokeShader):
         elif self.__blend == 'ADD':
             v1 += fac * v2
         elif self.__blend == 'MULTIPLY':
-            v1 *= facm + fac * v2;
+            v1 *= facm + fac * v2
         elif self.__blend == 'SUBTRACT':
             v1 -= fac * v2
         elif self.__blend == 'DIVIDE':
@@ -84,6 +89,7 @@ class ScalarBlendModifier(StrokeShader):
             raise ValueError("unknown curve blend type: " + self.__blend)
         return v1
 
+
 class CurveMappingModifier(ScalarBlendModifier):
     def __init__(self, blend, influence, mapping, invert, curve):
         ScalarBlendModifier.__init__(self, blend, influence)
@@ -91,19 +97,24 @@ class CurveMappingModifier(ScalarBlendModifier):
         self.__mapping = getattr(self, mapping)
         self.__invert = invert
         self.__curve = curve
+
     def LINEAR(self, t):
         if self.__invert:
             return 1.0 - t
         return t
+
     def CURVE(self, t):
         return freestyle.evaluateCurveMappingF(self.__curve, 0, t)
+
     def evaluate(self, t):
         return self.__mapping(t)
 
+
 class ThicknessModifierMixIn:
     def __init__(self):
         scene = freestyle.getCurrentScene()
         self.__persp_camera = (scene.camera.data.type == 'PERSP')
+
     def set_thickness(self, sv, outer, inner):
         fe = sv.first_svertex.get_fedge(sv.second_svertex)
         nature = fe.nature
@@ -114,20 +125,22 @@ class ThicknessModifierMixIn:
                 dir = point.dot(fe.normal_left)
             else:
                 dir = fe.normal_left.z
-            if dir < 0.0: # the back side is visible
+            if dir < 0.0:  # the back side is visible
                 outer, inner = inner, outer
         elif (nature & Nature.SILHOUETTE):
-            if fe.is_smooth: # TODO more tests needed
+            if fe.is_smooth:  # TODO more tests needed
                 outer, inner = inner, outer
         else:
             outer = inner = (outer + inner) / 2
         sv.attribute.thickness = (outer, inner)
 
+
 class ThicknessBlenderMixIn(ThicknessModifierMixIn):
     def __init__(self, position, ratio):
         ThicknessModifierMixIn.__init__(self)
         self.__position = position
         self.__ratio = ratio
+
     def blend_thickness(self, outer, inner, v):
         if self.__position == 'CENTER':
             outer = self.blend(outer, v / 2)
@@ -145,9 +158,11 @@ class ThicknessBlenderMixIn(ThicknessModifierMixIn):
             raise ValueError("unknown thickness position: " + self.__position)
         return outer, inner
 
+
 class BaseColorShader(ConstantColorShader):
     pass
 
+
 class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
     def __init__(self, thickness, position, ratio):
         StrokeShader.__init__(self)
@@ -166,6 +181,7 @@ class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
             self.__inner = thickness * (1 - ratio)
         else:
             raise ValueError("unknown thickness position: " + self.position)
+
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
         while not it.is_end:
@@ -173,6 +189,7 @@ class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
             self.set_thickness(sv, self.__outer, self.__inner)
             it.increment()
 
+
 # Along Stroke modifiers
 
 def iter_t2d_along_stroke(stroke):
@@ -183,11 +200,12 @@ def iter_t2d_along_stroke(stroke):
     while not it.is_end:
         p = it.object.point
         distance += (prev - p).length
-        prev = p.copy() # need a copy because the point can be altered
+        prev = p.copy()  # need a copy because the point can be altered
         t = min(distance / total, 1.0) if total > 0.0 else 0.0
         yield it, t
         it.increment()
 
+
 class ColorAlongStrokeShader(ColorRampModifier):
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
@@ -196,6 +214,7 @@ class ColorAlongStrokeShader(ColorRampModifier):
             b = self.evaluate(t)
             sv.attribute.color = self.blend_ramp(a, b)
 
+
 class AlphaAlongStrokeShader(CurveMappingModifier):
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
@@ -204,6 +223,7 @@ class AlphaAlongStrokeShader(CurveMappingModifier):
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
 
+
 class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
     def __init__(self, thickness_position, thickness_ratio,
                  blend, influence, mapping, invert, curve, value_min, value_max):
@@ -211,6 +231,7 @@ class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
         self.__value_min = value_min
         self.__value_max = value_max
+
     def shade(self, stroke):
         for it, t in iter_t2d_along_stroke(stroke):
             sv = it.object
@@ -219,13 +240,14 @@ class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
             c = self.blend_thickness(a[0], a[1], b)
             self.set_thickness(sv, c[0], c[1])
 
+
 # Distance from Camera modifiers
 
 def iter_distance_from_camera(stroke, range_min, range_max):
-    normfac = range_max - range_min # normalization factor
+    normfac = range_max - range_min  # normalization factor
     it = stroke.stroke_vertices_begin()
     while not it.is_end:
-        p = it.object.point_3d # in the camera coordinate
+        p = it.object.point_3d  # in the camera coordinate
         distance = p.length
         if distance < range_min:
             t = 0.0
@@ -236,11 +258,13 @@ def iter_distance_from_camera(stroke, range_min, range_max):
         yield it, t
         it.increment()
 
+
 class ColorDistanceFromCameraShader(ColorRampModifier):
     def __init__(self, blend, influence, ramp, range_min, range_max):
         ColorRampModifier.__init__(self, blend, influence, ramp)
         self.__range_min = range_min
         self.__range_max = range_max
+
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
             sv = it.object
@@ -248,11 +272,13 @@ class ColorDistanceFromCameraShader(ColorRampModifier):
             b = self.evaluate(t)
             sv.attribute.color = self.blend_ramp(a, b)
 
+
 class AlphaDistanceFromCameraShader(CurveMappingModifier):
     def __init__(self, blend, influence, mapping, invert, curve, range_min, range_max):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
         self.__range_min = range_min
         self.__range_max = range_max
+
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
             sv = it.object
@@ -260,6 +286,7 @@ class AlphaDistanceFromCameraShader(CurveMappingModifier):
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
 
+
 class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModifier):
     def __init__(self, thickness_position, thickness_ratio,
                  blend, influence, mapping, invert, curve, range_min, range_max, value_min, value_max):
@@ -269,6 +296,7 @@ class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModif
         self.__range_max = range_max
         self.__value_min = value_min
         self.__value_max = value_max
+
     def shade(self, stroke):
         for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
             sv = it.object
@@ -277,17 +305,18 @@ class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModif
             c = self.blend_thickness(a[0], a[1], b)
             self.set_thickness(sv, c[0], c[1])
 
+
 # Distance from Object modifiers
 
 def iter_distance_from_object(stroke, object, range_min, range_max):
     scene = freestyle.getCurrentScene()
-    mv = scene.camera.matrix_world.copy() # model-view matrix
+    mv = scene.camera.matrix_world.copy()  # model-view matrix
     mv.invert()
-    loc = mv * object.location # loc in the camera coordinate
+    loc = mv * object.location  # loc in the camera coordinate
-    normfac = range_max - range_min # normalization factor
+    normfac = range_max - range_min  # normalization factor
     it = stroke.stroke_vertices_begin()
     while not it.is_end:
-        p = it.object.point_3d # in the camera coordinate
+        p = it.object.point_3d  # in the camera coordinate
         distance = (p - loc).length
         if distance < range_min:
             t = 0.0
@@ -298,12 +327,14 @@ def iter_distance_from_object(stroke, object, range_min, range_max):
         yield it, t
         it.increment()
 
+
 class ColorDistanceFromObjectShader(ColorRampModifier):
     def __init__(self, blend, influence, ramp, target, range_min, range_max):
         ColorRampModifier.__init__(self, blend, influence, ramp)
         self.__target = target
         self.__range_min = range_min
         self.__range_max = range_max
+
     def shade(self, stroke):
         if self.__target is None:
             return
@@ -313,12 +344,14 @@ class ColorDistanceFromObjectShader(ColorRampModifier):
             b = self.evaluate(t)
             sv.attribute.color = self.blend_ramp(a, b)
 
+
 class AlphaDistanceFromObjectShader(CurveMappingModifier):
     def __init__(self, blend, influence, mapping, invert, curve, target, range_min, range_max):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
         self.__target = target
         self.__range_min = range_min
         self.__range_max = range_max
+
     def shade(self, stroke):
         if self.__target is None:
             return
@@ -328,6 +361,7 @@ class AlphaDistanceFromObjectShader(CurveMappingModifier):
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
 
+
 class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModifier):
     def __init__(self, thickness_position, thickness_ratio,
                  blend, influence, mapping, invert, curve, target, range_min, range_max, value_min, value_max):
@@ -338,6 +372,7 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
         self.__range_max = range_max
         self.__value_min = value_min
         self.__value_max = value_max
+
     def shade(self, stroke):
         if self.__target is None:
             return
@@ -348,6 +383,7 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
             c = self.blend_thickness(a[0], a[1], b)
             self.set_thickness(sv, c[0], c[1])
 
+
 # Material modifiers
 
 def iter_material_color(stroke, material_attribute):
@@ -364,6 +400,7 @@ def iter_material_color(stroke, material_attribute):
         yield it, color
         it.increment()
 
+
 def iter_material_value(stroke, material_attribute):
     func = CurveMaterialF0D()
     it = stroke.stroke_vertices_begin()
@@ -396,11 +433,13 @@ def iter_material_value(stroke, material_attribute):
         yield it, t
         it.increment()
 
+
 class ColorMaterialShader(ColorRampModifier):
     def __init__(self, blend, influence, ramp, material_attribute, use_ramp):
         ColorRampModifier.__init__(self, blend, influence, ramp)
         self.__material_attribute = material_attribute
         self.__use_ramp = use_ramp
+
     def shade(self, stroke):
         if self.__material_attribute in {'DIFF', 'SPEC'} and not self.__use_ramp:
             for it, b in iter_material_color(stroke, self.__material_attribute):
@@ -414,10 +453,12 @@ class ColorMaterialShader(ColorRampModifier):
                 b = self.evaluate(t)
                 sv.attribute.color = self.blend_ramp(a, b)
 
+
 class AlphaMaterialShader(CurveMappingModifier):
     def __init__(self, blend, influence, mapping, invert, curve, material_attribute):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
         self.__material_attribute = material_attribute
+
     def shade(self, stroke):
         for it, t in iter_material_value(stroke, self.__material_attribute):
             sv = it.object
@@ -425,6 +466,7 @@ class AlphaMaterialShader(CurveMappingModifier):
             b = self.evaluate(t)
             sv.attribute.alpha = self.blend(a, b)
 
+
 class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
     def __init__(self, thickness_position, thickness_ratio,
                  blend, influence, mapping, invert, curve, material_attribute, value_min, value_max):
@@ -433,6 +475,7 @@ class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
         self.__material_attribute = material_attribute
         self.__value_min = value_min
         self.__value_max = value_max
+
     def shade(self, stroke):
         for it, t in iter_material_value(stroke, self.__material_attribute):
             sv = it.object
@@ -441,6 +484,7 @@ class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
             c = self.blend_thickness(a[0], a[1], b)
             self.set_thickness(sv, c[0], c[1])
 
+
 # Calligraphic thickness modifier
 
 class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
@@ -451,6 +495,7 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
         self.__orientation = mathutils.Vector((math.cos(orientation), math.sin(orientation)))
         self.__thickness_min = thickness_min
         self.__thickness_max = thickness_max
+
     def shade(self, stroke):
         func = VertexOrientation2DF0D()
         it = stroke.stroke_vertices_begin()
@@ -467,6 +512,7 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
             self.set_thickness(sv, c[0], c[1])
             it.increment()
 
+
 # Geometry modifiers
 
 def iter_distance_along_stroke(stroke):
@@ -476,10 +522,11 @@ def iter_distance_along_stroke(stroke):
     while not it.is_end:
         p = it.object.point
         distance += (prev - p).length
-        prev = p.copy() # need a copy because the point can be altered
+        prev = p.copy()  # need a copy because the point can be altered
         yield it, distance
         it.increment()
 
+
 class SinusDisplacementShader(StrokeShader):
     def __init__(self, wavelength, amplitude, phase):
         StrokeShader.__init__(self)
@@ -487,6 +534,7 @@ class SinusDisplacementShader(StrokeShader):
         self._amplitude = amplitude
         self._phase = phase / wavelength * 2 * math.pi
         self._getNormal = Normal2DF0D()
+
     def shade(self, stroke):
         for it, distance in iter_distance_along_stroke(stroke):
             v = it.object
@@ -495,14 +543,16 @@ class SinusDisplacementShader(StrokeShader):
             v.point = v.point + n
         stroke.update_length()
 
+
 class PerlinNoise1DShader(StrokeShader):
-    def __init__(self, freq = 10, amp = 10, oct = 4, angle = math.radians(45), seed = -1):
+    def __init__(self, freq=10, amp=10, oct=4, angle=math.radians(45), seed=-1):
         StrokeShader.__init__(self)
         self.__noise = Noise(seed)
         self.__freq = freq
         self.__amp = amp
         self.__oct = oct
-        self.__dir = mathutils.Vector([math.cos(angle), math.sin(angle)])
+        self.__dir = mathutils.Vector((math.cos(angle), math.sin(angle)))
+
     def shade(self, stroke):
         length = stroke.length_2d
         it = stroke.stroke_vertices_begin()
@@ -513,31 +563,35 @@ class PerlinNoise1DShader(StrokeShader):
             it.increment()
         stroke.update_length()
 
+
 class PerlinNoise2DShader(StrokeShader):
-    def __init__(self, freq = 10, amp = 10, oct = 4, angle = math.radians(45), seed = -1):
+    def __init__(self, freq=10, amp=10, oct=4, angle=math.radians(45), seed=-1):
         StrokeShader.__init__(self)
         self.__noise = Noise(seed)
         self.__freq = freq
         self.__amp = amp
         self.__oct = oct
-        self.__dir = mathutils.Vector([math.cos(angle), math.sin(angle)])
+        self.__dir = mathutils.Vector((math.cos(angle), math.sin(angle)))
+
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
         while not it.is_end:
             v = it.object
-            vec = mathutils.Vector([v.projected_x, v.projected_y])
+            vec = mathutils.Vector((v.projected_x, v.projected_y))
             nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
             v.point = v.point + nres * self.__dir
             it.increment()
         stroke.update_length()
 
+
 class Offset2DShader(StrokeShader):
     def __init__(self, start, end, x, y):
         StrokeShader.__init__(self)
         self.__start = start
         self.__end = end
-        self.__xy = mathutils.Vector([x, y])
+        self.__xy = mathutils.Vector((x, y))
         self.__getNormal = Normal2DF0D()
+
     def shade(self, stroke):
         it = stroke.stroke_vertices_begin()
         while not it.is_end:
@@ -550,6 +604,7 @@ class Offset2DShader(StrokeShader):
             it.increment()
         stroke.update_length()
 
+
 class Transform2DShader(StrokeShader):
     def __init__(self, pivot, scale_x, scale_y, angle, pivot_u, pivot_x, pivot_y):
         StrokeShader.__init__(self)
@@ -560,6 +615,7 @@ class Transform2DShader(StrokeShader):
         self.__pivot_u = pivot_u
         self.__pivot_x = pivot_x
         self.__pivot_y = pivot_y
+
     def shade(self, stroke):
         # determine the pivot of scaling and rotation operations
         if self.__pivot == 'START':
@@ -586,18 +642,18 @@ class Transform2DShader(StrokeShader):
                 delta = u - self.__pivot_u
                 pivot = p + delta * (prev - p)
         elif self.__pivot == 'CENTER':
-            pivot = mathutils.Vector([0.0, 0.0])
+            pivot = mathutils.Vector((0.0, 0.0))
             n = 0
             it = stroke.stroke_vertices_begin()
             while not it.is_end:
                 p = it.object.point
                 pivot = pivot + p
-                n = n + 1
+                n += 1
                 it.increment()
             pivot.x = pivot.x / n
             pivot.y = pivot.y / n
         elif self.__pivot == 'ABSOLUTE':
-            pivot = mathutils.Vector([self.__pivot_x, self.__pivot_y])
+            pivot = mathutils.Vector((self.__pivot_x, self.__pivot_y))
         # apply scaling and rotation operations
         cos_theta = math.cos(self.__angle)
         sin_theta = math.sin(self.__angle)
@@ -614,6 +670,7 @@ class Transform2DShader(StrokeShader):
             it.increment()
         stroke.update_length()
 
+
 # Predicates and helper functions
 
 class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D):
@@ -622,10 +679,12 @@ class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D):
         self.__getQI = QuantitativeInvisibilityF1D()
         self.__qi_start = qi_start
         self.__qi_end = qi_end
+
     def __call__(self, inter):
         qi = self.__getQI(inter)
         return self.__qi_start <= qi <= self.__qi_end
 
+
 def join_unary_predicates(upred_list, bpred):
     if not upred_list:
         return None
@@ -634,17 +693,20 @@ def join_unary_predicates(upred_list, bpred):
         upred = bpred(upred, p)
     return upred
 
+
 class ObjectNamesUP1D(UnaryPredicate1D):
     def __init__(self, names, negative):
         UnaryPredicate1D.__init__(self)
         self._names = names
         self._negative = negative
+
     def __call__(self, viewEdge):
         found = viewEdge.viewshape.name in self._names
         if self._negative:
             return not found
         return found
 
+
 # Stroke caps
 
 def iter_stroke_vertices(stroke):
@@ -658,10 +720,12 @@ def iter_stroke_vertices(stroke):
             prev_p = p.copy()
         it.increment()
 
+
 class RoundCapShader(StrokeShader):
     def round_cap_thickness(self, x):
         x = max(0.0, min(x, 1.0))
-        return math.sqrt(1.0 - (x ** 2))
+        return math.sqrt(1.0 - (x ** 2.0))
+
     def shade(self, stroke):
         # save the location and attribute of stroke vertices
         buffer = []
@@ -706,13 +770,14 @@ class RoundCapShader(StrokeShader):
         R, L = attr.thickness
         for i in range(nverts_end):
             t = (nverts_end - i) * n
-            stroke[-i-1].point = p + d * t
+            stroke[-i - 1].point = p + d * t
             r = self.round_cap_thickness((nverts_end - i + 1) * n)
-            stroke[-i-1].attribute = attr
+            stroke[-i - 1].attribute = attr
-            stroke[-i-1].attribute.thickness = (R * r, L * r)
+            stroke[-i - 1].attribute.thickness = (R * r, L * r)
         # update the curvilinear 2D length of each vertex
         stroke.update_length()
 
+
 class SquareCapShader(StrokeShader):
     def shade(self, stroke):
         # save the location and attribute of stroke vertices
@@ -751,35 +816,42 @@ class SquareCapShader(StrokeShader):
         # update the curvilinear 2D length of each vertex
         stroke.update_length()
 
+
 # Split by dashed line pattern
 
 class SplitPatternStartingUP0D(UnaryPredicate0D):
     def __init__(self, controller):
         UnaryPredicate0D.__init__(self)
         self._controller = controller
+
     def __call__(self, inter):
         return self._controller.start()
 
+
 class SplitPatternStoppingUP0D(UnaryPredicate0D):
     def __init__(self, controller):
         UnaryPredicate0D.__init__(self)
         self._controller = controller
+
     def __call__(self, inter):
         return self._controller.stop()
 
+
 class SplitPatternController:
     def __init__(self, pattern, sampling):
         self.sampling = float(sampling)
         k = len(pattern) // 2
         n = k * 2
-        self.start_pos = [pattern[i] + pattern[i+1] for i in range(0, n, 2)]
+        self.start_pos = [pattern[i] + pattern[i + 1] for i in range(0, n, 2)]
         self.stop_pos = [pattern[i] for i in range(0, n, 2)]
         self.init()
+
     def init(self):
         self.start_len = 0.0
         self.start_idx = 0
         self.stop_len = self.sampling
         self.stop_idx = 0
+
     def start(self):
         self.start_len += self.sampling
         if abs(self.start_len - self.start_pos[self.start_idx]) < self.sampling / 2.0:
@@ -787,6 +859,7 @@ class SplitPatternController:
             self.start_idx = (self.start_idx + 1) % len(self.start_pos)
             return True
         return False
+
     def stop(self):
         if self.start_len > 0.0:
             self.init()
@@ -797,20 +870,22 @@ class SplitPatternController:
             return True
         return False
 
+
 # Dashed line
 
 class DashedLineShader(StrokeShader):
     def __init__(self, pattern):
         StrokeShader.__init__(self)
         self._pattern = pattern
+
     def shade(self, stroke):
-        index = 0 # pattern index
+        index = 0  # pattern index
-        start = 0.0 # 2D curvilinear length
+        start = 0.0  # 2D curvilinear length
         visible = True
         sampling = 1.0
         it = stroke.stroke_vertices_begin(sampling)
         while not it.is_end:
-            pos = it.t # curvilinear abscissa
+            pos = it.t  # curvilinear abscissa
             # The extra 'sampling' term is added below, because the
             # visibility attribute of the i-th vertex refers to the
             # visibility of the stroke segment between the i-th and
@@ -824,12 +899,14 @@ class DashedLineShader(StrokeShader):
             it.object.attribute.visible = visible
             it.increment()
 
+
 # predicates for chaining
 
 class AngleLargerThanBP1D(BinaryPredicate1D):
     def __init__(self, angle):
         BinaryPredicate1D.__init__(self)
         self._angle = angle
+
     def __call__(self, i1, i2):
         sv1a = i1.first_fedge.first_svertex.point_2d
         sv1b = i1.last_fedge.second_svertex.point_2d
@@ -855,14 +932,17 @@ class AngleLargerThanBP1D(BinaryPredicate1D):
         x = (dir1 * dir2) / denom
         return math.acos(min(max(x, -1.0), 1.0)) > self._angle
 
+
 class AndBP1D(BinaryPredicate1D):
     def __init__(self, pred1, pred2):
         BinaryPredicate1D.__init__(self)
         self.__pred1 = pred1
         self.__pred2 = pred2
+
     def __call__(self, i1, i2):
         return self.__pred1(i1, i2) and self.__pred2(i1, i2)
 
+
 # predicates for selection
 
 class LengthThresholdUP1D(UnaryPredicate1D):
@@ -870,6 +950,7 @@ class LengthThresholdUP1D(UnaryPredicate1D):
         UnaryPredicate1D.__init__(self)
         self._length_min = length_min
         self._length_max = length_max
+
     def __call__(self, inter):
         length = inter.length_2d
         if self._length_min is not None and length < self._length_min:
@@ -878,8 +959,9 @@ class LengthThresholdUP1D(UnaryPredicate1D):
             return False
         return True
 
+
 class FaceMarkBothUP1D(UnaryPredicate1D):
-    def __call__(self, inter): # ViewEdge
+    def __call__(self, inter):  # ViewEdge
         fe = inter.first_fedge
         while fe is not None:
             if fe.is_smooth:
@@ -894,8 +976,9 @@ class FaceMarkBothUP1D(UnaryPredicate1D):
             fe = fe.next_fedge
         return False
 
+
 class FaceMarkOneUP1D(UnaryPredicate1D):
-    def __call__(self, inter): # ViewEdge
+    def __call__(self, inter):  # ViewEdge
         fe = inter.first_fedge
         while fe is not None:
             if fe.is_smooth:
@@ -910,13 +993,14 @@ class FaceMarkOneUP1D(UnaryPredicate1D):
             fe = fe.next_fedge
         return False
 
+
 # predicates for splitting
 
 class MaterialBoundaryUP0D(UnaryPredicate0D):
     def __call__(self, it):
         if it.is_begin:
             return False
-        it_prev = Interface0DIterator(it) 
+        it_prev = Interface0DIterator(it)
         it_prev.decrement()
         v = it.object
         it.increment()
@@ -928,12 +1012,14 @@ class MaterialBoundaryUP0D(UnaryPredicate0D):
         idx2 = fe.material_index if fe.is_smooth else fe.material_index_left
         return idx1 != idx2
 
+
 class Curvature2DAngleThresholdUP0D(UnaryPredicate0D):
     def __init__(self, angle_min=None, angle_max=None):
         UnaryPredicate0D.__init__(self)
         self._angle_min = angle_min
         self._angle_max = angle_max
         self._func = Curvature2DAngleF0D()
+
     def __call__(self, inter):
         angle = math.pi - self._func(inter)
         if self._angle_min is not None and angle < self._angle_min:
@@ -942,13 +1028,15 @@ class Curvature2DAngleThresholdUP0D(UnaryPredicate0D):
             return True
         return False
 
+
 class Length2DThresholdUP0D(UnaryPredicate0D):
     def __init__(self, length_limit):
         UnaryPredicate0D.__init__(self)
         self._length_limit = length_limit
         self._t = 0.0
+
     def __call__(self, inter):
-        t = inter.t # curvilinear abscissa
+        t = inter.t  # curvilinear abscissa
         if t < self._t:
             self._t = 0.0
             return False
@@ -957,12 +1045,14 @@ class Length2DThresholdUP0D(UnaryPredicate0D):
         self._t = t
         return True
 
+
 # Seed for random number generation
 
 class Seed:
     def __init__(self):
         self.t_max = 2 ** 15
         self.t = int(time.time()) % self.t_max
+
     def get(self, seed):
         if seed < 0:
             self.t = (self.t + 1) % self.t_max
@@ -973,6 +1063,7 @@ _seed = Seed()
 
 ### T.K. 07-Aug-2013 Temporary fix for unexpected line gaps
 
+
 def iter_three_segments(stroke):
     n = stroke.stroke_vertices_size()
     if n >= 4:
@@ -993,13 +1084,14 @@ def iter_three_segments(stroke):
             it3.increment()
             it4.increment()
 
+
 class StrokeCleaner(StrokeShader):
     def shade(self, stroke):
         for sv1, sv2, sv3, sv4 in iter_three_segments(stroke):
             seg1 = sv2.point - sv1.point
             seg2 = sv3.point - sv2.point
             seg3 = sv4.point - sv3.point
-            if seg1.dot(seg2) < 0 and seg2.dot(seg3) < 0:
+            if seg1.dot(seg2) < 0.0 and seg2.dot(seg3) < 0.0:
                 print(sv2.first_svertex.viewvertex)
                 print(sv2.second_svertex.viewvertex)
                 print(sv3.first_svertex.viewvertex)
@@ -1009,6 +1101,7 @@ class StrokeCleaner(StrokeShader):
                 sv2.point = p3
                 sv3.point = p2
 
+
 # main function for parameter processing
 
 def process(layer_name, lineset_name):