mesh_looptools.py

        
        # cleaning up
        terminate(global_undo)
        
        return{'FINISHED'}


# circle operator
class Circle(bpy.types.Operator):
    bl_idname = "mesh.looptools_circle"
    bl_label = "Circle"
    bl_description = "Move selected vertices into a circle shape"
    bl_options = {'REGISTER', 'UNDO'}
    
    custom_radius = bpy.props.BoolProperty(name = "Radius",
        description = "Force a custom radius",
        default = False)
    fit = bpy.props.EnumProperty(name = "Method",
        items = (("best", "Best fit", "Non-linear least squares"),
            ("inside", "Fit inside","Only move vertices towards the center")),
        description = "Method used for fitting a circle to the vertices",
        default = 'best')
    flatten = bpy.props.BoolProperty(name = "Flatten",
        description = "Flatten the circle, instead of projecting it on the " \
            "mesh",
        default = True)
    influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    radius = bpy.props.FloatProperty(name = "Radius",
        description = "Custom radius for circle",
        default = 1.0,
        min = 0.0,
        soft_max = 1000.0)
    regular = bpy.props.BoolProperty(name = "Regular",
        description = "Distribute vertices at constant distances along the " \
            "circle",
        default = True)
    
    @classmethod
    def poll(cls, context):
        ob = context.active_object
        return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
    
    def draw(self, context):
        layout = self.layout
        col = layout.column()
        
        col.prop(self, "fit")
        col.separator()
        
        col.prop(self, "flatten")
        row = col.row(align=True)
        row.prop(self, "custom_radius")
        row_right = row.row(align=True)
        row_right.active = self.custom_radius
        row_right.prop(self, "radius", text="")
        col.prop(self, "regular")
        col.separator()
                
        col.prop(self, "influence")
    
    def invoke(self, context, event):
        # load custom settings
        settings_load(self)
        return self.execute(context)
    
    def execute(self, context):
        # initialise
        global_undo, object, bm = initialise()
        settings_write(self)
        # check cache to see if we can save time
        cached, single_loops, loops, derived, mapping = cache_read("Circle",
            object, bm, False, False)
        if cached:
            derived, bm_mod = get_derived_bmesh(object, bm, context.scene)
        else:
            # find loops
            derived, bm_mod, single_vertices, single_loops, loops = \
                circle_get_input(object, bm, context.scene)
            mapping = get_mapping(derived, bm, bm_mod, single_vertices,
                False, loops)
            single_loops, loops = circle_check_loops(single_loops, loops,
                mapping, bm_mod)
        
        # saving cache for faster execution next time
        if not cached:
            cache_write("Circle", object, bm, False, False, single_loops,
                loops, derived, mapping)
        
        move = []
        for i, loop in enumerate(loops):
            # best fitting flat plane
            com, normal = calculate_plane(bm_mod, loop)
            # if circular, shift loop so we get a good starting vertex
            if loop[1]:
                loop = circle_shift_loop(bm_mod, loop, com)
            # flatten vertices on plane
            locs_2d, p, q = circle_3d_to_2d(bm_mod, loop, com, normal)
            # calculate circle
            if self.fit == 'best':
                x0, y0, r = circle_calculate_best_fit(locs_2d)
            else: # self.fit == 'inside'
                x0, y0, r = circle_calculate_min_fit(locs_2d)
            # radius override
            if self.custom_radius:
                r = self.radius / p.length
            # calculate positions on circle
            if self.regular:
                new_locs_2d = circle_project_regular(locs_2d[:], x0, y0, r)
            else:
                new_locs_2d = circle_project_non_regular(locs_2d[:], x0, y0, r)
            # take influence into account
            locs_2d = circle_influence_locs(locs_2d, new_locs_2d,
                self.influence)
            # calculate 3d positions of the created 2d input
            move.append(circle_calculate_verts(self.flatten, bm_mod,
                locs_2d, com, p, q, normal))
            # flatten single input vertices on plane defined by loop
            if self.flatten and single_loops:
                move.append(circle_flatten_singles(bm_mod, com, p, q,
                    normal, single_loops[i]))
        
        # move vertices to new locations
        move_verts(object, bm, mapping, move, -1)
        
        # cleaning up
        if derived:
            bm_mod.free()
        terminate(global_undo)
        
        return{'FINISHED'}


