mantis/utilities.py

#fool: should be wrColor like prColor... dumb

def wrapRed(skk):    return "\033[91m{}\033[00m".format(skk)
def wrapGreen(skk):  return "\033[92m{}\033[00m".format(skk)
def wrapPurple(skk): return "\033[95m{}\033[00m".format(skk)
def wrapWhite(skk):  return "\033[97m{}\033[00m".format(skk)
def wrapOrange(skk):  return "\033[0;33m{}\033[00m".format(skk)

# these should reimplement the print interface..
def prRed(*args): print (*[wrapRed(arg) for arg in args])
def prGreen(*args): print (*[wrapGreen(arg) for arg in args])
def prPurple(*args): print (*[wrapPurple(arg) for arg in args])
def prWhite(*args): print (*[wrapWhite(arg) for arg in args])
def prOrange(*args): print (*[wrapOrange(arg) for arg in args])



# add THIS to the top of a file for easy access:
# from mantis.utilities import (prRed, prGreen, prPurple, prWhite,
#                               prOrange,
#                               wrapRed, wrapGreen, wrapPurple, wrapWhite,
#                               wrapOrange,)

def float_lerp(a : float, b : float, factor : float)  -> float:
    return (a * (1.0 - factor)) + (b * factor)

# A fuction for getting to the end of a Reroute.
# TODO: this seems really inefficient!
def socket_seek(start_link, links):
    link = start_link
    while(link.from_socket):
        for newlink in links:
            if link.from_socket.node.inputs:
                if link.from_node.bl_idname != 'NodeReroute':
                    return link.from_socket
                if newlink.to_socket == link.from_socket.node.inputs[0]:
                    link=newlink; break
        else:
            break
    return link.from_socket

# THIS ONE is better. I don't know what I was thinking up above.
# TODO: try and refactor to use this function instead
def find_reroute_start_socket(reroute, track='BACK'):
    # "BACK" traces back through the tree
    # "FORWARD" traces forward through the tree
    socket = None
    while (reroute and track == 'BACK'):
        if len(reroute.inputs[0].links) == 1:
            link = reroute.inputs[0].links[0]
            socket = link.from_socket
            if link.from_node.bl_idname == 'NodeReroute':
                reroute =  link.from_node
            else:
                link, reroute = None, None
    while (reroute and track == 'FORWARD'):
        if len(reroute.outputs[0].links) == 1:
            link = reroute.outputs[0].links[0]
            socket = link.to_socket
            if link.to_node.bl_idname == 'NodeReroute':
                reroute =  link.to_node
            else:
                link, reroute = None, None
    return socket

# this creates fake links that have the same interface as Blender's
# so that I can bypass Reroutes
def clear_reroutes(links):
    from .base_definitions import DummyLink
    kept_links, rerouted_starts = [], []
    rerouted = []
    all_links = links.copy()
    while(all_links):
        link = all_links.pop()
        to_cls = link.to_socket.node.bl_idname
        from_cls = link.from_socket.node.bl_idname
        reroute_classes = ["NodeReroute"]
        if (to_cls in reroute_classes and
            from_cls in reroute_classes):
                rerouted.append(link)
        elif (to_cls in reroute_classes and not
            from_cls in reroute_classes):
                rerouted.append(link)
        elif (from_cls in reroute_classes and not
            to_cls in reroute_classes):
                rerouted_starts.append(link)
        else:
            kept_links.append(link)
    for start in rerouted_starts:
        from_socket = socket_seek(start, rerouted)
        new_link = DummyLink(from_socket=from_socket, to_socket=start.to_socket, nc_from=None, nc_to=None, multi_input_sort_id=start.multi_input_sort_id )
        kept_links.append(new_link)
    return kept_links

def tree_from_nc(sig, base_tree):
    if (sig[0] == 'MANTIS_AUTOGENERATED'):
        sig = sig[:-2] # cut off the end part of the signature (because it uses socket.name and socket.identifier)
        # this will lead to totally untraceble bugs in the event of a change in how signatures are assigned
    tree = base_tree
    for i, path_item in enumerate(sig):
        if (i == 0) or (i == len(sig) - 1):
            continue
        tree = tree.nodes.get(path_item).node_tree
    return tree
    
def get_node_prototype(sig, base_tree):
    return tree_from_nc(sig, base_tree).nodes.get( sig[-1] )


##################################################################################################
# groups and changing sockets -- this is used extensively by Schema.
##################################################################################################

# this one returns None if there is an error.
def get_socket_maps(node, force=False):
    maps = [{}, {}]
    node_collection = ["inputs", "outputs"]
    links = ["from_socket", "to_socket"]
    for collection, map, linked_socket in zip(node_collection, maps, links):
        for sock in getattr(node, collection):
            if sock.is_linked:
                other_sockets = []
                # Sort the links first (in case they are mult-input), because Blender doesn't
                links = sorted(list(sock.links), key = lambda l : l.multi_input_sort_id)
                # HACK here because Blender will crash if the socket values in the NodeReroute
                #  are mutated. Because this seems to happen in a deffered way, I can't account
                #  for it except by checking the node later...
                # TODO: The fact that I need this hack means I can probably solve this problem
                #  for all node types in a safer way, since they may also be dynamic somehow
                for l in links:
                    if "from" in linked_socket and l.from_node.bl_idname == "NodeReroute":
                        other_sockets.append(l.from_node)
                    elif "to" in linked_socket and l.to_node.bl_idname == "NodeReroute":
                        other_sockets.append(l.to_node)
                    else:
                        other_sockets.append(getattr(l, linked_socket))
                from bpy.types import NodeSocket
                keep_sockets=[]
                for other_socket in other_sockets.copy():
                    if isinstance(other_socket, NodeSocket) and \
                        other_socket.bl_idname == 'NodeSocketUndefined':
                            continue # this one is bad
                    keep_sockets.append(other_socket)
                # if len(keep_sockets) == 0:
                #     keep_sockets = None
                map[sock.identifier]= keep_sockets
            elif hasattr(sock, "default_value"):
                if sock.get("default_value") is not None:
                    val = sock['default_value']
                elif sock.bl_idname == "EnumCurveSocket" and sock.get("default_value") is None:
                    # HACK I need to add this special case because during file-load,
                    #  this value is None and should not be altered until it is set once.
                    continue
                elif "Enum" in sock.bl_idname and isinstance(sock.get("default_value"), int):
                    continue # for string enum properties that have not yet initialized (at startup)
                elif (val := sock.default_value) is not None:
                    pass
                elif not force:
                    continue
                map[sock.identifier]=val
            else:
                from .socket_definitions import no_default_value
                if sock.bl_idname in no_default_value:
                    map[sock.identifier]=None
                else:
                    raise RuntimeError(f"ERROR: Could not get socket data for socket of type: {sock.bl_idname}")
    return maps

