mesh_edge_roundifier: update correct 279 version from mesh extra tools to 2.8
authormeta-androcto <meta.androcto1@gmail.com>
Sun, 2 Jun 2019 04:10:41 +0000 (14:10 +1000)
committermeta-androcto <meta.androcto1@gmail.com>
Sun, 2 Jun 2019 04:10:41 +0000 (14:10 +1000)
mesh_tools/mesh_edge_roundifier.py

index dce883a..704a260 100644 (file)
@@ -1,71 +1,59 @@
-# ***** BEGIN GPL LICENSE BLOCK *****
+# ##### BEGIN GPL LICENSE BLOCK #####
 #
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
 #
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
 #
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
-# GNU General Public License for more details.
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ***** END GPL LICENCE BLOCK *****
+# ##### END GPL LICENSE BLOCK #####
 
 bl_info = {
     "name": "Edge Roundifier",
     "category": "Mesh",
-    'author': 'Piotr Komisarczyk (komi3D), PKHG, ported to 2.8 by Titus',
-    'version': (1, 0, 1),
-    'blender': (2, 80, 0),
-    'location': 'SPACE > Edge Roundifier or CTRL-E > Edge Roundifier or Tools > Addons > Edge Roundifier',
-    'description': 'Mesh editing script allowing edge rounding',
-    'wiki_url': '',
-    'tracker_url': '',
-    'category': 'Mesh'
+    "author": "Piotr Komisarczyk (komi3D), PKHG",
+    "version": (1, 0, 2),
+    "blender": (2, 80, 0),
+    "location": "SPACE > Edge Roundifier or CTRL-E > "
+                "Edge Roundifier or Tools > Addons > Edge Roundifier",
+    "description": "Mesh editing script allowing edge rounding",
+    "wiki_url": "",
+    "category": "Mesh"
 }
 
-import bmesh
 import bpy
-import bpy.props
-import imp
-from math import sqrt, acos, asin, pi, radians, degrees, sin, acos
-from mathutils import Vector, Euler, Matrix, Quaternion
-import types
-
+import bmesh
+from bpy.types import Operator
+from bpy.props import (
+        BoolProperty,
+        FloatProperty,
+        EnumProperty,
+        IntProperty,
+        )
+from math import (
+        sqrt, acos, pi,
+        radians, degrees, sin,
+        )
+from mathutils import (
+        Vector, Euler,
+        Quaternion,
+        )
 
 # CONSTANTS
-two_pi = 2 * pi #PKHG>??? maybe other constantly used values too???
+two_pi = 2 * pi
 XY = "XY"
 XZ = "XZ"
 YZ = "YZ"
 SPIN_END_THRESHOLD = 0.001
 LINE_TOLERANCE = 0.0001
-
-
-# variable controlling all print functions
-#PKHG>??? to be replaced, see debugPrintNew ;-)
-debug = True
-
-def debugPrint(*text):
-    if debug:
-        for t in text:
-            print(text)
-
-
-
-############# for debugging PKHG ################
-def debugPrintNew(debug,*text):
-    if debug:
-        tmp = [el for el in text]
-        for row in tmp:
-            print(row)
-
 d_XABS_YABS = False
 d_Edge_Info = False
 d_Plane = False
@@ -76,28 +64,39 @@ d_LineAB = False
 d_Selected_edges = False
 d_Rotate_Around_Spin_Center = False
 
+# Enable debug prints
+DEBUG = False
+
+
+# for debugging PKHG #
+def debugPrintNew(debugs, *text):
+    if DEBUG and debugs:
+        tmp = [el for el in text]
+        for row in tmp:
+            print(row)
 
 
-####################### Geometry and math calcualtion methods #####################
+# Geometry and math calculation methods #
 
 class CalculationHelper:
+
     def __init__(self):