# curve operator
class Curve(bpy.types.Operator):
    bl_idname = "mesh.looptools_curve"
    bl_label = "Curve"
    bl_description = "Turn a loop into a smooth curve"
    bl_options = {'REGISTER', 'UNDO'}
    
    boundaries = bpy.props.BoolProperty(name = "Boundaries",
        description = "Limit the tool to work within the boundaries of the "\
            "selected vertices",
        default = False)
    influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    interpolation = bpy.props.EnumProperty(name = "Interpolation",
        items = (("cubic", "Cubic", "Natural cubic spline, smooth results"),
            ("linear", "Linear", "Simple and fast linear algorithm")),
        description = "Algorithm used for interpolation",
        default = 'cubic')
    regular = bpy.props.BoolProperty(name = "Regular",
        description = "Distribute vertices at constant distances along the" \
            "curve",
        default = True)
    restriction = bpy.props.EnumProperty(name = "Restriction",
        items = (("none", "None", "No restrictions on vertex movement"),
            ("extrude", "Extrude only","Only allow extrusions (no "\
                "indentations)"),
            ("indent", "Indent only", "Only allow indentation (no "\
                "extrusions)")),
        description = "Restrictions on how the vertices can be moved",
        default = 'none')
    
    @classmethod
    def poll(cls, context):
        ob = context.active_object
        return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
    
    def draw(self, context):
        layout = self.layout
        col = layout.column()
        
        col.prop(self, "interpolation")
        col.prop(self, "restriction")
        col.prop(self, "boundaries")
        col.prop(self, "regular")
        col.separator()
        
        col.prop(self, "influence")
    
    def invoke(self, context, event):
        # load custom settings
        settings_load(self)
        return self.execute(context)
    
    def execute(self, context):
        # initialise
        global_undo, object, bm = initialise()
        settings_write(self)
        # check cache to see if we can save time
        cached, single_loops, loops, derived, mapping = cache_read("Curve",
            object, bm, False, self.boundaries)
        if cached:
            derived, bm_mod = get_derived_bmesh(object, bm, context.scene)
        else:
            # find loops
            derived, bm_mod, loops = curve_get_input(object, bm,
                self.boundaries, context.scene)
            mapping = get_mapping(derived, bm, bm_mod, False, True, loops)
            loops = check_loops(loops, mapping, bm_mod)
        verts_selected = [v.index for v in bm_mod.verts if v.select \
            and not v.hide]
        
        # saving cache for faster execution next time
        if not cached:
            cache_write("Curve", object, bm, False, self.boundaries, False,
                loops, derived, mapping)
        
        move = []
        for loop in loops:
            knots, points = curve_calculate_knots(loop, verts_selected)
            pknots = curve_project_knots(bm_mod, verts_selected, knots,
                points, loop[1])
            tknots, tpoints = curve_calculate_t(bm_mod, knots, points,
                pknots, self.regular, loop[1])
            splines = calculate_splines(self.interpolation, bm_mod,
                tknots, knots)
            move.append(curve_calculate_vertices(bm_mod, knots, tknots,
                points, tpoints, splines, self.interpolation,
                self.restriction))
        
        # move vertices to new locations
        move_verts(object, bm, mapping, move, self.influence)
        
        # cleaning up 
        if derived:
            bm_mod.free()
        terminate(global_undo)

        return{'FINISHED'}