# this function is completely overloaded with different purposes and code paths
# TODO refactor everything that funnels into this function
# make this stuff simpler.
def do_relink(node, s, map, in_out='INPUT', parent_name = ''):
    if not node.__class__.is_registered_node_type(): return
    tree = node.id_data; interface_in_out = 'OUTPUT' if in_out == 'INPUT' else 'INPUT'
    if hasattr(node, "node_tree"):
        tree = node.node_tree
        interface_in_out=in_out
    from bpy.types import NodeSocket, Node
    get_string = '__extend__'
    if s: get_string = s.identifier
    from .base_definitions import SchemaUINode
    if (hasattr(node, "node_tree") or isinstance(node, SchemaUINode)) and get_string not in map.keys():
        # this happens when we are creating a new node group and need to update it from nothing.
        return
    val = map[get_string] # this will throw an error if the socket isn't there. Good!
    if isinstance(val, list):
        for sub_val in val:
            # this will only happen once because it assigns s, so it is safe to do in the for loop.
            if s is None:
                socket = sub_val
                if sub_val.bl_idname == "NodeReroute":
                    # we have to trace the reroute node...
                    if in_out == 'INPUT':
                        socket = find_reroute_start_socket(sub_val)
                    else:
                        socket = find_reroute_start_socket(sub_val, track="FORWARD")
                name = unique_socket_name(node, socket, tree)
                if parent_name:
                    interface_socket = update_interface(tree.interface, name, interface_in_out, sock_type, parent_name)
                if in_out =='INPUT':
                    s = node.inputs.new(sock_type, name, identifier=interface_socket.identifier)
                else:
                    s = node.outputs.new(sock_type, name, identifier=interface_socket.identifier)
                if parent_name == 'Array': s.display_shape='SQUARE_DOT'
                if parent_name == 'Constant': s.display_shape='CIRCLE_DOT'
                # then move it up and delete the other link.
                # this also needs to modify the interface of the node tree.
            if isinstance(sub_val, NodeSocket):
                l = None
                if in_out =='INPUT':
                    l = node.id_data.links.new(input=sub_val, output=s)
                else:
                    l = node.id_data.links.new(input=s, output=sub_val)
                if l is None:
                    raise RuntimeError("Could not create link")
            elif isinstance(sub_val, Node):
                l = None
                # this happens when it is a NodeReroute
                if not s.is_output:
                    l = node.id_data.links.new(input=sub_val.outputs[0], output=s)
                else:
                    l = node.id_data.links.new(input=s, output=sub_val.inputs[0])
                if l is None:
                    raise RuntimeError("Could not create link")
            else:
                raise RuntimeError("Unhandled case in do_relink()")
    elif get_string != "__extend__":
        if not s.is_output:
            try:
                s.default_value = val
            except (AttributeError, ValueError): # must be readonly or maybe it doesn't have a d.v.
                pass

def update_interface(interface, name, in_out, sock_type, parent_name):
    from bpy.app import version as bpy_version
    if parent_name:
        if not (interface_parent := interface.items_tree.get(parent_name)):
            interface_parent = interface.new_panel(name=parent_name)
        if bpy_version != (4,5,0):
            socket = interface.new_socket(name=name,in_out=in_out, socket_type=sock_type, parent=interface_parent)
        else: # blender 4.5.0 LTS, have to workaround a bug!
            from .versioning import workaround_4_5_0_interface_update
            socket = workaround_4_5_0_interface_update(tree=interface.id_data, name=name, in_out=in_out,
                                                       sock_type=sock_type, parent_name=parent_name, do_parent=True)
        if parent_name == 'Connection':
            in_out = 'OUTPUT' if in_out == 'INPUT' else 'INPUT' # flip this make sure connections always do both
            interface.new_socket(name=name,in_out=in_out, socket_type=sock_type, parent=interface_parent)
        return socket
    else:
        raise RuntimeError(wrapRed("Cannot add interface item to tree without specifying type."))


# D.node_groups['Rigging Nodes'].interface.new_socket('beans', description='the b word', socket_type='NodeSocketGeometry')
#UGLY BAD REFACTOR
def relink_socket_map_add_socket(node, socket_collection, item, in_out=None,):
    from bpy.app import version as bpy_version
    if not in_out: in_out=item.in_out
    if node.bl_idname in ['MantisSchemaGroup'] and item.parent and item.parent.name == 'Array':
        multi = True if in_out == 'INPUT' else False
        # have to work around a bug in 4.5.0 that prevents me from declaring custom socket types
        # I have arbitrarily chosen to use the NodeSocketGeometry type to signal that this one is affected.
        if bpy_version == (4, 5, 0) and item.bl_socket_idname == 'NodeSocketGeometry':
            from .versioning import socket_add_workaround_for_4_5_0_LTS
            s = socket_add_workaround_for_4_5_0_LTS(item, socket_collection, multi)
        else:
            s = socket_collection.new(type=item.bl_socket_idname, name=item.name, identifier=item.identifier,  use_multi_input=multi)
    else:
        if bpy_version == (4, 5, 0) and item.bl_socket_idname == 'NodeSocketGeometry':
            from .versioning import socket_add_workaround_for_4_5_0_LTS
            s = socket_add_workaround_for_4_5_0_LTS(item, socket_collection, multi=False,)
        else:
            s = socket_collection.new(type=item.bl_socket_idname, name=item.name, identifier=item.identifier)
    if item.parent.name == 'Array': s.display_shape = 'SQUARE_DOT'
    elif item.parent.name == 'Constant': s.display_shape='CIRCLE_DOT'
    return s

# TODO REFACTOR THIS
# I did this awful thing because I needed the above code
# but I have provided this interface to Mantis
# I did not follow the Single Responsibility Principle
# I am now suffering for it, as I rightly deserve.
def relink_socket_map(node, socket_collection, map, item, in_out=None,):
    s = relink_socket_map_add_socket(node, socket_collection, item, in_out=None,)
    do_relink(node, s, map)

def unique_socket_name(node, other_socket, tree):
    name_stem = other_socket.bl_label; num=0
    # if hasattr(other_socket, "default_value"):
    #     name_stem = type(other_socket.default_value).__name__
    for item in tree.interface.items_tree:
        if item.item_type == 'PANEL': continue
        if other_socket.is_output and item.in_out == 'INPUT': continue
        if not other_socket.is_output and item.in_out == 'OUTPUT': continue
        if name_stem in item.name: num+=1
    name = name_stem + '.' + str(num).zfill(3)
    return name