-        '''
+        """
         Constructor
-        '''
+        """
     def getLineCoefficientsPerpendicularToVectorInPoint(self, point, vector, plane):
         x, y, z = point
         xVector, yVector, zVector = vector
         destinationPoint = (x + yVector, y - xVector, z)
         if plane == 'YZ':
-            destinationPoint = (x , y + zVector, z - yVector)
+            destinationPoint = (x, y + zVector, z - yVector)
         if plane == 'XZ':
             destinationPoint = (x + zVector, y, z - xVector)
         return self.getCoefficientsForLineThrough2Points(point, destinationPoint, plane)
 
     def getQuadraticRoots(self, coef):
         if len(coef) != 3:
-            return NaN
+            return None  # Replaced NaN with None
         else:
             a, b, c = coef
             delta = b ** 2 - 4 * a * c
@@ -106,7 +105,7 @@ class CalculationHelper:
                 return (x, x)
             elif delta < 0:
                 return None
-            else :
+            else:
                 x1 = (-b - sqrt(delta)) / (2 * a)
                 x2 = (-b + sqrt(delta)) / (2 * a)
                 return (x1, x2)
@@ -127,8 +126,8 @@ class CalculationHelper:
 
         # Further calculations the same as for XY plane
         xabs = abs(x2 - x1)
-        yabs = abs(y2 - y1) 
-        debugPrintNew(d_XABS_YABS, "XABS = " + str( xabs)+ " YABS = " + str(yabs))
+        yabs = abs(y2 - y1)
+        debugPrintNew(d_XABS_YABS, "XABS = " + str(xabs) + " YABS = " + str(yabs))
 
         if xabs <= LINE_TOLERANCE:
             return None  # this means line x = edgeCenterX
@@ -151,7 +150,7 @@ class CalculationHelper:
         h = (B ** 2) - 2 * b * B - (radius ** 2) + (a ** 2) + (b ** 2)
         coef = [f, g, h]
         roots = self.getQuadraticRoots(coef)
-        if roots != None:
+        if roots is not None:
             x1 = roots[0]
             x2 = roots[1]
             point1 = [x1, A * x1 + B]
@@ -160,7 +159,8 @@ class CalculationHelper:
         else:
             return None
 
-    def getLineCircleIntersectionsWhenXPerpendicular(self, edgeCenter, circleMidPoint, radius, plane):
+    def getLineCircleIntersectionsWhenXPerpendicular(self, edgeCenter,
+                                                     circleMidPoint, radius, plane):
         # (x - a)**2 + (y - b)**2 = r**2 - circle equation
         # x = xValue - line equation
         # f * x**2 + g * x + h = 0 - quadratic equation
@@ -176,7 +176,7 @@ class CalculationHelper:
         h = (a ** 2) + (b ** 2) + (xValue ** 2) - 2 * a * xValue - (radius ** 2)
         coef = [f, g, h]
         roots = self.getQuadraticRoots(coef)
-        if roots != None:
+        if roots is not None:
             y1 = roots[0]
             y2 = roots[1]
             point1 = [xValue, y1]
@@ -190,17 +190,17 @@ class CalculationHelper:
         distance1 = (Vector(point1) - Vector(point2)).length
         distance2 = (Vector(point2) - Vector(point3)).length
         cos = distance1 / distance2
-        
+
         if abs(cos) > 1:  # prevents Domain Error
             cos = round(cos)
-        
+
         alpha = acos(cos)
         return (alpha, degrees(alpha))
 
     # get two of three coordinates used for further calculation of spin center
-    #PKHG>nice if rescriction to these 3 types or planes is to be done
-    #komi3D> from 0.0.2 there is a restriction. In future I would like Edge Roundifier to work on
-    #komi3D> Normal and View coordinate systems. That would be great... 
+    # PKHG>nice if rescriction to these 3 types or planes is to be done
+    # komi3D> from 0.0.2 there is a restriction. In future I would like Edge
+    # komi3D> Roundifier to work on Normal and View coordinate systems
     def getCircleMidPointOnPlane(self, V1, plane):
         X = V1[0]
         Y = V1[1]
@@ -211,7 +211,6 @@ class CalculationHelper:
             X = V1[1]
             Y = V1[2]
         return [X, Y]
-        
 
     def getEdgeReference(self, edge, edgeCenter, plane):
         vert1 = edge.verts[1].co
@@ -223,155 +222,280 @@ class CalculationHelper:
             orthoVector = Vector((V[0], V[2], -V[1]))
         refPoint = edgeCenter + orthoVector
         return refPoint
-        
-        
-########################################################
-################# SELECTION METHODS ####################
+
+
+# Selection Methods #
 
 class SelectionHelper:
+
     def selectVertexInMesh(self, mesh, vertex):
-        bpy.ops.object.mode_set(mode = "OBJECT")
+        bpy.ops.object.mode_set(mode="OBJECT")
         for v in mesh.vertices:
             if v.co == vertex:
                 v.select = True
                 break
 
-        bpy.ops.object.mode_set(mode = "EDIT")
+        bpy.ops.object.mode_set(mode="EDIT")
 
     def getSelectedVertex(self, mesh):
-        bpy.ops.object.mode_set(mode = "OBJECT")
+        bpy.ops.object.mode_set(mode="OBJECT")
         for v in mesh.vertices:
-            if v.select == True :
-                bpy.ops.object.mode_set(mode = "EDIT")
+            if v.select is True:
+                bpy.ops.object.mode_set(mode="EDIT")
                 return v
 
-        bpy.ops.object.mode_set(mode = "EDIT")
+        bpy.ops.object.mode_set(mode="EDIT")
         return None
 
     def refreshMesh(self, bm, mesh):
-        bpy.ops.object.mode_set(mode = 'OBJECT')
+        bpy.ops.object.mode_set(mode='OBJECT')
         bm.to_mesh(mesh)
-        bpy.ops.object.mode_set(mode = 'EDIT')
-
+        bpy.ops.object.mode_set(mode='EDIT')
 
 
-###################################################################################
+# Operator
 
-class EdgeRoundifier(bpy.types.Operator):
-    """Edge Roundifier"""  # blender will use this as a tooltip for menu items and buttons.
-    bl_idname = "mesh.edge_roundifier"  # unique identifier for buttons and menu items to reference.
-    bl_label = "Edge Roundifier"  # display name in the interface.
-    bl_options = {'REGISTER', 'UNDO', 'PRESET'}  # enable undo for the operator.PKHG>INFO and PRESET
+class EdgeRoundifier(Operator):
+    bl_idname = "mesh.edge_roundifier"
+    bl_label = "Edge Roundifier"
+    bl_description = "Mesh modeling tool for building arcs on selected Edges"
+    bl_options = {'REGISTER', 'UNDO', 'PRESET'}
 
     threshold = 0.0005
-    
     obj = None
 
-    edgeScaleFactor : bpy.props.FloatProperty(name = '', default = 1.0, min = 0.00001, max = 100000.0, step = 0.5, precision = 5)
-    r : bpy.props.FloatProperty(name = '', default = 1, min = 0.00001, max = 1000.0, step = 0.1, precision = 3)
-    a : bpy.props.FloatProperty(name = '', default = 180.0, min = 0.1, max = 180.0, step = 0.5, precision = 1)
-    n : bpy.props.IntProperty(name = '', default = 4, min = 1, max = 100, step = 1)
-    flip : bpy.props.BoolProperty(name = 'Flip', default = False)
-    
-    invertAngle : bpy.props.BoolProperty(name = 'Invert', default = False)
-    fullCircles : bpy.props.BoolProperty(name = 'Circles', default = False)
-    bothSides : bpy.props.BoolProperty(name = 'Both sides', default = False)
-    
-    drawArcCenters : bpy.props.BoolProperty(name = 'Centers', default = False)
-    removeEdges : bpy.props.BoolProperty(name = 'Edges', default = False)
-    removeScaledEdges : bpy.props.BoolProperty(name = 'Scaled edges', default = False)
-    
-    connectArcWithEdge : bpy.props.BoolProperty(name = 'Arc - Edge', default = False)
-    connectArcs : bpy.props.BoolProperty(name = 'Arcs', default = False)
-    connectScaledAndBase : bpy.props.BoolProperty(name = 'Scaled - Base Edge', default = False)
-    connectArcsFlip : bpy.props.BoolProperty(name = 'Flip Arcs', default = False)
-    connectArcWithEdgeFlip : bpy.props.BoolProperty(name = 'Flip Arc - Edge', default = False)
-    
-    
-    axisAngle : bpy.props.FloatProperty(name = '', default = 0.0, min = -180.0, max = 180.0, step = 0.5, precision = 1)
-    edgeAngle : bpy.props.FloatProperty(name = '', default = 0.0, min = -180.0, max = 180.0, step = 0.5, precision = 1)
-    offset : bpy.props.FloatProperty(name = '', default = 0.0, min = -1000000.0, max = 1000000.0, step = 0.1, precision = 5)
-    offset2 : bpy.props.FloatProperty(name = '', default = 0.0, min = -1000000.0, max = 1000000.0, step = 0.1, precision = 5)
-    ellipticFactor : bpy.props.FloatProperty(name = '', default = 0.0, min = -1000000.0, max = 1000000.0, step = 0.1, precision = 5)
-    
-    
+    edgeScaleFactor: FloatProperty(
+            name="",
+            description="Set the Factor of scaling",
+            default=1.0,
+            min=0.00001, max=100000.0,
+            step=0.5,
+            precision=5
+            )
+    r: FloatProperty(
+            name="",
+            description="User Defined arc steepness by a Radius\n"
+                        "Enabled only if Entry mode is set to Radius\n",
+            default=1,
+            min=0.00001, max=1000.0,
+            step=0.1,
+            precision=3
+            )
+    a: FloatProperty(
+            name="",
+            description="User defined arc steepness calculated from an Angle\n"
+                        "Enabled only if Entry mode is set to Angle and\n"
+                        "Angle presets is set Other",
+            default=180.0,
+            min=0.1, max=180.0,
+            step=0.5,
+            precision=1
+            )
+    n: IntProperty(
+            name="",
+            description="Arc subdivision level",
+            default=4,
+            min=1, max=100,
+            step=1
+            )
+    flip: BoolProperty(
+            name="Flip",
+            description="If True, flip the side of the selected edges where the arcs are drawn",
+            default=False
+            )
+    invertAngle: BoolProperty(
+            name="Invert",
+            description="If True, uses an inverted angle to draw the arc (360 degrees - angle)",
+            default=False
+            )
+    fullCircles: BoolProperty(
+            name="Circles",
+            description="If True, uses an angle of 360 degrees to draw the arcs",
+            default=False
+            )
+    bothSides: BoolProperty(
+            name="Both sides",
+            description="If True, draw arcs on both sides of the selected edges",
+            default=False
+            )
+    drawArcCenters: BoolProperty(
+            name="Centers",
+            description="If True, draws a vertex for each spin center",
+            default=False
+            )
+    removeEdges: BoolProperty(
+            name="Edges",
+            description="If True removes the Original selected edges",
+            default=False
+            )
+    removeScaledEdges: BoolProperty(
+            name="Scaled edges",
+            description="If True removes the Scaled edges (not part of the arcs)",
+            default=False
+            )
+    connectArcWithEdge: BoolProperty(
+            name="Arc - Edge",
+            description="Connect Arcs to Edges",
+            default=False
+            )
+    connectArcs: BoolProperty(
+            name="Arcs",
+            description="Connect subsequent Arcs",
+            default=False
+            )
+    connectScaledAndBase: BoolProperty(
+            name="Scaled - Base Edge",
+            description="Connect Scaled to Base Edge",
+            default=False
+            )
+    connectArcsFlip: BoolProperty(
+            name="Flip Arcs",
+            description="Flip the connection of subsequent Arcs",
+            default=False
+            )
+    connectArcWithEdgeFlip: BoolProperty(
+            name="Flip Arc - Edge",
+            description="Flip the connection of the Arcs to Edges",
+            default=False
+            )
+    axisAngle: FloatProperty(
+            name="",
+            description="Rotate Arc around the perpendicular axis",
+            default=0.0,
+            min=-180.0, max=180.0,
+            step=0.5,
+            precision=1
+            )
+    edgeAngle: FloatProperty(
+            name="",
+            description="Rotate Arc around the Edge (Edge acts like as the axis)",
+            default=0.0,
+            min=-180.0, max=180.0,
+            step=0.5,
+            precision=1
+            )
+    offset: FloatProperty(
+            name="",
+            description="Offset Arc perpendicular the Edge",
+            default=0.0,
+            min=-1000000.0, max=1000000.0,
+            step=0.1,
+            precision=5
+            )
+    offset2: FloatProperty(
+            name="",
+            description="Offset Arc in parallel to the Edge",
+            default=0.0,
+            min=-1000000.0, max=1000000.0,
+            step=0.1,
+            precision=5
+            )
+    ellipticFactor: FloatProperty(
+            name="",
+            description="Make Arc elliptic",
+            default=0.0,
+            min=-1000000.0, max=1000000.0,
+            step=0.1,
+            precision=5
+            )
     workModeItems = [("Normal", "Normal", ""), ("Reset", "Reset", "")]
-    workMode : bpy.props.EnumProperty(
-        items = workModeItems,
-        name = '',
-        default = 'Normal',
-        description = "Edge Roundifier work mode")
-    
+    workMode: EnumProperty(
+            items=workModeItems,
+            name="",
+            default='Normal',
+            description="Normal work with the current given parameters set by the user\n"
+                        "Reset - changes back the parameters to their default values"
+            )
     entryModeItems = [("Radius", "Radius", ""), ("Angle", "Angle", "")]
-    entryMode : bpy.props.EnumProperty(
-        items = entryModeItems,
-        name = '',
-        default = 'Angle',
-        description = "Edge Roundifier entry mode")
-    
-    rotateCenterItems = [("Spin", "Spin", ""), ("V1", "V1", ""), ("Edge", "Edge", ""), ("V2", "V2", "")]
-    rotateCenter : bpy.props.EnumProperty(
-        items = rotateCenterItems,
-        name = '',
-        default = 'Edge',
-        description = "Rotate center for spin axis rotate")
-    
-    arcModeItems = [("FullEdgeArc","Full","Full"),('HalfEdgeArc',"Half","Half")]
-    arcMode : bpy.props.EnumProperty(
-        items = arcModeItems,
-        name = '',
-        default = 'FullEdgeArc',
-        description = "Edge Roundifier arc mode")
-    
-
-    angleItems = [('Other', "Other", "User defined angle"), ('180', "180", "HemiCircle"), ('120', "120", "TriangleCircle"),
-                    ('90', "90", "QuadCircle"), ('72', "72", "PentagonCircle"), ('60', "60", "HexagonCircle"), 
-                    ('45', "45", "OctagonCircle"), ('30', "30", "12-gonCircle")]
-
-    angleEnum : bpy.props.EnumProperty(
-        items = angleItems,
-        name = '',
-        default = '180',
-        description = "Presets prepare standard angles and calculate proper ray")
-
-    refItems = [('ORG', "Origin", "Use Origin Location"), ('CUR', "3D Cursor", "Use 3DCursor Location")
-                , ('EDG', "Edge", "Use Individual Edge Reference")]
-    referenceLocation : bpy.props.EnumProperty(
-        items = refItems,
-        name = '',
-        default = 'ORG',
-        description = "Reference location used by Edge Roundifier to calculate initial centers of drawn arcs")
-
-    planeItems = [(XY, XY, "XY Plane (Z=0)"), (YZ, YZ, "YZ Plane (X=0)"), (XZ, XZ, "XZ Plane (Y=0)")]
-    planeEnum : bpy.props.EnumProperty(
-        items = planeItems,
-        name = '',
-        default = 'XY',
-        description = "Plane used by Edge Roundifier to calculate spin plane of drawn arcs")
-
-    edgeScaleCenterItems = [('V1', "V1", "v1"), ('CENTER', "Center", "cent"), ('V2', "V2", "v2")]
-    edgeScaleCenterEnum : bpy.props.EnumProperty(
-        items = edgeScaleCenterItems,
-        name = 'edge scale center',
-        default = 'CENTER',
-        description = "Center used for scaling initial edge")
+    entryMode: EnumProperty(
+            items=entryModeItems,
+            name="",
+            default='Angle',
+            description="Entry mode switch between Angle and Radius\n"
+                        "If Angle is selected, arc radius is calculated from it"
+            )
+    rotateCenterItems = [
+            ("Spin", "Spin", ""), ("V1", "V1", ""),
+            ("Edge", "Edge", ""), ("V2", "V2", "")
+            ]
+    rotateCenter: EnumProperty(
+            items=rotateCenterItems,
+            name="",
+            default='Edge',
+            description="Rotate center for spin axis rotate"
+            )
+    arcModeItems = [("FullEdgeArc", "Full", "Full"), ('HalfEdgeArc', "Half", "Half")]
+    arcMode: EnumProperty(
+            items=arcModeItems,
+            name="",
+            default='FullEdgeArc',
+            description="Arc mode - switch between Full and Half arcs"
+            )
+    angleItems = [
+            ('Other', "Other", "User defined angle"), ('180', "180", "HemiCircle (2 sides)"),
+            ('120', "120", "TriangleCircle (3 sides)"), ('90', "90", "QuadCircle (4 sides)"),
+            ('72', "72", "PentagonCircle (5 sides)"), ('60', "60", "HexagonCircle (6 sides)"),
+            ('45', "45", "OctagonCircle (8 sides)"), ('30', "30", "DodecagonCircle (12 sides)")
+            ]
+    angleEnum: EnumProperty(
+            items=angleItems,
+            name="",
+            default='180',
+            description="Presets prepare standard angles and calculate proper ray"
+            )
+    refItems = [('ORG', "Origin", "Use Origin Location"), ('CUR', "3D Cursor", "Use 3DCursor Location"),
+                ('EDG', "Edge", "Use Individual Edge Reference")]
+    referenceLocation: EnumProperty(
+            items=refItems,
+            name="",
+            default='ORG',
+            description="Reference location used to calculate initial centers of drawn arcs"
+            )
+    planeItems = [
+            (XY, "XY", "XY Plane (Z=0)"),
+            (YZ, "YZ", "YZ Plane (X=0)"),
+            (XZ, "XZ", "XZ Plane (Y=0)")
+            ]
+    planeEnum: EnumProperty(
+            items=planeItems,
+            name="",
+            default='XY',
+            description="Plane used to calculate spin plane of drawn arcs"
+            )
+    edgeScaleCenterItems = [
+            ('V1', "V1", "v1 - First Edge's Vertex"),
+            ('CENTER', "Center", "Center of the Edge"),
+            ('V2', "V2", "v2 - Second Edge's Vertex")
+            ]
+    edgeScaleCenterEnum: EnumProperty(
+            items=edgeScaleCenterItems,
+            name="Edge scale center",
+            default='CENTER',
+            description="Center used for scaling the initial edge"
+            )
 
     calc = CalculationHelper()
     sel = SelectionHelper()
-    
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return (obj and obj.type == 'MESH' and
+                obj.mode == 'EDIT')
+
     def prepareMesh(self, context):
-        bpy.ops.object.mode_set(mode = 'OBJECT')
-        bpy.ops.object.mode_set(mode = 'EDIT')
+        bpy.ops.object.mode_set(mode='OBJECT')
+        bpy.ops.object.mode_set(mode='EDIT')
 
         mesh = context.view_layer.objects.active.data
         bm = bmesh.new()
         bm.from_mesh(mesh)
-        
+
         edges = [ele for ele in bm.edges if ele.select]
         return edges, mesh, bm
 
     def prepareParameters(self):
-        parameters = { "a" : "a"}
+        parameters = {"a": "a"}
         parameters["arcMode"] = self.arcMode
         parameters["edgeScaleFactor"] = self.edgeScaleFactor
         parameters["edgeScaleCenterEnum"] = self.edgeScaleCenterEnum
@@ -418,149 +542,161 @@ class EdgeRoundifier(bpy.types.Operator):
 
         box = layout.box()
         self.addEnumParameterToUI(box, False, uiPercentage, 'Entry mode:', 'entryMode')
-        
-        row = box.row (align = False)
-        row.prop(self, 'angleEnum', expand = True, text = "angle presets")
 
-        self.addParameterToUI(box, False, uiPercentage, 'Angle:', 'a')
-        self.addParameterToUI(box, False, uiPercentage, 'Radius:', 'r')
+        row = box.row(align=False)
+        row.prop(self, 'angleEnum', expand=True, text="Angle presets")
+
+        disable_a = bool(self.entryMode == 'Angle' and self.angleEnum == 'Other')
+        disable_r = bool(self.entryMode == 'Radius')
+
+        self.addParameterToUI(box, False, uiPercentage, 'Angle:', 'a', disable_a)
+        self.addParameterToUI(box, False, uiPercentage, 'Radius:', 'r', disable_r)
         self.addParameterToUI(box, False, uiPercentage, 'Segments:', 'n')
 
-###################################
         box = layout.box()
-        self.addTwoCheckboxesToUI(box, False, 'Options:', 'flip','invertAngle')
-        self.addTwoCheckboxesToUI(box, False, '', 'bothSides','fullCircles')
-        self.addCheckboxToUI(box, False, '', 'drawArcCenters')
+        self.addCheckboxToUI(box, True, 'Options:', 'flip', 'invertAngle')
+        self.addCheckboxToUI(box, True, '', 'bothSides', 'fullCircles')
+        self.addCheckboxToUI(box, True, '', 'drawArcCenters')
 
         box = layout.box()
-        self.addTwoCheckboxesToUI(box, False, 'Remove:', 'removeEdges','removeScaledEdges')
+        self.addCheckboxToUI(box, True, 'Remove:', 'removeEdges', 'removeScaledEdges')
 
         box = layout.box()
-        self.addTwoCheckboxesToUI(box, False, 'Connect:', 'connectArcs','connectArcsFlip')
-        self.addTwoCheckboxesToUI(box, False, '', 'connectArcWithEdge','connectArcWithEdgeFlip')
-        self.addCheckboxToUI(box, False, '', 'connectScaledAndBase')
-################################
-                
+        self.addCheckboxToUI(box, True, 'Connect:', 'connectArcs', 'connectArcsFlip')
+        self.addCheckboxToUI(box, True, '', 'connectArcWithEdge', 'connectArcWithEdgeFlip')
+        self.addCheckboxToUI(box, True, '', 'connectScaledAndBase')
+
         box = layout.box()
         self.addParameterToUI(box, False, uiPercentage, 'Orhto offset:', 'offset')
         self.addParameterToUI(box, False, uiPercentage, 'Parallel offset:', 'offset2')
-        
+
         box = layout.box()
         self.addParameterToUI(box, False, uiPercentage, 'Edge rotate :', 'edgeAngle')
         self.addEnumParameterToUI(box, False, uiPercentage, 'Axis rotate center:', 'rotateCenter')
         self.addParameterToUI(box, False, uiPercentage, 'Axis rotate:', 'axisAngle')
-        
+
         box = layout.box()
         self.addParameterToUI(box, False, uiPercentage, 'Elliptic factor:', 'ellipticFactor')
 
-    def addParameterToUI(self, layout, alignment, percent, label, property):
-        row = layout.row (align = alignment)
-        split = row.split(factor=percent, align=False)
+    def addParameterToUI(self, layout, alignment, percent, label, properties, disable=True):
+        row = layout.row(align=alignment)
+        split = row.split(factor=percent)
         col = split.column()
+
         col.label(text=label)
         col2 = split.column()
-        row = col2.row(align = alignment)
-        row.prop(self, property)
-        
-    def addTwoCheckboxesToUI(self, layout, alignment, label, property1, property2):
-        row = layout.row (align = alignment)
-        row.label(text=label)
-        row.prop(self, property1)
-        row.prop(self, property2)
-        
-    def addCheckboxToUI(self, layout, alignment, label, property1):
-        row = layout.row (align = alignment)
-        row.label(text=label)
-        row.prop(self, property1)
-        row.label(text='')
-        
-    def addEnumParameterToUI(self, layout, alignment, percent, label, property):
-        row = layout.row (align = alignment)
-        split = row.split(factor=percent, align=False)
+        row = col2.row(align=alignment)
+        row.enabled = disable
+        row.prop(self, properties)
+
+    def addCheckboxToUI(self, layout, alignment, label, property1, property2=None):
+        if label not in (""):
+            row = layout.row()
+            row.label(text=label)
+        row2 = layout.row(align=alignment)
+        if property2:
+            split = row2.split(factor=0.5)
+            split.prop(self, property1, toggle=True)
+            split.prop(self, property2, toggle=True)
+        else:
+            row2.prop(self, property1, toggle=True)
+            layout.separator()
+
+    def addEnumParameterToUI(self, layout, alignment, percent, label, properties):
+        row = layout.row(align=alignment)
+        split = row.split(factor=percent)
         col = split.column()
+
         col.label(text=label)
         col2 = split.column()
-        row = col2.row(align = alignment)
-        row.prop(self, property, expand = True, text = "a")
+        row = col2.row(align=alignment)
+        row.prop(self, properties, expand=True, text="a")
 
     def execute(self, context):
-            
+
         edges, mesh, bm = self.prepareMesh(context)
         parameters = self.prepareParameters()
-        
+
         self.resetValues(parameters["workMode"])
-        
+
         self.obj = context.view_layer.objects.active
         scaledEdges = self.scaleDuplicatedEdges(bm, edges, parameters)
 
         if len(scaledEdges) > 0:
             self.roundifyEdges(scaledEdges, parameters, bm, mesh)
-            
+
             if parameters["connectScaledAndBase"]:
                 self.connectScaledEdgesWithBaseEdge(scaledEdges, edges, bm, mesh)
-            
+
             self.sel.refreshMesh(bm, mesh)
             self.selectEdgesAfterRoundifier(context, scaledEdges)
         else:
-            debugPrint("No edges selected!")
-        
+            debugPrintNew(True, "No edges selected!")
+
         if parameters["removeEdges"]:
-            bmesh.ops.delete(bm, geom = edges, context = 'FACES_ONLY')
-        if parameters["removeScaledEdges"] and self.edgeScaleFactor != 1.0:    
-            bmesh.ops.delete(bm, geom = scaledEdges, context = 'FACES_ONLY')
-            
-        bpy.ops.object.mode_set(mode = 'OBJECT')
+            bmesh.ops.delete(bm, geom=edges, context='EDGES')
+
+        if parameters["removeScaledEdges"] and self.edgeScaleFactor != 1.0:
+            bmesh.ops.delete(bm, geom=scaledEdges, context='EDGES')
+
+        bpy.ops.object.mode_set(mode='OBJECT')
         bm.to_mesh(mesh)
-        bpy.ops.object.mode_set(mode = 'EDIT')
+        bpy.ops.object.mode_set(mode='EDIT')
+        bpy.ops.mesh.select_all(action='SELECT')
+        bpy.ops.mesh.remove_doubles()
 
         bm.free()
+
         return {'FINISHED'}
 
-##########################################
     def resetValues(self, workMode):
         if workMode == "Reset":
             self.setAllParamsToDefaults()
-        
+
     def setAllParamsToDefaults(self):
-        self.edgeScaleFactor = 1.0
-        self.r = 1
-        self.a = 180.0
-        self.n = 4
-        self.flip = False
-        self.invertAngle = False
-        self.fullCircles = False
-        self.bothSides = False
-        self.drawArcCenters = False
-        self.removeEdges = False
-        self.removeScaledEdges = False
-        
-        self.connectArcWithEdge = False
-        self.connectArcs = False
-        self.connectScaledAndBase = False
-        self.connectArcsFlip = False
-        self.connectArcWithEdgeFlip = False
-        
-        
-        self.axisAngle = 0.0
-        self.edgeAngle = 0.0
-        self.offset = 0.0
-        self.offset2 = 0.0
-        self.ellipticFactor = 0.0
-        
-        self.workMode = 'Normal'
-        self.entryMode = 'Angle'
-        self.angleEnum = '180'
-        self.referenceLocation = 'ORG'
-        self.planeEnum = 'XY'
-        self.edgeScaleCenterEnum = 'CENTER'
-        self.rotateCenter = 'Edge'
-        ######
-        
-    def scaleDuplicatedEdges(self,bm, edges, parameters):
+        try:
+            self.edgeScaleFactor = 1.0
+            self.r = 1
+            self.a = 180.0
+            self.n = 4
+            self.flip = False
+            self.invertAngle = False
+            self.fullCircles = False
+            self.bothSides = False
+            self.drawArcCenters = False
+            self.removeEdges = False
+            self.removeScaledEdges = False
+
+            self.connectArcWithEdge = False
+            self.connectArcs = False
+            self.connectScaledAndBase = False
+            self.connectArcsFlip = False
+            self.connectArcWithEdgeFlip = False
+
+            self.axisAngle = 0.0
+            self.edgeAngle = 0.0
+            self.offset = 0.0
+            self.offset2 = 0.0
+            self.ellipticFactor = 0.0
+
+            self.workMode = 'Normal'
+            self.entryMode = 'Angle'
+            self.angleEnum = '180'
+            self.referenceLocation = 'ORG'
+            self.planeEnum = 'XY'
+            self.edgeScaleCenterEnum = 'CENTER'
+            self.rotateCenter = 'Edge'
+
+            self.report({'INFO'}, "The parameters have been reset to default values")
+        except Exception as e:
+            self.report({'WARNING'}, "The parameters could not be reset")
+            debugPrintNew(True, "\n[setAllParamsToDefaults]\n parameter reset error\n" + e)
+
+    def scaleDuplicatedEdges(self, bm, edges, parameters):
         scaleCenter = parameters["edgeScaleCenterEnum"]
         factor = parameters["edgeScaleFactor"]
-        #this code is based on Zeffi's answer to my question
-        duplicateEdges=[]
+        # this code is based on Zeffi's answer to my question
+        duplicateEdges = []
         if factor == 1:
             duplicateEdges = edges
         else:
@@ -569,36 +705,35 @@ class EdgeRoundifier(bpy.types.Operator):
                 v2 = e.verts[1].co
                 origin = None
                 if scaleCenter == 'CENTER':
-                    origin = (v1+v2) * 0.5  
+                    origin = (v1 + v2) * 0.5
                 elif scaleCenter == 'V1':
-                    origin = v1  
+                    origin = v1
                 elif scaleCenter == 'V2':
-                    origin = v2  
-                    
-                bmv1 = bm.verts.new(((v1-origin) * factor) + origin)
-                bmv2 = bm.verts.new(((v2-origin) * factor) + origin)
+                    origin = v2
+
+                bmv1 = bm.verts.new(((v1 - origin) * factor) + origin)
+                bmv2 = bm.verts.new(((v2 - origin) * factor) + origin)
                 bme = bm.edges.new([bmv1, bmv2])
                 duplicateEdges.append(bme)
         return duplicateEdges
-        
-        
+
     def roundifyEdges(self, edges, parameters, bm, mesh):
         arcs = []
         for e in edges:
             arcVerts = self.roundify(e, parameters, bm, mesh)
             arcs.append(arcVerts)
 
-        if parameters["connectArcs"]: 
+        if parameters["connectArcs"]:
             self.connectArcsTogether(arcs, bm, mesh, parameters)
 
-    def getNormalizedEdgeVector (self, edge):
-        V1 = edge.verts[0].co 
-        V2 = edge.verts[1].co 
-        edgeVector =  V2 - V1
+    def getNormalizedEdgeVector(self, edge):
+        V1 = edge.verts[0].co
+        V2 = edge.verts[1].co
+        edgeVector = V2 - V1
         normEdge = edgeVector.normalized()
         return normEdge
 
-    def getEdgePerpendicularVector (self,edge, plane):
+    def getEdgePerpendicularVector(self, edge, plane):
         normEdge = self.getNormalizedEdgeVector(edge)
 
         edgePerpendicularVector = Vector((normEdge[1], -normEdge[0], 0))
@@ -607,16 +742,15 @@ class EdgeRoundifier(bpy.types.Operator):
         if plane == XZ:
             edgePerpendicularVector = Vector((normEdge[2], 0, -normEdge[0]))
         return edgePerpendicularVector
-            
+
     def getEdgeInfo(self, edge):
-        V1 = edge.verts[0].co 
-        V2 = edge.verts[1].co 
-        edgeVector =  V2 - V1 
-        edgeLength = edgeVector.length 
-        edgeCenter = (V2 + V1) * 0.5 
+        V1 = edge.verts[0].co
+        V2 = edge.verts[1].co
+        edgeVector = V2 - V1
+        edgeLength = edgeVector.length
+        edgeCenter = (V2 + V1) * 0.5
         return V1, V2, edgeVector, edgeLength, edgeCenter
 
-
     def roundify(self, edge, parameters, bm, mesh):
         V1, V2, edgeVector, edgeLength, edgeCenter = self.getEdgeInfo(edge)
         if self.skipThisEdge(V1, V2, parameters["plane"]):
@@ -625,15 +759,23 @@ class EdgeRoundifier(bpy.types.Operator):
         roundifyParams = None
         arcVerts = None
         roundifyParams = self.calculateRoundifyParams(edge, parameters, bm, mesh)
-        if roundifyParams == None:
+        if roundifyParams is None:
             return
-            
+
         arcVerts = self.spinAndPostprocess(edge, parameters, bm, mesh, edgeCenter, roundifyParams)
         return arcVerts
-                 
+
     def spinAndPostprocess(self, edge, parameters, bm, mesh, edgeCenter, roundifyParams):
-        spinnedVerts,roundifyParamsUpdated = self.drawSpin(edge, edgeCenter, roundifyParams, parameters, bm, mesh)
-        postProcessedArcVerts = self.arcPostprocessing(edge, parameters, bm, mesh, roundifyParamsUpdated, spinnedVerts, edgeCenter)
+        spinnedVerts, roundifyParamsUpdated = self.drawSpin(
+                                                edge, edgeCenter,
+                                                roundifyParams,
+                                                parameters, bm, mesh
+                                                )
+        postProcessedArcVerts = self.arcPostprocessing(
+                                                edge, parameters, bm, mesh,
+                                                roundifyParamsUpdated,
+                                                spinnedVerts, edgeCenter
+                                                )
         return postProcessedArcVerts
 
     def rotateArcAroundEdge(self, bm, mesh, arcVerts, parameters):
@@ -641,211 +783,221 @@ class EdgeRoundifier(bpy.types.Operator):
         if angle != 0:
             self.arc_rotator(arcVerts, angle, parameters)
 
-    # arc_rotator method was created by PKHG, I (komi3D) adjusted it to fit the rest of this addon    
+    # arc_rotator method was created by PKHG, I (komi3D) adjusted it to fit the rest
     def arc_rotator(self, arcVerts, extra_rotation, parameters):
-        bpy.ops.object.mode_set(mode = 'OBJECT')
+        bpy.ops.object.mode_set(mode='OBJECT')
         old_location = self.obj.location.copy()
-        bpy.ops.transform.translate(value = - old_location,
-                                    constraint_axis=(False, False, False),
-                                    orient_matrix_type='GLOBAL',
-                                    mirror=False,
-                                    use_proportional_edit=False,
-                                    proportional_edit_falloff='SMOOTH',
-                                    proportional_size=1
-                                    )
-        bpy.ops.object.mode_set(mode = 'EDIT')
+        bpy.ops.transform.translate(
+            value=-old_location,
+            constraint_axis=(False, False, False),
+            orient_type='GLOBAL',
+            mirror=False,
+            use_proportional_edit=False,
+        )
+        bpy.ops.object.mode_set(mode='EDIT')
         adjust_matrix = self.obj.matrix_parent_inverse
         bm = bmesh.from_edit_mesh(self.obj.data)
         lastVert = len(arcVerts) - 1
         if parameters["drawArcCenters"]:
-            lastVert = lastVert - 1 #center gets added as last vert of arc
-        v0_old = adjust_matrix  @  arcVerts[0].co.copy()
-        v1_old = adjust_matrix @ arcVerts[lastVert].co.copy()
+            lastVert = lastVert - 1  # center gets added as last vert of arc
+        v0_old = adjust_matrix @ arcVerts[0].co.copy()
 
-        #PKHG>INFO move if necessary v0 to origin such that the axis gos through origin and v1
-        if v0_old != Vector((0,0,0)):
+        # PKHG>INFO move if necessary v0 to origin such that the axis gos through origin and v1
+        if v0_old != Vector((0, 0, 0)):
             for i, ele in enumerate(arcVerts):
-                arcVerts[i].co += - v0_old   
+                arcVerts[i].co += - v0_old
 
-        axis =  arcVerts[0].co - arcVerts[lastVert].co 
-   
-        a_quat = Quaternion(axis, radians(extra_rotation)).normalized()
+        axis = arcVerts[0].co - arcVerts[lastVert].co
         a_mat = Quaternion(axis, radians(extra_rotation)).normalized().to_matrix()
-    
+
         for ele in arcVerts:
             ele.co = a_mat @ ele.co
-    
-        #PKHG>INFO move back if needed
-        if v0_old != Vector((0,0,0)):
+
+        # PKHG>INFO move back if needed
+        if v0_old != Vector((0, 0, 0)):
             for i, ele in enumerate(arcVerts):
-                arcVerts[i].co += + v0_old   
-    
-        bpy.ops.object.mode_set(mode = 'OBJECT')
-        #PKHG>INFO move origin object back print("old location = " , old_location)        
-        bpy.ops.transform.translate(value = old_location,
-                                    constraint_axis=(False, False, False),
-                                    orient_matrix_type='GLOBAL',
-                                    mirror=False,
-                                    use_proportional_edit=False,
-                                    proportional_edit_falloff='SMOOTH',
-                                    proportional_size=1
-                                    )
-        bpy.ops.object.mode_set(mode = 'EDIT')
-    
+                arcVerts[i].co += + v0_old
+
+        bpy.ops.object.mode_set(mode='OBJECT')
+        # PKHG>INFO move origin object back print("old location = " , old_location)
+        bpy.ops.transform.translate(
+            value=old_location,
+            constraint_axis=(False, False, False),
+            orient_type='GLOBAL',
+            mirror=False,
+            use_proportional_edit=False,
+        )
+        bpy.ops.object.mode_set(mode='EDIT')
+
     def makeElliptic(self, bm, mesh, arcVertices, parameters):
-        if parameters["ellipticFactor"] != 0: #if 0 then nothing has to be done
+        if parameters["ellipticFactor"] != 0:  # if 0 then nothing has to be done
             lastVert = len(arcVertices) - 1
             if parameters["drawArcCenters"]:
-                lastVert = lastVert - 1 #center gets added as last vert of arc
+                lastVert = lastVert - 1  # center gets added as last vert of arc
             v0co = arcVertices[0].co
             v1co = arcVertices[lastVert].co
-            
-            for vertex in arcVertices: #range(len(res_list)):
-                #PKHg>INFO compute the base on the edge  of the height-vector
-                top = vertex.co #res_list[nr].co
+
+            for vertex in arcVertices:  # range(len(res_list)):
+                # PKHg>INFO compute the base on the edge  of the height-vector
+                top = vertex.co  # res_list[nr].co
                 t = 0
-                if v1co - v0co != 0 :
-                    t = (v1co - v0co).dot(top - v0co)/(v1co - v0co).length ** 2 
+                if v1co - v0co != 0:
+                    t = (v1co - v0co).dot(top - v0co) / (v1co - v0co).length ** 2
                 h_bottom = v0co + t * (v1co - v0co)
-                height = (h_bottom - top )
+                height = (h_bottom - top)
                 vertex.co = top + parameters["ellipticFactor"] * height
-        
+
         return arcVertices
-        
+
     def arcPostprocessing(self, edge, parameters, bm, mesh, roundifyParams, spinnedVerts, edgeCenter):
         [chosenSpinCenter, otherSpinCenter, spinAxis, angle, steps, refObjectLocation] = roundifyParams
         rotatedVerts = []
         if parameters["rotateCenter"] == 'Edge':
-            rotatedVerts = self.rotateArcAroundSpinAxis(bm, mesh, spinnedVerts, parameters, edgeCenter)
+            rotatedVerts = self.rotateArcAroundSpinAxis(
+                                bm, mesh, spinnedVerts, parameters, edgeCenter
+                                )
         elif parameters["rotateCenter"] == 'Spin':
-            rotatedVerts = self.rotateArcAroundSpinAxis(bm, mesh, spinnedVerts, parameters, chosenSpinCenter)
+            rotatedVerts = self.rotateArcAroundSpinAxis(
+                                bm, mesh, spinnedVerts, parameters, chosenSpinCenter
+                                )
         elif parameters["rotateCenter"] == 'V1':
-            rotatedVerts = self.rotateArcAroundSpinAxis(bm, mesh, spinnedVerts, parameters, edge.verts[0].co)
+            rotatedVerts = self.rotateArcAroundSpinAxis(
+                                bm, mesh, spinnedVerts, parameters, edge.verts[0].co
+                                )
         elif parameters["rotateCenter"] == 'V2':
-            rotatedVerts = self.rotateArcAroundSpinAxis(bm, mesh, spinnedVerts, parameters, edge.verts[1].co)
-        
-        offsetVerts = self.offsetArcPerpendicular(bm, mesh, rotatedVerts, edge, parameters)
-        offsetVerts2 = self.offsetArcParallel(bm, mesh, offsetVerts, edge, parameters)
-        ellipticVerts = self.makeElliptic(bm,mesh,offsetVerts2,parameters)
+            rotatedVerts = self.rotateArcAroundSpinAxis(
+                                bm, mesh, spinnedVerts, parameters, edge.verts[1].co
+                                )
+
+        offsetVerts = self.offsetArcPerpendicular(
+                                bm, mesh, rotatedVerts, edge, parameters
+                                )
+        offsetVerts2 = self.offsetArcParallel(
+                                bm, mesh, offsetVerts, edge, parameters
+                                )
+        ellipticVerts = self.makeElliptic(
+                                bm, mesh, offsetVerts2, parameters
+                                )
         self.rotateArcAroundEdge(bm, mesh, ellipticVerts, parameters)
 
         if parameters["connectArcWithEdge"]:
-            self.connectArcTogetherWithEdge(edge,offsetVerts2,bm,mesh, parameters)
+            self.connectArcTogetherWithEdge(
+                                edge, offsetVerts2, bm, mesh, parameters
+                                )
         return offsetVerts2
-        
+
     def connectArcTogetherWithEdge(self, edge, arcVertices, bm, mesh, parameters):
         lastVert = len(arcVertices) - 1
         if parameters["drawArcCenters"]:
-            lastVert = lastVert - 1 #center gets added as last vert of arc    
+            lastVert = lastVert - 1  # center gets added as last vert of arc
         edgeV1 = edge.verts[0].co
         edgeV2 = edge.verts[1].co
         arcV1 = arcVertices[0].co
         arcV2 = arcVertices[lastVert].co
-        
+
         bmv1 = bm.verts.new(edgeV1)
         bmv2 = bm.verts.new(arcV1)
-        
+
         bmv3 = bm.verts.new(edgeV2)
         bmv4 = bm.verts.new(arcV2)
-        
-        if parameters["connectArcWithEdgeFlip"] == False: 
+
+        if parameters["connectArcWithEdgeFlip"] is False:
             bme = bm.edges.new([bmv1, bmv2])
             bme2 = bm.edges.new([bmv3, bmv4])
         else:
             bme = bm.edges.new([bmv1, bmv4])
             bme2 = bm.edges.new([bmv3, bmv2])
         self.sel.refreshMesh(bm, mesh)
-        
+
     def connectScaledEdgesWithBaseEdge(self, scaledEdges, baseEdges, bm, mesh):
         for i in range(0, len(scaledEdges)):
             scaledEdgeV1 = scaledEdges[i].verts[0].co
             baseEdgeV1 = baseEdges[i].verts[0].co
             scaledEdgeV2 = scaledEdges[i].verts[1].co
             baseEdgeV2 = baseEdges[i].verts[1].co
-            
+
             bmv1 = bm.verts.new(baseEdgeV1)
             bmv2 = bm.verts.new(scaledEdgeV1)
             bme = bm.edges.new([bmv1, bmv2])
-            
+
             bmv3 = bm.verts.new(scaledEdgeV2)
             bmv4 = bm.verts.new(baseEdgeV2)
             bme = bm.edges.new([bmv3, bmv4])
         self.sel.refreshMesh(bm, mesh)
-            
+
     def connectArcsTogether(self, arcs, bm, mesh, parameters):
-        for i in range(0, len(arcs)-1):
-            if arcs[i] == None or arcs[i + 1] == None: # in case on XZ or YZ there are no arcs drawn
+        for i in range(0, len(arcs) - 1):
+            # in case on XZ or YZ there are no arcs drawn
+            if arcs[i] is None or arcs[i + 1] is None:
                 return
-            lastVert = len(arcs[i])-1
+
+            lastVert = len(arcs[i]) - 1
             if parameters["drawArcCenters"]:
-                lastVert = lastVert - 1 #center gets added as last vert of arc    
+                lastVert = lastVert - 1  # center gets added as last vert of arc
+            # take last vert of arc i and first vert of arc i+1
 
-            #take last vert of arc i and first vert of arc i+1
             V1 = arcs[i][lastVert].co
-            V2 = arcs[i+1][0].co
-            
+            V2 = arcs[i + 1][0].co
+
             if parameters["connectArcsFlip"]:
                 V1 = arcs[i][0].co
-                V2 = arcs[i+1][lastVert].co
-            
+                V2 = arcs[i + 1][lastVert].co
+
             bmv1 = bm.verts.new(V1)
             bmv2 = bm.verts.new(V2)
             bme = bm.edges.new([bmv1, bmv2])
-        
-        #connect last arc and first one
-        lastArcId = len(arcs)-1
-        lastVertIdOfLastArc = len(arcs[lastArcId])-1
+
+        # connect last arc and first one
+        lastArcId = len(arcs) - 1
+        lastVertIdOfLastArc = len(arcs[lastArcId]) - 1
         if parameters["drawArcCenters"]:
-                lastVertIdOfLastArc = lastVertIdOfLastArc - 1 #center gets added as last vert of arc   
+            # center gets added as last vert of arc
+            lastVertIdOfLastArc = lastVertIdOfLastArc - 1
+
         V1 = arcs[lastArcId][lastVertIdOfLastArc].co
         V2 = arcs[0][0].co
         if parameters["connectArcsFlip"]:
-                V1 = arcs[lastArcId][0].co
-                V2 = arcs[0][lastVertIdOfLastArc].co
+            V1 = arcs[lastArcId][0].co
+            V2 = arcs[0][lastVertIdOfLastArc].co
 
         bmv1 = bm.verts.new(V1)
         bmv2 = bm.verts.new(V2)
         bme = bm.edges.new([bmv1, bmv2])
-                    
+
         self.sel.refreshMesh(bm, mesh)
 
     def offsetArcPerpendicular(self, bm, mesh, Verts, edge, parameters):
         perpendicularVector = self.getEdgePerpendicularVector(edge, parameters["plane"])
         offset = parameters["offset"]
         translation = offset * perpendicularVector
-        
+
         try:
-            bmesh.ops.translate(
-            bm,
-            verts=Verts,
-            vec=translation)
+            bmesh.ops.translate(bm, verts=Verts, vec=translation)
         except ValueError:
-            print ("[Edge Roundifier]: Perpendicular translate value error - multiple vertices in list - try unchecking 'Centers'")
-        
-        indexes = [v.index for v in Verts] 
+            print("[Edge Roundifier]: Perpendicular translate value error - "
+                  "multiple vertices in list - try unchecking 'Centers'")
+
+        indexes = [v.index for v in Verts]
         self.sel.refreshMesh(bm, mesh)
         offsetVertices = [bm.verts[i] for i in indexes]
         return offsetVertices
-    
+
     def offsetArcParallel(self, bm, mesh, Verts, edge, parameters):
         edgeVector = self.getNormalizedEdgeVector(edge)
         offset = parameters["offset2"]
         translation = offset * edgeVector
-        
+
         try:
-            bmesh.ops.translate(
-            bm,
-            verts=Verts,
-            vec=translation)
+            bmesh.ops.translate(bm, verts=Verts, vec=translation)
         except ValueError:
-            print ("[Edge Roundifier]: Parallel translate value error - multiple vertices in list - try unchecking 'Centers'")
-        
-        indexes = [v.index for v in Verts] 
+            print("[Edge Roundifier]: Parallel translate value error - "
+                  "multiple vertices in list - try unchecking 'Centers'")
+
+        indexes = [v.index for v in Verts]
         self.sel.refreshMesh(bm, mesh)
         offsetVertices = [bm.verts[i] for i in indexes]
         return offsetVertices
-        
-        
+
     def skipThisEdge(self, V1, V2, plane):
         # Check If It is possible to spin selected verts on this plane if not exit roundifier
         if(plane == XY):
@@ -860,35 +1012,51 @@ class EdgeRoundifier(bpy.types.Operator):
         return False
 
     def calculateRoundifyParams(self, edge, parameters, bm, mesh):
-        # BECAUSE ALL DATA FROM MESH IS IN LOCAL COORDINATES
-        # AND SPIN OPERATOR WORKS ON GLOBAL COORDINATES
-        # WE FIRST NEED TO TRANSLATE ALL INPUT DATA BY VECTOR EQUAL TO ORIGIN POSITION AND THEN PERFORM CALCULATIONS
+        # Because all data from mesh is in local coordinates
+        # and spin operator works on global coordinates
+        # We first need to translate all input data by vector equal
+        # to origin position and then perform calculations
         # At least that is my understanding :) <komi3D>
 
         # V1 V2 stores Local Coordinates
         V1, V2, edgeVector, edgeLength, edgeCenter = self.getEdgeInfo(edge)
 
-        debugPrintNew(d_Plane, "PLANE: " +  parameters["plane"])
-        lineAB = self.calc.getLineCoefficientsPerpendicularToVectorInPoint(edgeCenter, edgeVector, parameters["plane"])
+        debugPrintNew(d_Plane, "PLANE: " + parameters["plane"])
+        lineAB = self.calc.getLineCoefficientsPerpendicularToVectorInPoint(
+                                                edgeCenter, edgeVector,
+                                                parameters["plane"]
+                                                )
         circleMidPoint = V1
-        circleMidPointOnPlane = self.calc.getCircleMidPointOnPlane(V1, parameters["plane"])
+        circleMidPointOnPlane = self.calc.getCircleMidPointOnPlane(
+                                                V1, parameters["plane"]
+                                                )
         radius = parameters["radius"]
 
         angle = 0
         if (parameters["entryMode"] == 'Angle'):
             if (parameters["angleEnum"] != 'Other'):
-                radius, angle = self.CalculateRadiusAndAngleForAnglePresets(parameters["angleEnum"], radius, angle, edgeLength)
+                radius, angle = self.CalculateRadiusAndAngleForAnglePresets(
+                                                parameters["angleEnum"], radius,
+                                                angle, edgeLength
+                                                )
             else:
                 radius, angle = self.CalculateRadiusAndAngle(edgeLength)
-        debugPrintNew(d_Radius_Angle, "RADIUS = " + str(radius) + "  ANGLE = " + str( angle))
+        debugPrintNew(d_Radius_Angle, "RADIUS = " + str(radius) + "  ANGLE = " + str(angle))
         roots = None
         if angle != pi:  # mode other than 180
-            if lineAB == None:
-                roots = self.calc.getLineCircleIntersectionsWhenXPerpendicular(edgeCenter, circleMidPointOnPlane, radius, parameters["plane"])
+            if lineAB is None:
+                roots = self.calc.getLineCircleIntersectionsWhenXPerpendicular(
+                                                edgeCenter, circleMidPointOnPlane,
+                                                radius, parameters["plane"]
+                                                )
             else:
-                roots = self.calc.getLineCircleIntersections(lineAB, circleMidPointOnPlane, radius)
-            if roots == None:
-                debugPrint("[Edge Roundifier]: No centers were found. Change radius to higher value")
+                roots = self.calc.getLineCircleIntersections(
+                                                lineAB, circleMidPointOnPlane, radius
+                                                )
+
+            if roots is None:
+                debugPrintNew(True,
+                             "[Edge Roundifier]: No centers were found. Change radius to higher value")
                 return None
             roots = self.addMissingCoordinate(roots, V1, parameters["plane"])  # adds X, Y or Z coordinate
         else:
@@ -906,19 +1074,21 @@ class EdgeRoundifier(bpy.types.Operator):
             refObjectLocation = self.calc.getEdgeReference(edge, edgeCenter, parameters["plane"])
 
         debugPrintNew(d_RefObject, parameters["refObject"], refObjectLocation)
-        chosenSpinCenter, otherSpinCenter = self.getSpinCenterClosestToRefCenter(refObjectLocation, roots)
+        chosenSpinCenter, otherSpinCenter = self.getSpinCenterClosestToRefCenter(
+                                                            refObjectLocation, roots
+                                                            )
 
         if (parameters["entryMode"] == "Radius"):
             halfAngle = self.calc.getAngle(edgeCenter, chosenSpinCenter, circleMidPoint)
             angle = 2 * halfAngle[0]  # in radians
-            self.a = degrees(angle)  # in degrees
+            self.a = degrees(angle)   # in degrees
 
         spinAxis = self.getSpinAxis(parameters["plane"])
         steps = parameters["segments"]
-        angle = -angle #rotate clockwise by default
-        
+        angle = -angle  # rotate clockwise by default
+
         return [chosenSpinCenter, otherSpinCenter, spinAxis, angle, steps, refObjectLocation]
-    
+
     def drawSpin(self, edge, edgeCenter, roundifyParams, parameters, bm, mesh):
         [chosenSpinCenter, otherSpinCenter, spinAxis, angle, steps, refObjectLocation] = roundifyParams
 
@@ -929,7 +1099,7 @@ class EdgeRoundifier(bpy.types.Operator):
             spinCenterTemp = chosenSpinCenter
             chosenSpinCenter = otherSpinCenter
             otherSpinCenter = spinCenterTemp
-            
+
         if(parameters["invertAngle"]):
             if angle < 0:
                 angle = two_pi + angle
@@ -942,83 +1112,97 @@ class EdgeRoundifier(bpy.types.Operator):
             angle = two_pi
 
         v0 = bm.verts.new(v0org.co)
-        
-        result = bmesh.ops.spin(bm, geom = [v0], cent = chosenSpinCenter, axis = spinAxis, \
-                                   angle = angle, steps = steps, use_duplicate = False)
 
-        # it seems there is something wrong with last index of this spin...
-        # I need to calculate the last index manually here...
+        result = bmesh.ops.spin(
+                        bm, geom=[v0], cent=chosenSpinCenter, axis=spinAxis,
+                        angle=angle, steps=steps, use_duplicate=False
+                        )
+
+        # it seems there is something wrong with last index of this spin
+        # I need to calculate the last index manually here
         vertsLength = len(bm.verts)
         bm.verts.ensure_lookup_table()
         lastVertIndex = bm.verts[vertsLength - 1].index
         lastSpinVertIndices = self.getLastSpinVertIndices(steps, lastVertIndex)
 
         self.sel.refreshMesh(bm, mesh)
-        
+
         alternativeLastSpinVertIndices = []
         bothSpinVertices = []
         spinVertices = []
         alternate = False
-        
+
         if ((angle == pi or angle == -pi) and not parameters["bothSides"]):
 
             midVertexIndex = lastVertIndex - round(steps / 2)
             bm.verts.ensure_lookup_table()
             midVert = bm.verts[midVertexIndex].co
 
-            midVertexDistance = (Vector(refObjectLocation) - Vector(midVert)).length 
+            midVertexDistance = (Vector(refObjectLocation) - Vector(midVert)).length
             midEdgeDistance = (Vector(refObjectLocation) - Vector(edgeCenter)).length
 
-
-            if ((parameters["invertAngle"]) or (parameters["flip"] )) :
+            if ((parameters["invertAngle"]) or (parameters["flip"])):
                 if (midVertexDistance > midEdgeDistance):
-                    alternativeLastSpinVertIndices = self.alternateSpin(bm, mesh, angle, chosenSpinCenter, spinAxis, steps, v0, v1org, lastSpinVertIndices)
-                                    
+                    alternativeLastSpinVertIndices = self.alternateSpin(
+                                                        bm, mesh, angle, chosenSpinCenter,
+                                                        spinAxis, steps, v0, v1org, lastSpinVertIndices
+                                                        )
             else:
                 if (midVertexDistance < midEdgeDistance):
-                    alternativeLastSpinVertIndices = self.alternateSpin(bm, mesh, angle, chosenSpinCenter, spinAxis, steps, v0, v1org, lastSpinVertIndices)
-
-        elif (angle != two_pi):  # to allow full circles :)
+                    alternativeLastSpinVertIndices = self.alternateSpin(
+                                                        bm, mesh, angle, chosenSpinCenter,
+                                                        spinAxis, steps, v0, v1org, lastSpinVertIndices
+                                                        )
+        elif (angle != two_pi):  # to allow full circles
             if (result['geom_last'][0].co - v1org.co).length > SPIN_END_THRESHOLD:
-                alternativeLastSpinVertIndices = self.alternateSpin(bm, mesh, angle, chosenSpinCenter, spinAxis, steps, v0, v1org, lastSpinVertIndices)
+                alternativeLastSpinVertIndices = self.alternateSpin(
+                                                        bm, mesh, angle, chosenSpinCenter,
+                                                        spinAxis, steps, v0, v1org, lastSpinVertIndices
+                                                        )
                 alternate = True
 
         self.sel.refreshMesh(bm, mesh)
         if alternativeLastSpinVertIndices != []:
             lastSpinVertIndices = alternativeLastSpinVertIndices
-        
-       
-        if lastSpinVertIndices.stop <= len(bm.verts): #make sure arc was added to bmesh
-            spinVertices = [ bm.verts[i] for i in lastSpinVertIndices]
+
+        if lastSpinVertIndices.stop <= len(bm.verts):  # make sure arc was added to bmesh
+            spinVertices = [bm.verts[i] for i in lastSpinVertIndices]
             if alternativeLastSpinVertIndices != []:
-                spinVertices = spinVertices + [v0] 
+                spinVertices = spinVertices + [v0]
             else:
                 spinVertices = [v0] + spinVertices
-            
+
         if (parameters["bothSides"]):
-                #do some more testing here!!!
+            do some more testing here!!!
             if (angle == pi or angle == -pi):
-                alternativeLastSpinVertIndices = self.alternateSpinNoDelete(bm, mesh, -angle, chosenSpinCenter, spinAxis, steps, v0, v1org, [])
+                alternativeLastSpinVertIndices = self.alternateSpinNoDelete(
+                                                        bm, mesh, -angle, chosenSpinCenter,
+                                                        spinAxis, steps, v0, v1org, []
+                                                        )
             elif alternate:
-                alternativeLastSpinVertIndices = self.alternateSpinNoDelete(bm, mesh, angle, otherSpinCenter, spinAxis, steps, v0, v1org, [])
-            elif not alternate:    
-                alternativeLastSpinVertIndices = self.alternateSpinNoDelete(bm, mesh, -angle, otherSpinCenter, spinAxis, steps, v0, v1org, [])
-            bothSpinVertices = [ bm.verts[i] for i in lastSpinVertIndices]
-            alternativeSpinVertices= [ bm.verts[i] for i in alternativeLastSpinVertIndices]
-            bothSpinVertices = [v0] + bothSpinVertices + alternativeSpinVertices 
+                alternativeLastSpinVertIndices = self.alternateSpinNoDelete(
+                                                        bm, mesh, angle, otherSpinCenter,
+                                                        spinAxis, steps, v0, v1org, []
+                                                        )
+            elif not alternate:
+                alternativeLastSpinVertIndices = self.alternateSpinNoDelete(
+                                                        bm, mesh, -angle, otherSpinCenter,
+                                                        spinAxis, steps, v0, v1org, []
+                                                        )
+            bothSpinVertices = [bm.verts[i] for i in lastSpinVertIndices]
+            alternativeSpinVertices = [bm.verts[i] for i in alternativeLastSpinVertIndices]
+            bothSpinVertices = [v0] + bothSpinVertices + alternativeSpinVertices
             spinVertices = bothSpinVertices
-            
+
         if (parameters["fullCircles"]):
             v1 = bm.verts.new(v1org.co)
             spinVertices = spinVertices + [v1]
-            
+
         if (parameters['drawArcCenters']):
             centerVert = bm.verts.new(chosenSpinCenter)
             spinVertices.append(centerVert)
-            
-        return spinVertices,[chosenSpinCenter, otherSpinCenter, spinAxis, angle, steps, refObjectLocation]
 
-##########################################
+        return spinVertices, [chosenSpinCenter, otherSpinCenter, spinAxis, angle, steps, refObjectLocation]
 
     def deleteSpinVertices(self, bm, mesh, lastSpinVertIndices):
         verticesForDeletion = []
@@ -1026,19 +1210,20 @@ class EdgeRoundifier(bpy.types.Operator):
         for i in lastSpinVertIndices:
             vi = bm.verts[i]
             vi.select = True
-            debugPrint(str(i) + ") " + str(vi))
+            debugPrintNew(True, str(i) + ") " + str(vi))
             verticesForDeletion.append(vi)
 
-        bmesh.ops.delete(bm, geom = verticesForDeletion, context = 1)
+        bmesh.ops.delete(bm, geom=verticesForDeletion, context = 'VERTS')
         bmesh.update_edit_mesh(mesh, True)
-        bpy.ops.object.mode_set(mode = 'OBJECT')
-        bpy.ops.object.mode_set(mode = 'EDIT')
+        bpy.ops.object.mode_set(mode='OBJECT')
+        bpy.ops.object.mode_set(mode='EDIT')
 
-    def alternateSpinNoDelete(self, bm, mesh, angle, chosenSpinCenter, spinAxis, steps, v0, v1org, lastSpinVertIndices):
+    def alternateSpinNoDelete(self, bm, mesh, angle, chosenSpinCenter,
+                              spinAxis, steps, v0, v1org, lastSpinVertIndices):
         v0prim = v0
-       
-        result2 = bmesh.ops.spin(bm, geom = [v0prim], cent = chosenSpinCenter, axis = spinAxis,
-            angle = angle, steps = steps, use_duplicate = False)
+
+        result2 = bmesh.ops.spin(bm, geom=[v0prim], cent=chosenSpinCenter, axis=spinAxis,
+                                 angle=angle, steps=steps, use_duplicate=False)
         vertsLength = len(bm.verts)
         bm.verts.ensure_lookup_table()
         lastVertIndex2 = bm.verts[vertsLength - 1].index
@@ -1046,14 +1231,18 @@ class EdgeRoundifier(bpy.types.Operator):
         lastSpinVertIndices2 = self.getLastSpinVertIndices(steps, lastVertIndex2)
         return lastSpinVertIndices2
 
-    def alternateSpin(self, bm, mesh, angle, chosenSpinCenter, spinAxis, steps, v0, v1org, lastSpinVertIndices):
+    def alternateSpin(self, bm, mesh, angle, chosenSpinCenter,
+                      spinAxis, steps, v0, v1org, lastSpinVertIndices):
+
         self.deleteSpinVertices(bm, mesh, lastSpinVertIndices)
         v0prim = v0
-       
-        result2 = bmesh.ops.spin(bm, geom = [v0prim], cent = chosenSpinCenter, axis = spinAxis,
-            angle = -angle, steps = steps, use_duplicate = False)
-        # it seems there is something wrong with last index of this spin...
-        # I need to calculate the last index manually here...
+
+        result2 = bmesh.ops.spin(
+                        bm, geom=[v0prim], cent=chosenSpinCenter, axis=spinAxis,
+                        angle=-angle, steps=steps, use_duplicate=False
+                        )
+        # it seems there is something wrong with last index of this spin
+        # I need to calculate the last index manually here
         vertsLength = len(bm.verts)
         bm.verts.ensure_lookup_table()
         lastVertIndex2 = bm.verts[vertsLength - 1].index
@@ -1061,7 +1250,7 @@ class EdgeRoundifier(bpy.types.Operator):
         lastSpinVertIndices2 = self.getLastSpinVertIndices(steps, lastVertIndex2)
         # second spin also does not hit the v1org
         if (result2['geom_last'][0].co - v1org.co).length > SPIN_END_THRESHOLD:
-            
+
             self.deleteSpinVertices(bm, mesh, lastSpinVertIndices2)
             self.deleteSpinVertices(bm, mesh, range(v0.index, v0.index + 1))
             return []
@@ -1073,86 +1262,57 @@ class EdgeRoundifier(bpy.types.Operator):
         lastSpinVertIndices = range(arcfirstVertexIndex, lastVertIndex + 1)
         return lastSpinVertIndices
 
-
-##################        
-        
     def rotateArcAroundSpinAxis(self, bm, mesh, vertices, parameters, edgeCenter):
-        
         axisAngle = parameters["axisAngle"]
         plane = parameters["plane"]
-        #compensate rotation center
+        # compensate rotation center
         objectLocation = bpy.context.active_object.location
-        #center = objectLocation + chosenSpinCenter 
         center = objectLocation + edgeCenter
-        
-        rot = Euler( (0.0, 0.0, radians(axisAngle)),'XYZ' ).to_matrix()
+
+        rot = Euler((0.0, 0.0, radians(axisAngle)), 'XYZ').to_matrix()
         if plane == YZ:
-            rot = Euler( (radians(axisAngle),0.0, 0.0 ),'XYZ' ).to_matrix()
+            rot = Euler((radians(axisAngle), 0.0, 0.0), 'XYZ').to_matrix()
         if plane == XZ:
-            rot = Euler( (0.0, radians(axisAngle),0.0),'XYZ' ).to_matrix()
-           
-        indexes = [v.index for v in vertices] 
+            rot = Euler((0.0, radians(axisAngle), 0.0), 'XYZ').to_matrix()
+
+        indexes = [v.index for v in vertices]
 
         bmesh.ops.rotate(
-                    bm,
-                    cent=center,
-                    matrix=rot,
-                    verts=vertices,
-                    space=bpy.context.edit_object.matrix_world
-                    )
+            bm,
+            cent=center,
+            matrix=rot,
+            verts=vertices,
+            space=bpy.context.edit_object.matrix_world
+        )
         self.sel.refreshMesh(bm, mesh)
         bm.verts.ensure_lookup_table()
         rotatedVertices = [bm.verts[i] for i in indexes]
-        
-        return rotatedVertices
-            
-    def deleteSpinVertices(self, bm, mesh, lastSpinVertIndices):
-        verticesForDeletion = []
-        bm.verts.ensure_lookup_table()
-        for i in lastSpinVertIndices:
-            vi = bm.verts[i]
-            vi.select = True
-            verticesForDeletion.append(vi)
 
-        bmesh.ops.delete(bm, geom = verticesForDeletion, context = 'EDGES')
-        bmesh.update_edit_mesh(mesh, True)
-        bpy.ops.object.mode_set(mode = 'OBJECT')
-        bpy.ops.object.mode_set(mode = 'EDIT')
-
-    def getLastSpinVertIndices(self, steps, lastVertIndex):
-        arcfirstVertexIndex = lastVertIndex - steps + 1
-        lastSpinVertIndices = range(arcfirstVertexIndex, lastVertIndex + 1)
-        return lastSpinVertIndices
+        return rotatedVertices
 
     def CalculateRadiusAndAngle(self, edgeLength):
         degAngle = self.a
         angle = radians(degAngle)
         self.r = radius = edgeLength / (2 * sin(angle / 2))
         return radius, angle
-    
+
     def CalculateRadiusAndAngleForAnglePresets(self, angleEnum, initR, initA, edgeLength):
         radius = initR
         angle = initA
+        try:
+            # Note - define an integer string in the angleEnum
+            angle_convert = int(angleEnum)
+            self.a = angle_convert
+        except:
+            self.a = 180  # fallback
+            debugPrintNew(True,
+                          "CalculateRadiusAndAngleForAnglePresets problem with int conversion")
 
-        if angleEnum == "180":
-            self.a = 180
-        elif angleEnum == "120":
-            self.a = 120
-        elif angleEnum == "90":
-            self.a = 90
-        elif angleEnum == "72":
-            self.a = 72
-        elif angleEnum == "60":
-            self.a = 60
-        elif angleEnum == "45":
-            self.a = 45
-        elif angleEnum == "30":
-            self.a = 30
         return self.CalculateRadiusAndAngle(edgeLength)
-                      
+
     def getSpinCenterClosestToRefCenter(self, objLocation, roots):
         root0Distance = (Vector(objLocation) - Vector(roots[0])).length
-        root1Distance = (Vector(objLocation) - Vector(roots[1])).length 
+        root1Distance = (Vector(objLocation) - Vector(roots[1])).length
 
         chosenId = 0
         rejectedId = 1
@@ -1162,7 +1322,7 @@ class EdgeRoundifier(bpy.types.Operator):
         return roots[chosenId], roots[rejectedId]
 
     def addMissingCoordinate(self, roots, startVertex, plane):
-        if roots != None:
+        if roots is not None:
             a, b = roots[0]
             c, d = roots[1]
             if plane == XY:
@@ -1177,11 +1337,12 @@ class EdgeRoundifier(bpy.types.Operator):
         return roots
 
     def selectEdgesAfterRoundifier(self, context, edges):
-        bpy.ops.object.mode_set(mode = 'OBJECT')
-        bpy.ops.object.mode_set(mode = 'EDIT')
+        bpy.ops.object.mode_set(mode='OBJECT')
+        bpy.ops.object.mode_set(mode='EDIT')
         mesh = context.view_layer.objects.active.data
         bmnew = bmesh.new()
         bmnew.from_mesh(mesh)
+
         self.deselectEdges(bmnew)
         for selectedEdge in edges:
             for e in bmnew.edges:
@@ -1189,11 +1350,10 @@ class EdgeRoundifier(bpy.types.Operator):
                    and (e.verts[1].co - selectedEdge.verts[1].co).length <= self.threshold:
                     e.select_set(True)
 
-        bpy.ops.object.mode_set(mode = 'OBJECT')
+        bpy.ops.object.mode_set(mode='OBJECT')
         bmnew.to_mesh(mesh)
         bmnew.free()
-        bpy.ops.object.mode_set(mode = 'EDIT')
-
+        bpy.ops.object.mode_set(mode='EDIT')
 
     def deselectEdges(self, bm):
         for edge in bm.edges:
@@ -1207,6 +1367,7 @@ class EdgeRoundifier(bpy.types.Operator):
             axis = (0, 1, 0)
         return axis
 
+
     @classmethod
     def poll(cls, context):
         return (context.view_layer.objects.active.type == 'MESH') and (context.view_layer.objects.active.mode == 'EDIT')
@@ -1215,6 +1376,7 @@ def draw_item(self, context):
     self.layout.operator_context = 'INVOKE_DEFAULT'
     self.layout.operator('mesh.edge_roundifier')
 
+    
 classes = (
            EdgeRoundifier,
            )
@@ -1222,8 +1384,6 @@ classes = (
 reg_cls, unreg_cls = bpy.utils.register_classes_factory(classes)
 
 
-
-
 def register():
     reg_cls()
     bpy.types.VIEW3D_MT_edit_mesh_edges.append(draw_item)