# flatten operator
class Flatten(bpy.types.Operator):
    bl_idname = "mesh.looptools_flatten"
    bl_label = "Flatten"
    bl_description = "Flatten vertices on a best-fitting plane"
    bl_options = {'REGISTER', 'UNDO'}
    
    influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    plane = bpy.props.EnumProperty(name = "Plane",
        items = (("best_fit", "Best fit", "Calculate a best fitting plane"),
            ("normal", "Normal", "Derive plane from averaging vertex "\
            "normals"),
            ("view", "View", "Flatten on a plane perpendicular to the "\
            "viewing angle")),
        description = "Plane on which vertices are flattened",
        default = 'best_fit')
    restriction = bpy.props.EnumProperty(name = "Restriction",
        items = (("none", "None", "No restrictions on vertex movement"),
            ("bounding_box", "Bounding box", "Vertices are restricted to "\
            "movement inside the bounding box of the selection")),
        description = "Restrictions on how the vertices can be moved",
        default = 'none')
    
    @classmethod
    def poll(cls, context):
        ob = context.active_object
        return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
    
    def draw(self, context):
        layout = self.layout
        col = layout.column()
        
        col.prop(self, "plane")
        #col.prop(self, "restriction")
        col.separator()
        
        col.prop(self, "influence")
    
    def invoke(self, context, event):
        # load custom settings
        settings_load(self)
        return self.execute(context)
    
    def execute(self, context):
        # initialise
        global_undo, object, bm = initialise()
        settings_write(self)
        # check cache to see if we can save time
        cached, single_loops, loops, derived, mapping = cache_read("Flatten",
            object, bm, False, False)
        if not cached:
            # order input into virtual loops
            loops = flatten_get_input(bm)
            loops = check_loops(loops, mapping, bm)
        
        # saving cache for faster execution next time
        if not cached:
            cache_write("Flatten", object, bm, False, False, False, loops,
                False, False)
        
        move = []
        for loop in loops:
            # calculate plane and position of vertices on them
            com, normal = calculate_plane(bm, loop, method=self.plane,
                object=object)
            to_move = flatten_project(bm, loop, com, normal)
            if self.restriction == 'none':
                move.append(to_move)
            else:
                move.append(to_move)
        move_verts(object, bm, False, move, self.influence)
        
        # cleaning up
        terminate(global_undo)
        
        return{'FINISHED'}


# gstretch operator
class GStretch(bpy.types.Operator):
    bl_idname = "mesh.looptools_gstretch"
    bl_label = "Gstretch"
    bl_description = "Stretch selected vertices to Grease Pencil stroke"
    bl_options = {'REGISTER', 'UNDO'}
    
    delete_strokes = bpy.props.BoolProperty(name="Delete strokes",
        description = "Remove Grease Pencil strokes if they have been used "\
            "for Gstretch",
        default = False)    
    influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    method = bpy.props.EnumProperty(name = "Method",
        items = (("project", "Project", "Project vertices onto the stroke, "\
            "using vertex normals and connected edges"),
            ("irregular", "Spread", "Distribute vertices along the full "\
            "stroke, retaining relative distances between the vertices"),
            ("regular", "Spread evenly", "Distribute vertices at regular "\
            "distances along the full stroke")),
        description = "Method of distributing the vertices over the Grease "\
            "Pencil stroke",
        default = 'regular')
        
    @classmethod
    def poll(cls, context):
        ob = context.active_object
        return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH'
            and ob.grease_pencil)
    
    def draw(self, context):
        layout = self.layout
        col = layout.column()
        
        col.prop(self, "delete_strokes")
        col.prop(self, "method")
        col.separator()
        col.prop(self, "influence")
    
    def invoke(self, context, event):
        # load custom settings
        settings_load(self)
        return self.execute(context)
    
    def execute(self, context):
        # initialise
        global_undo, object, bm = initialise()
        settings_write(self)
        
        # check cache to see if we can save time
        cached, single_loops, loops, derived, mapping = cache_read("Gstretch",
            object, bm, False, False)
        if cached:
            derived, bm_mod = get_derived_bmesh(object, bm, context.scene)
        else:
            # find loops
            derived, bm_mod, loops = get_connected_input(object, bm,
                context.scene, input='selected')
            mapping = get_mapping(derived, bm, bm_mod, False, False, loops)
            loops = check_loops(loops, mapping, bm_mod)
        strokes = gstretch_get_strokes(object)
        
        # saving cache for faster execution next time
        if not cached:
            cache_write("Gstretch", object, bm, False, False, False, loops,
                derived, mapping)
        
        # pair loops and strokes
        ls_pairs = gstretch_match_loops_strokes(loops, strokes, object, bm_mod)
        ls_pairs = gstretch_align_pairs(ls_pairs, object, bm_mod, self.method)
        
        move = []
        if ls_pairs:
            for (loop, stroke) in ls_pairs:
                move.append(gstretch_calculate_verts(loop, stroke, object,
                    bm_mod, self.method))
                if self.delete_strokes:
                    gstretch_erase_stroke(stroke, context)
        
        # move vertices to new locations
        move_verts(object, bm, mapping, move, self.influence)
        
        # cleaning up 
        if derived:
            bm_mod.free()
        terminate(global_undo)
        
        return{'FINISHED'}