##############################
# Dealing with Objects
##############################

# use this to ensure the active object is set back when changing it
def preserve_active_object(func):
    def wrapper(*args, **kwargs):
        import bpy
        original_active = bpy.context.active_object
        func(*args, **kwargs)
        bpy.context.view_layer.objects.active = original_active
    return wrapper

def switch_mode(mode='OBJECT', objects = []):
    active = None
    if objects:
        from bpy import context, ops
        active = objects[-1]
        context.view_layer.objects.active = active
        if (active):
            with context.temp_override(**{'active_object':active, 'selected_objects':objects}):
                ops.object.mode_set(mode=mode)
    return active

# run this in Object mode, during bFinalize
@preserve_active_object
def bind_modifier_operator(modifier, operator):
        # now we have to bind it
        ob = modifier.id_data
        ob.modifiers.active = modifier
        import bpy
        bpy.context.view_layer.objects.active = ob
        # Context override does not do anything here... it isn't handled in the C code
        # I have verified this by building Blender with print statements to debug.

        # let's just make sure the target object has its modifiers disabled and update the dg
        targ_attr = "target"
        if hasattr(modifier, "object"): targ_attr = "object"
        target = getattr(modifier, targ_attr)
        if target:
            prWhite(f"Binding Deformer {modifier.name} to target {target.name}")
            operator(modifier=modifier.name)

def import_widget_obj(path,):
    from bpy.app import version as bpy_version
    from bpy import context, data
    from os import path as os_path
    file_name = os_path.split(path)[-1]
    obj_name = os_path.splitext(file_name)[0]
    if bpy_version < (4,5,0):
        original_active = context.active_object
        # for blender versions prior to 4.5.0, we have to import with an operator
        from bpy.ops import wm as wm_ops
        ob_names_before = data.objects.keys()
        wm_ops.obj_import(
            filepath=path,
            check_existing=False,
            forward_axis='NEGATIVE_Z',
            up_axis='Y',
            validate_meshes=True,)
        # just make sure the active object doesn't change
        context.view_layer.objects.active = original_active
        # the below is a HACK... I can find the objects in the .obj file
        # by scanning the file for the "o" prefix and checking the name.
        # but that may be slow if the obj is big. which would make a bad widget!
        ob = None
        for ob in data.objects:
            if ob.name in ob_names_before: continue
            return ob # return the first one, that should be the one
        else: # no new object was found - fail.
            # I don't expect this to happen unless there is an error in the operator.
            raise RuntimeError(f"Failed to import {file_name}. This is probably"
                                "a bug or a corrupted file.")
    else:
        prWhite(f"INFO: using Geometry Nodes to import {file_name}")
        mesh = data.meshes.new(obj_name)
        ob = data.objects.new(name=obj_name, object_data=mesh)
        # we'll do a geometry nodes import
        context.collection.objects.link(ob)
        import_modifier = ob.modifiers.new("Import OBJ", type="NODES")
        ng = data.node_groups.get("Import OBJ")
        if ng is None:
            from .geometry_node_graphgen import gen_import_obj_node_group
            ng = gen_import_obj_node_group()
        import_modifier.node_group = ng
        import_modifier["Socket_0"]=path
        return ob

def import_object_from_file(path):
    # first let's check to see if we need it.
    from os import path as os_path
    file_name = os_path.split(path)[-1]
    obj_name = os_path.splitext(file_name)[0]
    extension = os_path.splitext(file_name)[1]
    if extension == '.obj':
        return import_widget_obj(path,)
    else:
        raise RuntimeError(f"Failed to parse filename {path}")
        

##############################
#  READ TREE and also Schema Solve!
##############################

# TODO: refactor the following two functions, they should be one function with arguments.
def init_connections(nc):
    c, hc = [], []
    for i in nc.outputs.values():
        for l in i.links:
            # if l.from_node != nc:
            #     continue
            if l.is_hierarchy:
                hc.append(l.to_node)
            c.append(l.to_node)
    nc.hierarchy_connections = hc
    nc.connections = c

def init_dependencies(nc):
    c, hc = [], []
    for i in nc.inputs.values():
        for l in i.links:
            # if l.to_node != nc:
            #     continue
            if l.is_hierarchy:
                hc.append(l.from_node)
            c.append(l.from_node)
    nc.hierarchy_dependencies = hc
    nc.dependencies = c

def schema_dependency_handle_item(schema, all_nc, item,):
    hierarchy = True
    from .base_definitions import from_name_filter, to_name_filter
    if item.in_out == 'INPUT':
        dependencies = schema.dependencies
        hierarchy_dependencies = schema.hierarchy_dependencies
        if item.parent and item.parent.name == 'Array':
            for schema_idname in ['SchemaArrayInput', 'SchemaArrayInputGet', 'SchemaArrayInputAll']:
                if (nc := all_nc.get( (*schema.signature, schema_idname) )):
                    for to_link in nc.outputs[item.name].links:
                        if to_link.to_socket in to_name_filter:
                            # hierarchy_reason='a'
                            hierarchy = False
                    for from_link in schema.inputs[item.identifier].links:
                        if from_link.from_socket in from_name_filter:
                            hierarchy = False
                            # hierarchy_reason='b'
                        if from_link.from_node not in dependencies:
                            if hierarchy:
                                hierarchy_dependencies.append(from_link.from_node)
                            dependencies.append(from_link.from_node)
        if item.parent and item.parent.name == 'Constant':
            if nc := all_nc.get((*schema.signature, 'SchemaConstInput')):
                for to_link in nc.outputs[item.name].links:
                    if to_link.to_socket in to_name_filter:
                        # hierarchy_reason='dependencies'
                        hierarchy = False
                for from_link in schema.inputs[item.identifier].links:
                    if from_link.from_socket in from_name_filter:
                        # hierarchy_reason='d'
                        hierarchy = False
                    if from_link.from_node not in dependencies:
                        if hierarchy:
                            hierarchy_dependencies.append(from_link.from_node)
                        dependencies.append(from_link.from_node)
        if item.parent and item.parent.name == 'Connection':
            if nc := all_nc.get((*schema.signature, 'SchemaIncomingConnection')):
                for to_link in nc.outputs[item.name].links:
                    if to_link.to_socket in to_name_filter:
                        # hierarchy_reason='e'
                        hierarchy = False
                for from_link in schema.inputs[item.identifier].links:
                    if from_link.from_socket in from_name_filter:
                        # hierarchy_reason='f'
                        hierarchy = False
                    if from_link.from_node not in dependencies:
                        if hierarchy:
                            hierarchy_dependencies.append(from_link.from_node)
                        dependencies.append(from_link.from_node)

