Scripting: low level join meshes / elements (hopefully with bmesh)?

Question

Currently I only know of one way to join meshes - using the join operator:

bpy.ops.object.join()

This has an annoying overhead of additional operations required to select the objects you want to join, etc.

But what if I only want to join elements from two different meshes? This will be even more cumbersome with traditional methods: select the object, go to edit mode, select the relevant elements, duplicate them, separate them to a new mesh, join the new mesh with the other mesh...

It would be much nicer if I could just create two bmesh objects, then directly copy elements from one to the other. Something like this currently illegal code:

for v in bm1.verts:
    bm2.verts.add( v )

# or:
bm2.edges.add( bm1.edges[5] )

At the moment this requires adding the vertices first via their coordinates, then adding faces or edges by referencing the relevant new verts.

# Example for adding all the edges from another bmesh object
current_last_vert_index = len( bm2.verts ) - 1
for v in bm1.verts:
    bm2.verts.new( v.co )

for e in bm1.edges:
    verts = [ bm2.verts[ current_last_vert_index + v.index ] for v in e.verts ]
    bm2.edges.new( verts )

So, any better way to do this?

Answer 1

The best solution I found so far is using the bmesh.from_mesh( mesh ) method. Apparently, if you call this method more than once, it will add the 2nd mesh to the first, thus effectively joining them:

import bpy, bmesh

bm = bmesh.new()
bm.from_mesh( mesh1 ) # Add first mesh
bm.from_mesh( mesh2 ) # Add 2nd mesh

However, this does not really help with adding individual components from another mesh or bmesh in a direct manner.

Answer 2

Here's what i'm using in Sverchok at the moment, it's not heavily tested yet. It is derived from Sverchok's bmesh_from_pydata function (which is extensively tested)

import bmesh

def bmesh_join(list_of_bmeshes, normal_update=False):
    """ takes as input a list of bm references and outputs a single merged bmesh 
    allows an additional 'normal_update=True' to force _normal_ calculations.
    """

    bm = bmesh.new()
    add_vert = bm.verts.new
    add_face = bm.faces.new
    add_edge = bm.edges.new

    for bm_to_add in list_of_bmeshes:
        offset = len(bm.verts)

        for v in bm_to_add.verts:
            add_vert(v.co)

        bm.verts.index_update()
        bm.verts.ensure_lookup_table()

        if bm_to_add.faces:
            for face in bm_to_add.faces:
                add_face(tuple(bm.verts[i.index+offset] for i in face.verts))
            bm.faces.index_update()

        if bm_to_add.edges:
            for edge in bm_to_add.edges:
                edge_seq = tuple(bm.verts[i.index+offset] for i in edge.verts)
                try:
                    add_edge(edge_seq)
                except ValueError:
                    # edge exists!
                    pass
            bm.edges.index_update()

    if normal_update:
        bm.normal_update()

    return bm

you may have to clear or free the content of the list_of_bmeshes variable after it completes, but i suspect the memory is freed after the scope ends.

---

In the scenario where you are operating on bmeshes derived from objects with unapplied Matrices, one can do

def bmesh_join(list_of_bmeshes, list_of_matrices, normal_update=False):

    ...

    for bm_to_add, matrix in zip(list_of_bmeshes, list_of_matrices):
        bm_to_add.transform(matrix)

        ...

or transform them before passing them to the function at the top of this answer.

Answer 3

I need to go through and optimize this, but it's working for me

def join_bmesh_map(source, target, src_trg_map = None, src_mx = None, trg_mx = None):
    '''
    source - bmesh to bring data from
    target - bmesh to place data into
    scr_trg_map - if overlapping parts of source and target, this will substitute new and old geometry.  Good for filling holes and sewing an inner patch to the perimeter of the hole

    '''
    L = len(target.verts)

    if not src_trg_map:
        src_trg_map = {-1:-1}  #dummy dictionary
    if not src_mx:
        src_mx = Matrix.Identity(4)
    if not trg_mx:
        trg_mx = Matrix.Identity(4)
        i_trg_mx = Matrix.Identity(4)
    else:
        i_trg_mx = trg_mx.inverted()


    old_bmverts = [v for v in target.verts]  #this will store them in order
    new_bmverts = [] #these will be created in order

    source.verts.ensure_lookup_table()

    for v in source.verts:
        if v.index not in src_trg_map:
            new_ind = len(target.verts)
            new_bv = target.verts.new(i_trg_mx * src_mx * v.co)
            new_bmverts.append(new_bv)  #gross...append
            src_trg_map[v.index] = new_ind

    lverts = old_bmverts + new_bmverts

    new_bmfaces = []
    for f in source.faces:
        v_inds = []
        for v in f.verts:
            new_ind = src_trg_map[v.index]
            v_inds.append(new_ind)

        new_bmfaces += [target.faces.new(tuple(lverts[i] for i in v_inds))]

    target.faces.ensure_lookup_table()
    target.verts.ensure_lookup_table()

    new_L = len(target.verts)

    if src_trg_map:
        if new_L != L + len(source.verts) -l:
            print('seems some verts were left in that should not have been')

Answer 4

Below is another way to copy bmesh data from one into another. By using tags and layers (thanks to this discussion: Python: assign custom tag to vertices?), more information is held in the vertices of the source-bmesh.

def join_bmesh(target_bm, source_bm):
    '''
    source_bm into target_bm
    returns target_bm with added geometry, if source_bm is not empty.
    '''

    source_bm.verts.layers.int.new('index')
    idx_layer = source_bm.verts.layers.int['index']

    for face in source_bm.faces:
        new_verts = []
        for old_vert in face.verts:
            #tag is False by defualt, Im using it to mean its been added
            if not old_vert.tag:
                new_vert = target_bm.verts.new(old_vert.co)
                target_bm.verts.index_update()
                old_vert[idx_layer] = new_vert.index
                old_vert.tag = True

            target_bm.verts.ensure_lookup_table()
            idx = old_vert[idx_layer]
            new_verts.append(target_bm.verts[idx])

        target_bm.faces.new(new_verts)
    return target_bm