# relax operator
class Relax(bpy.types.Operator):
    bl_idname = "mesh.looptools_relax"
    bl_label = "Relax"
    bl_description = "Relax the loop, so it is smoother"
    bl_options = {'REGISTER', 'UNDO'}
    
    input = bpy.props.EnumProperty(name = "Input",
        items = (("all", "Parallel (all)", "Also use non-selected "\
                "parallel loops as input"),
            ("selected", "Selection","Only use selected vertices as input")),
        description = "Loops that are relaxed",
        default = 'selected')
    interpolation = bpy.props.EnumProperty(name = "Interpolation",
        items = (("cubic", "Cubic", "Natural cubic spline, smooth results"),
            ("linear", "Linear", "Simple and fast linear algorithm")),
        description = "Algorithm used for interpolation",
        default = 'cubic')
    iterations = bpy.props.EnumProperty(name = "Iterations",
        items = (("1", "1", "One"),
            ("3", "3", "Three"),
            ("5", "5", "Five"),
            ("10", "10", "Ten"),
            ("25", "25", "Twenty-five")),
        description = "Number of times the loop is relaxed",
        default = "1")
    regular = bpy.props.BoolProperty(name = "Regular",
        description = "Distribute vertices at constant distances along the" \
            "loop",
        default = True)
    
    @classmethod
    def poll(cls, context):
        ob = context.active_object
        return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
    
    def draw(self, context):
        layout = self.layout
        col = layout.column()
        
        col.prop(self, "interpolation")
        col.prop(self, "input")
        col.prop(self, "iterations")
        col.prop(self, "regular")
    
    def invoke(self, context, event):
        # load custom settings
        settings_load(self)
        return self.execute(context)
    
    def execute(self, context):
        # initialise
        global_undo, object, bm = initialise()
        settings_write(self)
        # check cache to see if we can save time
        cached, single_loops, loops, derived, mapping = cache_read("Relax",
            object, bm, self.input, False)
        if cached:
            derived, bm_mod = get_derived_bmesh(object, bm, context.scene)
        else:
            # find loops
            derived, bm_mod, loops = get_connected_input(object, bm,
                context.scene, self.input)
            mapping = get_mapping(derived, bm, bm_mod, False, False, loops)
            loops = check_loops(loops, mapping, bm_mod)
        knots, points = relax_calculate_knots(loops)
        
        # saving cache for faster execution next time
        if not cached:
            cache_write("Relax", object, bm, self.input, False, False, loops,
                derived, mapping)
        
        for iteration in range(int(self.iterations)):
            # calculate splines and new positions
            tknots, tpoints = relax_calculate_t(bm_mod, knots, points,
                self.regular)
            splines = []
            for i in range(len(knots)):
                splines.append(calculate_splines(self.interpolation, bm_mod,
                    tknots[i], knots[i]))
            move = [relax_calculate_verts(bm_mod, self.interpolation,
                tknots, knots, tpoints, points, splines)]
            move_verts(object, bm, mapping, move, -1)
        
        # cleaning up
        if derived:
            bm_mod.free()
        terminate(global_undo)
        
        return{'FINISHED'}