def init_schema_dependencies(schema, all_nc):
    """ Initialize the dependencies for Schema, and mark them as hierarchy or non-hierarchy dependencies
        Non-hierarchy dependencies are e.g. drivers and custom transforms.
    """
    tree = schema.prototype.node_tree
    if tree is None:
        raise RuntimeError(f"Cannot get dependencies for schema {schema}")
    schema.dependencies = []
    schema.hierarchy_dependencies = []
    for l in schema.inputs["Schema Length"].links:
        schema.hierarchy_dependencies.append(l.from_node)
    if tree.interface:
        for item in tree.interface.items_tree:
            if item.item_type == 'PANEL':
                continue
            schema_dependency_handle_item(schema, all_nc, item,)

def check_and_add_root(n, roots, include_non_hierarchy=False):
    if (include_non_hierarchy * len(n.dependencies)) > 0:
        return 
    elif len(n.hierarchy_dependencies) > 0:
        return
    roots.append(n)

def get_link_in_out(link):
    from .base_definitions import replace_types
    from_name, to_name = link.from_socket.node.name, link.to_socket.node.name
    # catch special bl_idnames and bunch the connections up
    if link.from_socket.node.bl_idname in replace_types:
        from_name = link.from_socket.node.bl_idname 
    if link.to_socket.node.bl_idname in replace_types:
        to_name = link.to_socket.node.bl_idname
    return from_name, to_name

def link_node_containers(tree_path_names, link, local_nc, from_suffix='', to_suffix=''):
    dummy_types = ["DUMMY", "DUMMY_SCHEMA"]
    from_name, to_name = get_link_in_out(link)
    nc_from = local_nc.get( (*tree_path_names, from_name+from_suffix) )
    nc_to = local_nc.get( (*tree_path_names, to_name+to_suffix))
    if (nc_from and nc_to):
        from_s, to_s = link.from_socket.name, link.to_socket.name
        if nc_to.node_type in dummy_types: to_s = link.to_socket.identifier
        if nc_from.node_type in dummy_types: from_s = link.from_socket.identifier
        try:
            connection = nc_from.outputs[from_s].connect(node=nc_to, socket=to_s, sort_id=link.multi_input_sort_id)
            if connection is None:
                prWhite(f"Already connected: {from_name}:{from_s}->{to_name}:{to_s}")
            return connection
        except KeyError as e:
            prRed(f"{nc_from}:{from_s} or {nc_to}:{to_s} missing; review the connections printed below:")
            print (nc_from.outputs.keys())
            print (nc_to.inputs.keys())
            raise e
    else:
        prRed(nc_from, nc_to, (*tree_path_names, from_name+from_suffix), (*tree_path_names, to_name+to_suffix))
        raise RuntimeError(wrapRed("Link not connected: %s -> %s in tree %s" % (from_name, to_name, tree_path_names[-1])))
    
def get_all_dependencies(nc):
    from .base_definitions import GraphError
    """ find all dependencies for a mantis node"""
    nodes = []
    check_nodes = [nc]
    nodes_checked = set()
    while (len(check_nodes) > 0):
        node = check_nodes.pop()
        nodes_checked.add (node)
        connected_nodes = node.hierarchy_dependencies
        for new_node in connected_nodes:
            if new_node in nodes:
                continue
            nodes.append(new_node)
            if new_node not in nodes_checked:
                check_nodes.append(new_node)
    return nodes
                
def get_all_nodes_of_type(base_tree, bl_idname):
    nodes = []
    check_nodes = list(base_tree.nodes)
    while (len(check_nodes) > 0):
        node = check_nodes.pop()
        if node.bl_idname in bl_idname:
            nodes.append(node)
        if hasattr(node, "node_tree"):
            check_nodes.extend(list(node.node_tree.nodes))
    return nodes

def trace_all_nodes_from_root(root, nodes):
    from .base_definitions import GraphError
    """ find all dependencies for a mantis node"""
    nodes.add(root); check_nodes = [root]
    nodes_checked = set()
    while (len(check_nodes) > 0):
        node = check_nodes.pop(); nodes_checked.add (node)
        connected_nodes = []
        for output in node.outputs:
            for l in output.links:
                if l.to_node not in nodes:
                    connected_nodes.append(l.to_node)
        for new_node in connected_nodes:
            nodes.add(new_node)
            if new_node not in nodes_checked:
                check_nodes.append(new_node)
    return nodes
            
##################################################################################################
# misc
##################################################################################################

# TODO: get the matrix to return a mathutils.Matrix so I don't need a function call here
def to_mathutils_value(socket):
    if hasattr(socket, "default_value"):
        val = socket.default_value
        if socket.bl_idname in ['MatrixSocket']:
            return socket.TellValue()
        else:
            return val
    else:
        return None


def all_trees_in_tree(base_tree, selected=False):
    """ Recursively finds all trees referenced in a given base-tree."""
    # note that this is recursive but not by tail-end recursion
    # a while-loop is a better way to do recursion in Python.
    trees = [base_tree]
    can_descend = True
    check_trees = [base_tree]
    while (len(check_trees) > 0): # this seems innefficient, why 2 loops?
        new_trees = []
        while (len(check_trees) > 0):
            tree = check_trees.pop()
            for node in tree.nodes:
                if selected == True and node.select == False:
                    continue
                if new_tree := getattr(node, "node_tree", None):
                    if new_tree in trees: continue 
                    new_trees.append(new_tree)
                    trees.append(new_tree)
        check_trees = new_trees
    return trees

