test

some_revarta.py

import bpy
import bmesh
import mathutils
from mathutils import Vector, Matrix
from sverchok.utils.sv_bmesh_utils import pydata_from_bmesh


def reprocess_bmesh(bm, radius):
    geom = pydata_from_bmesh(bm)
    original_verts, original_edges, original_faces = geom
    new_verts, new_edges, new_faces = [], [], []
    new_verts.extend(original_verts)
    new_edges.extend(original_edges)
    new_faces.extend(original_faces)

    if -0.001 < radius < 0.001:
        return geom

    verts = []
    edges = []
    faces = []

    bm.verts.ensure_lookup_table()
    bm.edges.ensure_lookup_table()

    # first ignore any loose verts, this perhaps optional for safety. OPTION
    linked_vertices = [v for v in bm.verts if v.link_edges[:]]

    # pick the lowest indexed vertex which has only one edge linked, and start from here
    for v in linked_vertices:
        if len(v.link_edges[:]) == 1:
            print(',....', v.index, v.link_edges[0].index)
            p = v.link_edges[0]
            print(dir(p))
            print('pther vert', p.other_vert(v))
            break

    '''
    observations:
    - if a vertex has 3 linked edges,
        - start from one edge and draw guide edges clockwise
        - store for every original vertex:
            - for every original edge combo
                - result guide vertex co
                - result guide vertex index
                - result guide edge index
        - store for every original edge:
            - the guide vertex indices it generated

    - end points are special,
        - extend along current vector by radius
        - make two guide vertices

    - for every newly generated guide point per edge
        - connect to the other guide points, stop at first valid edge per
          vertex.
        - no two vertices shall be connected if they intersect with
          the original edge.
            - original edges that are connected on both sides
                - result in one edge per vertex
            - if original edge is connect only one one side:
                - then the unconnect side will use 2 vertices twice.

    '''

    # find all vertices, used by only one edge
    single_linked_verts = [v for v in bm.verts if len(v.link_edges[:]) is 1]
    for v in single_linked_verts:
        e = v.link_edges[0]
        this_vert = v
        other_vert = e.other_vert(v)
        v1 = this_vert.co
        v2 = other_vert.co
        vlength = (v1 - v2).length
        print(v.index, '<---', other_vert.index, ':', vlength)
        v3 = v2.lerp(v1, (vlength + radius) / vlength)
        new_verts.append(v3)

    return new_verts, new_edges, new_faces


def sv_main(radius=0.3):
    verts_out = []
    edges_out = []
    faces_out = []
    verts_new_out = []
    edges_new_out = []
    faces_new_out = []

    in_sockets = [
        ['s', 'radius', radius]
    ]

    bm = bmesh.new()
    objname = "Plane"
    obj = bpy.data.objects[objname]

    if obj:

        bm.from_mesh(obj.data)

        # return original
        verts, edges, faces = pydata_from_bmesh(bm)
        verts_out.append([verts])
        edges_out.append([edges])

        # return processed
        verts2, edges2, faces2 = reprocess_bmesh(bm, radius)
        verts_new_out.append([verts2])
        edges_new_out.append([edges2])

        bm.free()

    out_sockets = [
        ['v', 'verts', verts_out],
        ['s', 'edges', edges_out],
        ['s', 'faces', faces_out],
        ['v', 'verts_new', verts_new_out],
        ['s', 'edges_new', edges_new_out],
        ['s', 'faces_new', faces_new_out]
    ]

    return in_sockets, out_sockets