# space operator
class Space(bpy.types.Operator):
    bl_idname = "mesh.looptools_space"
    bl_label = "Space"
    bl_description = "Space the vertices in a regular distrubtion on the loop"
    bl_options = {'REGISTER', 'UNDO'}
    
    influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    input = bpy.props.EnumProperty(name = "Input",
        items = (("all", "Parallel (all)", "Also use non-selected "\
                "parallel loops as input"),
            ("selected", "Selection","Only use selected vertices as input")),
        description = "Loops that are spaced",
        default = 'selected')
    interpolation = bpy.props.EnumProperty(name = "Interpolation",
        items = (("cubic", "Cubic", "Natural cubic spline, smooth results"),
            ("linear", "Linear", "Vertices are projected on existing edges")),
        description = "Algorithm used for interpolation",
        default = 'cubic')
    
    @classmethod
    def poll(cls, context):
        ob = context.active_object
        return(ob and ob.type == 'MESH' and context.mode == 'EDIT_MESH')
    
    def draw(self, context):
        layout = self.layout
        col = layout.column()
        
        col.prop(self, "interpolation")
        col.prop(self, "input")
        col.separator()
        
        col.prop(self, "influence")
    
    def invoke(self, context, event):
        # load custom settings
        settings_load(self)
        return self.execute(context)
    
    def execute(self, context):
        # initialise
        global_undo, object, bm = initialise()
        settings_write(self)
        # check cache to see if we can save time
        cached, single_loops, loops, derived, mapping = cache_read("Space",
            object, bm, self.input, False)
        if cached:
            derived, bm_mod = get_derived_bmesh(object, bm, context.scene)
        else:
            # find loops
            derived, bm_mod, loops = get_connected_input(object, bm,
                context.scene, self.input)
            mapping = get_mapping(derived, bm, bm_mod, False, False, loops)
            loops = check_loops(loops, mapping, bm_mod)
        
        # saving cache for faster execution next time
        if not cached:
            cache_write("Space", object, bm, self.input, False, False, loops,
                derived, mapping)
        
        move = []
        for loop in loops:
            # calculate splines and new positions
            if loop[1]: # circular
                loop[0].append(loop[0][0])
            tknots, tpoints = space_calculate_t(bm_mod, loop[0][:])
            splines = calculate_splines(self.interpolation, bm_mod,
                tknots, loop[0][:])
            move.append(space_calculate_verts(bm_mod, self.interpolation,
                tknots, tpoints, loop[0][:-1], splines))
        # move vertices to new locations
        move_verts(object, bm, mapping, move, self.influence)
        
        # cleaning up
        if derived:
            bm_mod.free()
        terminate(global_undo)
        
        return{'FINISHED'}


##########################################
####### GUI and registration #############
##########################################

# menu containing all tools
class VIEW3D_MT_edit_mesh_looptools(bpy.types.Menu):
    bl_label = "LoopTools"
    
    def draw(self, context):
        layout = self.layout
        
        layout.operator("mesh.looptools_bridge", text="Bridge").loft = False
        layout.operator("mesh.looptools_circle")
        layout.operator("mesh.looptools_curve")
        layout.operator("mesh.looptools_flatten")
        layout.operator("mesh.looptools_gstretch")
        layout.operator("mesh.looptools_bridge", text="Loft").loft = True
        layout.operator("mesh.looptools_relax")
        layout.operator("mesh.looptools_space")