# this is a destructive operation, not a pure function or whatever. That isn't good but I don't care.
def SugiyamaGraph(tree, iterations):
        from grandalf.graphs import Vertex, Edge, Graph, graph_core
        class defaultview(object):
            w,h = 1,1
            xz = (0,0)
        
        graph = Graph()
        no_links = set()
        verts = {}
        for n in tree.nodes:
            if n.select == True:
                v = Vertex(n.name)
                v.view = defaultview()
                v.view.xy = n.location
                v.view.h = n.height*2.5
                v.view.w = n.width*2.2
                verts[n.name] = v
                no_links.add(n.name)
                graph.add_vertex(v)
            n.select=False
            
        edges = []
        inverted_edges=[]
        not_a_root = set()
        for link in tree.links:
            if (link.from_node.name not in verts.keys()) or (link.to_node.name not in verts.keys()):
                continue # problem??
            weight = 1 # maybe this is useful
            not_a_root.add(link.to_node.name) # if it has a edge-input it is not a root.
            e = Edge(verts[link.from_node.name], verts[link.to_node.name], weight)
            graph.add_edge(e)
            edges.append(e )
            if link.is_valid == False:
                inverted_edges.append(e)
            if link.from_node.name in no_links:
                no_links.remove(link.from_node.name)
            if link.to_node.name in no_links:
                no_links.remove(link.to_node.name)
        try:
            from grandalf.layouts import SugiyamaLayout
            # .C[0] is the first "graph core" that contains a connected graph.
            sug = SugiyamaLayout(graph.C[0]) 
            sug.init_all()
            sug.draw(iterations)
            # Digco is good for small graphs.
            # from grandalf.layouts import DigcoLayout
            # dco = DigcoLayout(graph.C[0])
            # dco.init_all()
            # dco.draw(iterations)
        except KeyboardInterrupt:
            pass # just use what it has calculated so far, I guess

        for v in graph.C[0].sV:
            for n in tree.nodes:
                if n.name == v.data:
                    n.location.x = v.view.xy[1]
                    n.location.y = v.view.xy[0]
                    n.select = True
        
        # now we can take all the input nodes and try to put them in a sensible place
        # not sure why but this absolutely does not do anything
        for n_name in no_links:
            n = tree.nodes.get(n_name)
            next_node = None
            for output in n.outputs:
                if output.is_linked == True:
                    next_node = output.links[0].to_node
                    break
            # let's see if the next node
            if next_node:
                # need to find the other node in the same layer...
                other_node = None
                for s_input in next_node.inputs:
                    if s_input.is_linked:
                        other_node = s_input.links[0].from_node
                        if other_node is n:
                            continue
                        else:
                            break
                if other_node:
                    n.location = other_node.location
                    n.location.y -= other_node.height*2
                else: # we'll just position it next to the next node
                    n.location = next_node.location
                    n.location.x -= next_node.width*1.5
        

def project_point_to_plane(point, origin, normal):
    return point - normal.dot(point- origin)*normal

##################################################################################################
# stuff I should probably refactor!!
##################################################################################################

# This is really, really stupid way to do this
def gen_nc_input_for_data(socket):
    # Class List #TODO deduplicate
    from . import xForm_nodes, link_nodes, misc_nodes, primitives_nodes, deformer_nodes, math_nodes, schema_nodes
    from .internal_containers import NoOpNode
    classes = {}
    for module in [xForm_nodes, link_nodes, misc_nodes, primitives_nodes, deformer_nodes, math_nodes, schema_nodes]:
        for cls in module.TellClasses():
            classes[cls.__name__] = cls
    #
    socket_class_map = {
                        "MatrixSocket"                         : classes["InputMatrix"],
                        "xFormSocket"                          : None,
                        "RelationshipSocket"                   : NoOpNode,
                        "DeformerSocket"                       : NoOpNode,
                        "GeometrySocket"                       : classes["InputExistingGeometryData"],
                        "EnableSocket"                         : classes["InputBoolean"],
                        "HideSocket"                           : classes["InputBoolean"],
                        #
                        "DriverSocket"                         : None,
                        "DriverVariableSocket"                 : None, 
                        "FCurveSocket"                         : None, 
                        "KeyframeSocket"                       : None,
                        "BoneCollectionSocket"                 : classes["InputString"],
                        #
                        "xFormParameterSocket"                 : None,
                        "ParameterBoolSocket"                  : classes["InputBoolean"],
                        "ParameterIntSocket"                   : classes["InputFloat"],  #TODO: make an Int node for this
                        "ParameterFloatSocket"                 : classes["InputFloat"],
                        "ParameterVectorSocket"                : classes["InputVector"],
                        "ParameterStringSocket"                : classes["InputString"],
                        #
                        "TransformSpaceSocket"                 : classes["InputTransformSpace"],
                        "BooleanSocket"                        : classes["InputBoolean"],
                        "BooleanThreeTupleSocket"              : classes["InputBooleanThreeTuple"],
                        "RotationOrderSocket"                  : classes["InputRotationOrder"],
                        "QuaternionSocket"                     : None,
                        "QuaternionSocketAA"                   : None,
                        "UnsignedIntSocket"                    : classes["InputFloat"],
                        "IntSocket"                            : classes["InputFloat"],
                        "StringSocket"                         : classes["InputString"],
                        #
                        "BoolUpdateParentNode"                 : classes["InputBoolean"],
                        "IKChainLengthSocket"                  : classes["InputFloat"],
                        "EnumInheritScale"                     : classes["InputString"],
                        "EnumRotationMix"                      : classes["InputString"],
                        "EnumRotationMixCopyTransforms"        : classes["InputString"],
                        "EnumMaintainVolumeStretchTo"          : classes["InputString"],
                        "EnumRotationStretchTo"                : classes["InputString"],
                        "EnumTrackAxis"                        : classes["InputString"],
                        "EnumUpAxis"                           : classes["InputString"],
                        "EnumLockAxis"                         : classes["InputString"],
                        "EnumLimitMode"                        : classes["InputString"],
                        "EnumYScaleMode"                       : classes["InputString"],
                        "EnumXZScaleMode"                      : classes["InputString"],
                        "EnumCurveSocket"                      : classes["InputString"],
                        "EnumMetaRigSocket"                    : classes["InputString"],
                        # Deformers
                        "EnumSkinning"                         : classes["InputString"],
                        #
                        "FloatSocket"                          : classes["InputFloat"],
                        "FloatFactorSocket"                    : classes["InputFloat"],
                        "FloatPositiveSocket"                  : classes["InputFloat"],
                        "FloatAngleSocket"                     : classes["InputFloat"],
                        "VectorSocket"                         : classes["InputVector"],
                        "VectorEulerSocket"                    : classes["InputVector"],
                        "VectorTranslationSocket"              : classes["InputVector"],
                        "VectorScaleSocket"                    : classes["InputVector"],
                        # Drivers             
                        "EnumDriverVariableType"               : classes["InputString"],
                        "EnumDriverVariableEvaluationSpace"    : classes["InputString"],
                        "EnumDriverRotationMode"               : classes["InputString"],
                        "EnumDriverType"                       : classes["InputString"],
                        "EnumKeyframeInterpTypeSocket"         : classes["InputString"],
                        "EnumKeyframeBezierHandleTypeSocket"   : classes["InputString"],
                        # Math
                        "MathFloatOperation"                   : classes["InputString"],
                        "MathVectorOperation"                  : classes["InputString"],
                        "MatrixTransformOperation"             : classes["InputString"],
                        # Schema
                        "WildcardSocket"                       : None,
                       }
    return socket_class_map.get(socket.bl_idname, None)

####################################
# CURVE STUFF
####################################

def make_perpendicular(v1, v2):
    from .base_definitions import FLOAT_EPSILON
    if (v1.length_squared < FLOAT_EPSILON) or (v2.length_squared < FLOAT_EPSILON):
        raise RuntimeError("Cannot generate perpendicular vetor for zero-length vector")
    projected = (v2.dot(v1) / v1.dot(v1)) * v1
    perpendicular = v2 - projected
    return perpendicular

# this stuff could be branchless but I don't use it much TODO
def cap(val, maxValue):
    if (val > maxValue):
        return maxValue
    return val

def capMin(val, minValue):
    if (val < minValue):
        return minValue
    return val

def wrap(min : float, max : float, value: float) -> float:
    range = max-min; remainder = value % range
    if remainder > max: return min + remainder-max
    else: return remainder

def lerpVal(a, b, fac = 0.5):
    return a + ( (b-a) * fac)

#wtf this doesn't do anything even remotely similar to wrap
# HACK BAD FIXME UNBREAK ME BAD
# I don't understand what this function does but I am using it in multiple places?
def old_bad_wrap_that_should_be_refactored(val, maxValue, minValue = None):
    if (val > maxValue):
        return (-1 * ((maxValue - val) + 1))
    if ((minValue) and (val < minValue)):
        return (val + maxValue)
    return val
    #TODO clean this up

def extract_spline_suffix(spline_index):
    return ".spline."+str(spline_index).zfill(3)+".extracted"

def do_extract_spline(data, spline):
    remove_me = []
    for other_spline in data.splines:
        if other_spline != spline: remove_me.append(other_spline)
    while remove_me: data.splines.remove(remove_me.pop())

def extract_spline(curve, spline_index):
    """ Given a curve object and spline index, returns a new object
        containing only the selcted spline. The new object is bound to
        the original curve.
    """
    if len(curve.data.splines) == 1:
        return curve # nothing to do here.
    spline_suffix = extract_spline_suffix(spline_index)
    from bpy import data
    if (new_ob := data.objects.get(curve.name+spline_suffix)) is None:
        new_ob=curve.copy(); new_ob.name=curve.name+spline_suffix
    # if the data exists, it is probably stale, so delete it and start over.
    if (old_data := data.objects.get(curve.data.name+spline_suffix)) is not None:
        data.curves.remove(old_data)
    new_data=curve.data.copy(); new_data.name=curve.data.name+spline_suffix
    new_ob.data = new_data
    # do not check for index error here, it is the calling function's responsibility
    do_extract_spline(new_data, new_data.splines[spline_index])
    return new_ob

def bind_extracted_spline_to_curve(new_ob, curve):
    # Set up a relationship between the new object and the old object
    # now, weirdly enough - we can't use parenting very easily because Blender
    # defines the parent on a curve relative to the evaluated path animation
    # Setting the inverse matrix is too much work. Use Copy Transforms instead.
    from .xForm_nodes import reset_object_data
    reset_object_data(new_ob)
    c = new_ob.constraints.new("COPY_TRANSFORMS"); c.target=curve
    new_ob.parent=curve
    return new_ob

def get_extracted_spline_object(proto_curve, spline_index, mContext):
    # we're storing it separately like this to ensure all nodes use the same
    #   object if they extract the same spline for use by Mantis.
    # this should be transparent to the user since it is working around a
    #   a limitation in Blender.
    extracted_spline_name = proto_curve.name+extract_spline_suffix(spline_index)
    if curve := mContext.b_objects.get(extracted_spline_name):
        return curve
    else:
        curve = extract_spline(proto_curve, spline_index)
        if curve.name != proto_curve.name: # if there is only one spline, no
            bind_extracted_spline_to_curve(curve, proto_curve)# dupe is created.
        mContext.b_objects[extracted_spline_name] = curve
        return curve

def nurbs_copy_bez_spline(curve, bez_spline, do_setup=True):
    other_spline= curve.data.splines.new('NURBS')
    other_spline.use_endpoint_u=True
    other_spline.use_bezier_u=True
    bez_pts = bez_spline.bezier_points
    bez_data=[]
    for i, bez_pt in enumerate(bez_pts):
        if i > 0:
            bez_data.append(bez_pt.handle_left.copy())
        bez_data.append(bez_pt.co.copy())
        if i != len(bez_pts)-1:
            bez_data.append(bez_pt.handle_right.copy())
    other_spline.points.add(len(bez_data)-1)
    for i, pt in enumerate(bez_data):
        other_spline.points[i].co=(*pt,1.0) # add the W value here
    if do_setup: # do the stuff that makes it behave the same as a bez spline
        other_spline.use_endpoint_u = True; other_spline.use_bezier_u = True
        other_spline.order_u=4 # set to 1 for poly
    return other_spline

def RibbonMeshEdgeLengths(m, ribbon):
    tE = ribbon[0]; bE = ribbon[1]; c = ribbon[2]
    lengths = []
    for i in range( len( tE ) ): #tE and bE are same length
        if (c == True):
            v1NextInd = tE[old_bad_wrap_that_should_be_refactored((i+1), len(tE) - 1)]
        else:
            v1NextInd = tE[cap((i+1) , len(tE) - 1 )]
        v1 = m.vertices[tE[i]]; v1Next = m.vertices[v1NextInd]
        if (c == True):
            v2NextInd = bE[old_bad_wrap_that_should_be_refactored((i+1), len(bE) - 1)]
        else:
            v2NextInd = bE[cap((i+1) , len(bE) - 1 )]
        v2 = m.vertices[bE[i]]; v2Next = m.vertices[v2NextInd]
        
        v = v1.co.lerp(v2.co, 0.5); vNext = v1Next.co.lerp(v2Next.co, 0.5)
        # get the center, edges may not be straight so total length 
        #  of one edge may be more than the ribbon center's length
        lengths.append(( v - vNext ).length)
    return lengths

def EnsureCurveIsRibbon(crv, defaultRadius = 0.1):
    from .base_definitions import FLOAT_EPSILON
    crvRadius = 0
    crv.data.offset = 0
    if (crv.data.bevel_depth < FLOAT_EPSILON):
        crvRadius = crv.data.extrude
    else: #Set ribbon from bevel depth
        crvRadius = crv.data.bevel_depth
        crv.data.bevel_depth = 0
        crv.data.extrude = crvRadius
    if (crvRadius < FLOAT_EPSILON):
        crv.data.extrude = defaultRadius