# panel containing all tools
class VIEW3D_PT_tools_looptools(bpy.types.Panel):
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'
    bl_context = "mesh_edit"
    bl_label = "LoopTools"
    bl_options = {'DEFAULT_CLOSED'}

    def draw(self, context):
        layout = self.layout
        col = layout.column(align=True)
        lt = context.window_manager.looptools
        
        # bridge - first line
        split = col.split(percentage=0.15)
        if lt.display_bridge:
            split.prop(lt, "display_bridge", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_bridge", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_bridge", text="Bridge").loft = False
        # bridge - settings
        if lt.display_bridge:
            box = col.column(align=True).box().column()
            #box.prop(self, "mode")
            
            # top row
            col_top = box.column(align=True)
            row = col_top.row(align=True)
            col_left = row.column(align=True)
            col_right = row.column(align=True)
            col_right.active = lt.bridge_segments != 1
            col_left.prop(lt, "bridge_segments")
            col_right.prop(lt, "bridge_min_width", text="")
            # bottom row
            bottom_left = col_left.row()
            bottom_left.active = lt.bridge_segments != 1
            bottom_left.prop(lt, "bridge_interpolation", text="")
            bottom_right = col_right.row()
            bottom_right.active = lt.bridge_interpolation == 'cubic'
            bottom_right.prop(lt, "bridge_cubic_strength")
            # boolean properties
            col_top.prop(lt, "bridge_remove_faces")
            
            # override properties
            col_top.separator()
            row = box.row(align = True)
            row.prop(lt, "bridge_twist")
            row.prop(lt, "bridge_reverse")
        
        # circle - first line
        split = col.split(percentage=0.15)
        if lt.display_circle:
            split.prop(lt, "display_circle", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_circle", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_circle")
        # circle - settings
        if lt.display_circle:
            box = col.column(align=True).box().column()
            box.prop(lt, "circle_fit")
            box.separator()
            
            box.prop(lt, "circle_flatten")
            row = box.row(align=True)
            row.prop(lt, "circle_custom_radius")
            row_right = row.row(align=True)
            row_right.active = lt.circle_custom_radius
            row_right.prop(lt, "circle_radius", text="")
            box.prop(lt, "circle_regular")
            box.separator()
            
            box.prop(lt, "circle_influence")
        
        # curve - first line
        split = col.split(percentage=0.15)
        if lt.display_curve:
            split.prop(lt, "display_curve", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_curve", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_curve")
        # curve - settings
        if lt.display_curve:
            box = col.column(align=True).box().column()
            box.prop(lt, "curve_interpolation")
            box.prop(lt, "curve_restriction")
            box.prop(lt, "curve_boundaries")
            box.prop(lt, "curve_regular")
            box.separator()
            
            box.prop(lt, "curve_influence")
        
        # flatten - first line
        split = col.split(percentage=0.15)
        if lt.display_flatten:
            split.prop(lt, "display_flatten", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_flatten", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_flatten")
        # flatten - settings
        if lt.display_flatten:
            box = col.column(align=True).box().column()
            box.prop(lt, "flatten_plane")
            #box.prop(lt, "flatten_restriction")
            box.separator()
            
            box.prop(lt, "flatten_influence")
        
        # gstretch - first line
        split = col.split(percentage=0.15)
        if lt.display_gstretch:
            split.prop(lt, "display_gstretch", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_gstretch", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_gstretch")
        # gstretch settings
        if lt.display_gstretch:
            box = col.column(align=True).box().column()
            box.prop(lt, "gstretch_delete_strokes")
            box.prop(lt, "gstretch_method")
            box.separator()
            box.prop(lt, "gstretch_influence")
        
        # loft - first line
        split = col.split(percentage=0.15)
        if lt.display_loft:
            split.prop(lt, "display_loft", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_loft", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_bridge", text="Loft").loft = True
        # loft - settings
        if lt.display_loft:
            box = col.column(align=True).box().column()
            #box.prop(self, "mode")
            
            # top row
            col_top = box.column(align=True)
            row = col_top.row(align=True)
            col_left = row.column(align=True)
            col_right = row.column(align=True)
            col_right.active = lt.bridge_segments != 1
            col_left.prop(lt, "bridge_segments")
            col_right.prop(lt, "bridge_min_width", text="")
            # bottom row
            bottom_left = col_left.row()
            bottom_left.active = lt.bridge_segments != 1
            bottom_left.prop(lt, "bridge_interpolation", text="")
            bottom_right = col_right.row()
            bottom_right.active = lt.bridge_interpolation == 'cubic'
            bottom_right.prop(lt, "bridge_cubic_strength")
            # boolean properties
            col_top.prop(lt, "bridge_remove_faces")
            col_top.prop(lt, "bridge_loft_loop")
            
            # override properties
            col_top.separator()
            row = box.row(align = True)
            row.prop(lt, "bridge_twist")
            row.prop(lt, "bridge_reverse")
        
        # relax - first line
        split = col.split(percentage=0.15)
        if lt.display_relax:
            split.prop(lt, "display_relax", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_relax", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_relax")
        # relax - settings
        if lt.display_relax:
            box = col.column(align=True).box().column()
            box.prop(lt, "relax_interpolation")
            box.prop(lt, "relax_input")
            box.prop(lt, "relax_iterations")
            box.prop(lt, "relax_regular")
        
        # space - first line
        split = col.split(percentage=0.15)
        if lt.display_space:
            split.prop(lt, "display_space", text="", icon='DOWNARROW_HLT')
        else:
            split.prop(lt, "display_space", text="", icon='RIGHTARROW')
        split.operator("mesh.looptools_space")
        # space - settings
        if lt.display_space:
            box = col.column(align=True).box().column()
            box.prop(lt, "space_interpolation")
            box.prop(lt, "space_input")
            box.separator()
            
            box.prop(lt, "space_influence")