def SetRibbonData(m, ribbon):
    #maybe this could be incorporated into the DetectWireEdges function?
    #maybe I can check for closed poly curves here? under what other circumstance
    # will I find the ends of the wire have identical coordinates?
    ribbonData = []
    tE = ribbon[0].copy(); bE = ribbon[1].copy()# circle = ribbon[2]
    #
    lengths = RibbonMeshEdgeLengths(m, ribbon)
    lengths.append(0)
    totalLength = sum(lengths)
    # m.calc_normals() #calculate normals
    # it appears this has been removed.
    for i, (t, b) in enumerate(zip(tE, bE)):
        ind = old_bad_wrap_that_should_be_refactored( (i + 1), len(tE) - 1 )
        tNext = tE[ind]; bNext = bE[ind]
        ribbonData.append(  ( (t,b), (tNext, bNext), lengths[i] ) )
        #if this is a circle, the last v in vertData has a length, otherwise 0
    return ribbonData, totalLength

def WireMeshEdgeLengths(m, wire):
    circle = False
    vIndex = wire.copy()
    for e in m.edges:
        if ((e.vertices[0] == vIndex[-1]) and (e.vertices[1] == vIndex[0])):
            #this checks for an edge between the first and last vertex in the wire
            circle = True
            break
    lengths = []
    for i in range(len(vIndex)):
        v = m.vertices[vIndex[i]]
        if (circle == True):
            vNextInd = vIndex[old_bad_wrap_that_should_be_refactored((i+1), len(vIndex) - 1)]
        else:
            vNextInd = vIndex[cap((i+1), len(vIndex) - 1 )]
        vNext = m.vertices[vNextInd]
        lengths.append(( v.co - vNext.co ).length)
    #if this is a circular wire mesh, this should wrap instead of cap
    return lengths

def GetDataFromWire(m, wire):
    vertData = []
    vIndex = wire.copy()
    lengths = WireMeshEdgeLengths(m, wire)
    lengths.append(0)
    totalLength = sum(lengths)
    for i, vInd in enumerate(vIndex):
        #-1 to avoid IndexError
        vNext = vIndex[ (old_bad_wrap_that_should_be_refactored(i+1, len(vIndex) - 1)) ]
        vertData.append((vInd, vNext, lengths[i]))
    #if this is a circle, the last v in vertData has a length, otherwise 0
    return vertData, totalLength

def DetectWireEdges(mesh):
    # Returns a list of vertex indices belonging to wire meshes
    # NOTE: this assumes a mesh object with only wire meshes
    ret = []
    import bmesh
    bm = bmesh.new()
    try:
        bm.from_mesh(mesh)
        ends = []
        for v in bm.verts:
            if (len(v.link_edges) == 1):
                ends.append(v.index)
        for e in bm.edges:
            assert (e.is_wire == True),"This function can only run on wire meshes"
            if (e.verts[1].index - e.verts[0].index != 1):
                ends.append(e.verts[1].index)
                ends.append(e.verts[0].index)
        for i in range(len(ends)//2): # // is floor division
            beg = ends[i*2]
            end = ends[(i*2)+1]
            indices = [(j + beg) for j in range ((end - beg) + 1)]
            ret.append(indices)
    finally:
        bm.free()
        return ret

def FindNearestPointOnWireMesh(m, pointsList):
    from mathutils import Vector
    from mathutils.geometry import intersect_point_line
    from math import sqrt
    wires = DetectWireEdges(m)
    ret = []
    # prevFactor = None
    for wire, points in zip(wires, pointsList):
        vertData, total_length = GetDataFromWire(m, wire)
        factorsOut = []
        for p in points:
            prevDist = float('inf')
            curDist  = float('inf')
            v1 = None
            v2 = None
            for i in range(len(vertData) - 1):
                #but it shouldn't check the last one
                if (p == m.vertices[i].co):
                    v1 = vertData[i]
                    v2 = vertData[i+1]
                    offset = 0
                    break
                else:
                    curDist = ( ((m.vertices[vertData[i][0]].co - p).length) +
                                ((m.vertices[vertData[i][1]].co - p).length) )/2
                if (curDist < prevDist):
                    v1 = vertData[i]
                    v2 = vertData[i+1]
                    prevDist = curDist
                    offset = intersect_point_line(p, m.vertices[v1[0]].co, 
                                                     m.vertices[v2[0]].co)[1]
            if (offset < 0):
                offset = 0
            elif (offset > 1):
                offset = 1
            # Assume the vertices are in order
            v1Length = 0
            v2Length = v2[2]
            for i in range(v1[0]):
                v1Length += vertData[i][2]
            factor = ((offset * (v2Length)) + v1Length )/total_length
            factor = wrap(0, 1, factor) # doesn't hurt to wrap it if it's over 1 or less than 0
            factorsOut.append(factor)
        ret.append( factorsOut )
    return ret


def mesh_from_curve(crv, context, ribbon=True):
    """Utility function for converting a mesh to a curve
       which will return the correct mesh even with modifiers"""
    import bpy
    m = None
    bevel = crv.data.bevel_depth
    extrude = crv.data.extrude
    offset = crv.data.offset
    try:
        if (len(crv.modifiers) > 0):
            do_unlink = False
            if (not context.scene.collection.all_objects.get(crv.name)):
                context.collection.objects.link(crv) # i guess this forces the dg to update it?
                do_unlink = True
            dg = context.view_layer.depsgraph
            # just gonna modify it for now lol
            if ribbon:
                EnsureCurveIsRibbon(crv)
            else:
                crv.data.bevel_depth=0
                crv.data.extrude=0
                crv.data.offset=0
            # try:
            dg.update()
            mOb = crv.evaluated_get(dg)
            m = bpy.data.meshes.new_from_object(mOb)
            m.name=crv.data.name+'_mesh'
            if (do_unlink):
                context.collection.objects.unlink(crv)
        else: # (ಥ﹏ಥ) why can't I just use this !
            # for now I will just do it like this
            if ribbon:
                EnsureCurveIsRibbon(crv)
            else:
                crv.data.bevel_depth=0
                crv.data.extrude=0
                crv.data.offset=0
            m = bpy.data.meshes.new_from_object(crv)
    finally:
        crv.data.bevel_depth = bevel
        crv.data.extrude = extrude
        crv.data.offset = offset
    return m

def DetectRibbon(f, bm, skipMe):
    fFirst = f.index
    cont = True
    circle = False
    tEdge, bEdge = [],[]
    while (cont == True):
        skipMe.add(f.index)
        tEdge.append (f.loops[0].vert.index) # top-left
        bEdge.append (f.loops[3].vert.index) # bottom-left
        nEdge = bm.edges.get([f.loops[1].vert, f.loops[2].vert])
        nFaces = nEdge.link_faces
        if (len(nFaces) == 1): 
            cont = False
        else:
            for nFace in nFaces:
                if (nFace != f):
                    f = nFace
                    break
            if (f.index == fFirst):
                cont = False
                circle = True
        if (cont == False): # we've reached the end, get the last two:
            tEdge.append (f.loops[1].vert.index) # top-right
            bEdge.append (f.loops[2].vert.index) # bottom-right
            # this will create a loop for rings -- 
            #  "the first shall be the last and the last shall be first"
    return (tEdge,bEdge,circle)

def DetectRibbons(m, fReport = None):
    # Returns list of vertex indices belonging to ribbon mesh edges
    # NOTE: this assumes a mesh object with only ribbon meshes
    # ---DO NOT call this script with a mesh that isn't a ribbon!--- #
    import bmesh
    bm = bmesh.new()
    bm.from_mesh(m)
    mIslands, mIsland = [], []
    skipMe = set()
    bm.faces.ensure_lookup_table()
    #first, get a list of mesh islands
    for f in bm.faces:
        if (f.index in skipMe):
            continue #already done here
        checkMe = [f]
        while (len(checkMe) > 0):
            facesFound = 0
            for f in checkMe:
                if (f.index in skipMe):
                    continue #already done here
                mIsland.append(f)
                skipMe.add(f.index)
                for e in f.edges:
                    checkMe += e.link_faces
            if (facesFound == 0):
                #this is the last iteration
                mIslands.append(mIsland)
                checkMe, mIsland = [], []
    ribbons = []
    skipMe = set() # to store ends already checked
    for mIsl in mIslands:
        ribbon = None
        first = float('inf')
        for f in mIsl:
            if (f.index in skipMe):
                continue #already done here
            if (f.index < first):
                first = f.index
            adjF = 0
            for e in f.edges:
                adjF+= (len(e.link_faces) - 1)
                # every face other than this one is added to the list
            if (adjF == 1):
                ribbon = (DetectRibbon(f, bm, skipMe) )
                break
        if (ribbon == None):
            ribbon = (DetectRibbon(bm.faces[first], bm, skipMe) )
        ribbons.append(ribbon)
    # print (ribbons)
    return ribbons

def data_from_ribbon_mesh(m, factorsList, mat, ribbons = None, fReport = None):
    #Note, factors list should be equal in length the the number of wires
    #Now working for multiple wires, ugly tho
    if (ribbons == None):
        ribbons = DetectRibbons(m, fReport=fReport)
        if (ribbons is None):
            if (fReport):
                fReport(type = {'ERROR'}, message="No ribbon to get data from.")
            else:  
                print ("No ribbon to get data from.")
            return None
    ret = []
    for factors, ribbon in zip(factorsList, ribbons):
        points  = []
        widths  = []
        normals = []
        ribbonData, totalLength = SetRibbonData(m, ribbon)

        for fac in factors:
            if (fac == 0):
                data = ribbonData[0]
                curFac = 0
            elif (fac == 1):
                data = ribbonData[-1]
                curFac = 0
            else:
                targetLength = totalLength * fac
                data = ribbonData[0]
                curLength = 0
                for ( (t, b), (tNext, bNext), length,) in ribbonData:
                    if (curLength >= targetLength):
                        break
                    curLength += length
                    data = ( (t, b), (tNext, bNext), length,)
                targetLengthAtEdge = (curLength - targetLength)
                if (targetLength == 0):
                    curFac = 0
                elif (targetLength == totalLength):
                    curFac = 1
                else:
                    # NOTE: This can be Zero. Find out why!
                    if data[2] == 0:
                        curFac=0
                    else:
                        curFac = 1 - (targetLengthAtEdge/ data[2]) #length
            t1 = m.vertices[data[0][0]]; b1 = m.vertices[data[0][1]]
            t2 = m.vertices[data[1][0]]; b2 = m.vertices[data[1][1]]
            #location
            loc1 = (t1.co).lerp(b1.co, 0.5)
            loc2 = (t2.co).lerp(b2.co, 0.5)
            #width
            w1 = (t1.co - b1.co).length/2
            w2 = (t2.co - b2.co).length/2 #radius, not diameter
            #normal
            n1 = (t1.normal).slerp(b1.normal, 0.5)
            n2 = (t1.normal).slerp(b2.normal, 0.5)
            if ((data[0][0] > data[1][0]) and (ribbon[2] == False)):
                curFac = 0
                #don't interpolate if at the end of a ribbon that isn't circular
            if ( 0 < curFac < 1):
                outPoint = loc1.lerp(loc2, curFac)
                outNorm  = n1.lerp(n2, curFac)
                outWidth = w1 + ( (w2-w1) * curFac)
            elif (curFac <= 0):
                outPoint = loc1.copy()
                outNorm = n1
                outWidth = w1
            elif (curFac >= 1):
                outPoint = loc2.copy()
                outNorm = n2
                outWidth = w2
            outPoint = mat @ outPoint
            outNorm.normalize()
            points.append ( outPoint.copy() ) #copy because this is an actual vertex location
            widths.append ( outWidth )
            normals.append( outNorm )
        ret.append( (points, widths, normals) )
    return ret # this is a list of tuples containing three lists




#This bisection search is generic, and it searches based on the
# magnitude of the error, rather than the sign.
# If the sign of the error is meaningful, a simpler function
# can be used.
def do_bisect_search_by_magnitude(
        owner, 
        attribute,
        index = None,
        test_function = None,
        modify = None,
        max_iterations = 10000,
        threshold = 0.0001,
        thresh2   = 0.0005,
        context = None,
        update_dg = None,
    ):
    from math import floor
    i = 0; best_so_far = 0; best = float('inf')
    min = 0; center = max_iterations//2; max = max_iterations
    # enforce getting the absolute value, in case the function has sign information
    # The sign may be useful in a sign-aware bisect search, but this one is more robust!
    test = lambda : abs(test_function(owner, attribute, index, context = context,))
    while (i <= max_iterations):
        upper = (max - ((max-center))//2)
        modify(owner, attribute, index, upper, context = context); error1 = test()
        lower = (center - ((center-min))//2)
        modify(owner, attribute, index, lower, context = context); error2 = test()
        if (error1 < error2):
            min = center
            center, check = upper, upper
            error = error1
        else:
            max = center
            center, check = lower, lower
            error = error2
        if (error <= threshold) or (min == max-1):
            break
        if (error < thresh2):
            j = min
            while (j < max):
                modify(owner, attribute, index, j * 1/max_iterations, context = context)
                error = test()
                if (error < best):
                    best_so_far = j; best = error
                if (error <= threshold):
                    break
                j+=1
            else: # loop has completed without finding a solution
                i = best_so_far; error = test()
                modify(owner, attribute, index, best_so_far, context = context)
                break
        if (error < best):
            best_so_far = check; best = error
        i+=1
        if update_dg:
            update_dg.update()
    else: # Loop has completed without finding a solution
        i = best_so_far
        modify(owner, attribute, best_so_far, context = context); i+=1