# property group containing all properties for the gui in the panel
class LoopToolsProps(bpy.types.PropertyGroup):
    """
    Fake module like class
    bpy.context.window_manager.looptools
    """
    
    # general display properties
    display_bridge = bpy.props.BoolProperty(name = "Bridge settings",
        description = "Display settings of the Bridge tool",
        default = False)
    display_circle = bpy.props.BoolProperty(name = "Circle settings",
        description = "Display settings of the Circle tool",
        default = False)
    display_curve = bpy.props.BoolProperty(name = "Curve settings",
        description = "Display settings of the Curve tool",
        default = False)
    display_flatten = bpy.props.BoolProperty(name = "Flatten settings",
        description = "Display settings of the Flatten tool",
        default = False)
    display_gstretch = bpy.props.BoolProperty(name = "Gstretch settings",
        description = "Display settings of the Gstretch tool",
        default = False)
    display_loft = bpy.props.BoolProperty(name = "Loft settings",
        description = "Display settings of the Loft tool",
        default = False)
    display_relax = bpy.props.BoolProperty(name = "Relax settings",
        description = "Display settings of the Relax tool",
        default = False)
    display_space = bpy.props.BoolProperty(name = "Space settings",
        description = "Display settings of the Space tool",
        default = False)
    
    # bridge properties
    bridge_cubic_strength = bpy.props.FloatProperty(name = "Strength",
        description = "Higher strength results in more fluid curves",
        default = 1.0,
        soft_min = -3.0,
        soft_max = 3.0)
    bridge_interpolation = bpy.props.EnumProperty(name = "Interpolation mode",
        items = (('cubic', "Cubic", "Gives curved results"),
            ('linear', "Linear", "Basic, fast, straight interpolation")),
        description = "Interpolation mode: algorithm used when creating "\
            "segments",
        default = 'cubic')
    bridge_loft = bpy.props.BoolProperty(name = "Loft",
        description = "Loft multiple loops, instead of considering them as "\
            "a multi-input for bridging",
        default = False)
    bridge_loft_loop = bpy.props.BoolProperty(name = "Loop",
        description = "Connect the first and the last loop with each other",
        default = False)
    bridge_min_width = bpy.props.IntProperty(name = "Minimum width",
        description = "Segments with an edge smaller than this are merged "\
            "(compared to base edge)",
        default = 0,
        min = 0,
        max = 100,
        subtype = 'PERCENTAGE')
    bridge_mode = bpy.props.EnumProperty(name = "Mode",
        items = (('basic', "Basic", "Fast algorithm"),
                 ('shortest', "Shortest edge", "Slower algorithm with " \
                                               "better vertex matching")),
        description = "Algorithm used for bridging",
        default = 'shortest')
    bridge_remove_faces = bpy.props.BoolProperty(name = "Remove faces",
        description = "Remove faces that are internal after bridging",
        default = True)
    bridge_reverse = bpy.props.BoolProperty(name = "Reverse",
        description = "Manually override the direction in which the loops "\
                      "are bridged. Only use if the tool gives the wrong " \
                      "result",
        default = False)
    bridge_segments = bpy.props.IntProperty(name = "Segments",
        description = "Number of segments used to bridge the gap "\
            "(0 = automatic)",
        default = 1,
        min = 0,
        soft_max = 20)
    bridge_twist = bpy.props.IntProperty(name = "Twist",
        description = "Twist what vertices are connected to each other",
        default = 0)
    
    # circle properties
    circle_custom_radius = bpy.props.BoolProperty(name = "Radius",
        description = "Force a custom radius",
        default = False)
    circle_fit = bpy.props.EnumProperty(name = "Method",
        items = (("best", "Best fit", "Non-linear least squares"),
            ("inside", "Fit inside","Only move vertices towards the center")),
        description = "Method used for fitting a circle to the vertices",
        default = 'best')
    circle_flatten = bpy.props.BoolProperty(name = "Flatten",
        description = "Flatten the circle, instead of projecting it on the " \
            "mesh",
        default = True)
    circle_influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    circle_radius = bpy.props.FloatProperty(name = "Radius",
        description = "Custom radius for circle",
        default = 1.0,
        min = 0.0,
        soft_max = 1000.0)
    circle_regular = bpy.props.BoolProperty(name = "Regular",
        description = "Distribute vertices at constant distances along the " \
            "circle",
        default = True)
    
    # curve properties
    curve_boundaries = bpy.props.BoolProperty(name = "Boundaries",
        description = "Limit the tool to work within the boundaries of the "\
            "selected vertices",
        default = False)
    curve_influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    curve_interpolation = bpy.props.EnumProperty(name = "Interpolation",
        items = (("cubic", "Cubic", "Natural cubic spline, smooth results"),
            ("linear", "Linear", "Simple and fast linear algorithm")),
        description = "Algorithm used for interpolation",
        default = 'cubic')
    curve_regular = bpy.props.BoolProperty(name = "Regular",
        description = "Distribute vertices at constant distances along the " \
            "curve",
        default = True)
    curve_restriction = bpy.props.EnumProperty(name = "Restriction",
        items = (("none", "None", "No restrictions on vertex movement"),
            ("extrude", "Extrude only","Only allow extrusions (no "\
                "indentations)"),
            ("indent", "Indent only", "Only allow indentation (no "\
                "extrusions)")),
        description = "Restrictions on how the vertices can be moved",
        default = 'none')
    
    # flatten properties
    flatten_influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    flatten_plane = bpy.props.EnumProperty(name = "Plane",
        items = (("best_fit", "Best fit", "Calculate a best fitting plane"),
            ("normal", "Normal", "Derive plane from averaging vertex "\
            "normals"),
            ("view", "View", "Flatten on a plane perpendicular to the "\
            "viewing angle")),
        description = "Plane on which vertices are flattened",
        default = 'best_fit')
    flatten_restriction = bpy.props.EnumProperty(name = "Restriction",
        items = (("none", "None", "No restrictions on vertex movement"),
            ("bounding_box", "Bounding box", "Vertices are restricted to "\
            "movement inside the bounding box of the selection")),
        description = "Restrictions on how the vertices can be moved",
        default = 'none')
    
    # gstretch properties
    gstretch_delete_strokes = bpy.props.BoolProperty(name="Delete strokes",
        description = "Remove Grease Pencil strokes if they have been used "\
            "for Gstretch",
        default = False)   
    gstretch_influence = bpy.props.FloatProperty(name = "Influence",
        description = "Force of the tool",
        default = 100.0,
        min = 0.0,
        max = 100.0,
        precision = 1,
        subtype = 'PERCENTAGE')
    gstretch_method = bpy.props.EnumProperty(name = "Method",
        items = (("project", "Project", "Project vertices onto the stroke, "\
            "using vertex normals and connected edges"),
            ("irregular", "Spread", "Distribute vertices along the full "\
            "stroke, retaining relative distances between the vertices"),
            ("regular", "Spread evenly", "Distribute vertices at regular "\
            "distances along the full stroke")),
        description = "Method of distributing the vertices over the Grease "\