Ex_Quick_Connect.py

# python
# Author: Jeff LeRoy (extol) www.leroyfx.com
# Ex_Quick_Connect.py
#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
#TO-DO / BUGS
#-------------------------------------------------------------------------------
#Still need to handle error close 

#-------------------------------------------------------------------------------
#select main layer
sel_mesh_ID = lx.eval('query layerservice layer.index ? main')
#-------------------------------------------------------------------------------


#-------------------------------------------------------------------------------
#Variables
#-------------------------------------------------------------------------------
edg_count_selected = lx.eval('query layerservice edge.N ?')#List of edges selected
edg_tup_frm_modo = ()#Tuple from modo containing selected edges
vrt_sel_order_b = []#Second list of ordered verts to select
vrt_sel_order_a = []#First list of ordered verts to select
end_crawl_vrts = []#The last two verts of the crawl
two_helper_edges = []#Two longest edges in selection
ply_main = int#poly shared between helper edgs


#-------------------------------------------------------------------------------
#Functions
#-------------------------------------------------------------------------------
def Edge_Crawl(test_vrt, v_s_o_lsts):
    #lx.out("Edge_Crawl")
    
    #Loop through edg_List_frm_modo with every edge from edg_tup_frm_modo
    #Then extract verts and turn two verts into a list
    for i in edg_list_frm_modo:
        #lx.out("Testing with vert", test_vrt)
        tmp = i[1:-1]
        tmp = tmp.split(',')
        
        #Test and see if the current crawl vert is in the list just made
        if test_vrt in tmp:
            idx = tmp.index(test_vrt)
            #lx.out("MATCH with vert", test_vrt)
            #found a match so remove from list no need to test on other verts
            edg_list_frm_modo.remove(i)
            
            #If select the other vert in the list as the next crawl vert
            if idx == 0:
                crwl_vrt_nxt = tmp[1]
                v_s_o_lsts.append(crwl_vrt_nxt)
            elif idx == 1:
                crwl_vrt_nxt = tmp[0]
                v_s_o_lsts.append(crwl_vrt_nxt)
            #Found a match no need to test the rest
            break

def Extract_Vertices(edge):
    vrt_tmp = edge[1:-1]
    vrt_tmp = vrt_tmp.split(',')
    vrt_a, vrt_b = vrt_tmp
    #vrt_a = vrt_tmp[0]
    #vrt_b = vrt_tmp[1]
    return(vrt_a, vrt_b)

def Error_Close():
    lx.eval('dialog.setup info')
    lx.eval('dialog.title "Ex_Quick_Connect"')
    lx.eval('dialog.msg "I can\'t find a shared polygon, quitting script."')
    lx.eval('dialog.open')
    quit()

#-------------------------------------------------------------------------------
#Too many edges selected so quit script
#-------------------------------------------------------------------------------
if edg_count_selected > 2:
    lx.eval('dialog.setup info')
    lx.eval('dialog.title "Ex_Quick_Connect"')
    lx.eval('dialog.msg "Too many edges are selected. '
    'Only select two edges"')
    lx.eval('dialog.open')
    quit()


#-------------------------------------------------------------------------------
#Not enough edges are selected
#-------------------------------------------------------------------------------
elif edg_count_selected <= 1:
    
    lx.eval('dialog.setup info')
    lx.eval('dialog.title "Ex_Quick_Connect"')
    lx.eval('dialog.msg "You need to select two edges"')
    lx.eval('dialog.open')
    quit()


#------------------------------------------------------------------------------- 
#Find shared polygon between two edges, select that polygon, then convert to
#edges, remove those edges from elist in modo because they dont need to be used
#in Edge_Crawl function
#-------------------------------------------------------------------------------
elif edg_count_selected == 2:
##---
    edg_tup_frm_modo = lx.eval('query layerservice edges ? selected')#Helper Edgs

    #Add helper edgs to list
    #Doing this here because we will query modo again for selected edges after we convert
    #And we need to remove them from the list so they wont be used in Edge_Crawl
    for i in edg_tup_frm_modo:
         two_helper_edges.append (i)
    
    #Get poly list from two helper edges
    border_edg_chk = lx.eval('query layerservice edge.polyList ? %s' %two_helper_edges[0])
    border_2_edg_chk = lx.eval('query layerservice edge.polyList ? %s' %two_helper_edges[1])
    
    #-------------------------------------------------------------------------------
    #Check to see if we have border edge selected or not 
    #-------------------------------------------------------------------------------  
    
    #Compare the types, if they are not equal one is a border edge
    if type(border_edg_chk) != type(border_2_edg_chk):
        if type(border_edg_chk) == int:
            ply_main = border_edg_chk
            if ply_main in border_2_edg_chk:
                pass
            else:
                Error_Close()
                
        if type(border_2_edg_chk) == int:
            ply_main = border_2_edg_chk
            if ply_main in border_edg_chk:
                pass
            else:
                Error_Close()
    
    #If tuple not a border edge 
    elif type(border_edg_chk) and type(border_2_edg_chk) == tuple:
        edg_ply_lst = lx.eval('query layerservice edge.polyList ? %s' %two_helper_edges[0])
        edg_ply_lst_2 = lx.eval('query layerservice edge.polyList ? %s' %two_helper_edges[1])
        
        #Compare polygons ID in ipl to polygons of ipl2
        for i in edg_ply_lst:
            if i in edg_ply_lst_2:
                ply_main = i
                #Break here because we found a match and it wont go to the else: below
                break
        #Cant find shared poly
        else:
            quit()
    
    #If int it is a border edge
    elif type(border_edg_chk) and type(border_2_edg_chk) == int:
        edg_ply_lst = lx.eval('query layerservice edge.polyList ? %s' %two_helper_edges[0])
        edg_ply_lst_2 = lx.eval('query layerservice edge.polyList ? %s' %two_helper_edges[1])
        
        #Two edges share the same poly
        if edg_ply_lst == edg_ply_lst_2:
            ply_main = edg_ply_lst
        #No shared polygon
        elif edg_ply_lst != edg_ply_lst_2:
            quit()
    
    
    #-------------------------------------------------------------------------------
    #Now that we know what polygon is shared selct it, and convert it to edges 
    #-------------------------------------------------------------------------------
    #Drop any selected polygons, select ply_main, convert to edges 
    lx.eval('select.drop polygon')
    lx.eval('select.element layer:%s type:polygon mode:add index:%s' %(sel_mesh_ID,ply_main))
    lx.eval('select.convert edge')

##---

    #-------------------------------------------------------------------------------
    #Define the two helper edges 
    #-------------------------------------------------------------------------------
    
    #Lets query this again becase we converted the polygon to edges and have more now
    edg_tup_frm_modo = lx.eval('query layerservice edges ? selected')

    #Creat a list of those edges so we can edit it later
    edg_list_frm_modo = list(edg_tup_frm_modo)
    
    #Remove these from the list so they wont be used in Edge_Crawl
    for i in two_helper_edges:
        edg_list_frm_modo.remove(i)

    #define the edge we will start the crawl from 
    long_e_1 = (two_helper_edges[-1])
    long_e_2 = (two_helper_edges[0])


#-------------------------------------------------------------------------------
#Extract the start and end verts from helper edges or longest edges
#-------------------------------------------------------------------------------
#Get the two verts that we will start the crawl with
vrt_a, vrt_b = Extract_Vertices(long_e_1)
vrt_sel_order_a.append(vrt_a)
vrt_sel_order_b.append(vrt_b)

#get the two verts that we will stop the crawl with
vrt_a, vrt_b = Extract_Vertices(long_e_2)
end_crawl_vrts.append(vrt_a)
end_crawl_vrts.append(vrt_b)


#-------------------------------------------------------------------------------
#Run every edge through Edge_Crawl
#-------------------------------------------------------------------------------
for i in edg_tup_frm_modo:
    #lx.out(edg_list_frm_modo)
    crawl_vert_a = vrt_sel_order_a[-1]
    
    if crawl_vert_a not in end_crawl_vrts:
        Edge_Crawl(crawl_vert_a, vrt_sel_order_a)
    else:
        #Now at one of the two end verts so exit loop
        break

for i in edg_tup_frm_modo:
    #lx.out(edg_list_frm_modo)
    crawl_vert_b = vrt_sel_order_b[-1]

    if crawl_vert_b not in end_crawl_vrts:
        Edge_Crawl(crawl_vert_b, vrt_sel_order_b)
    else:
        #Now at one of the two end verts so exit loop
        break


#Dropping stuff here because we will be selecting vertices below to connect them
lx.eval('select.drop edge')
lx.eval('select.drop vertex')


#-------------------------------------------------------------------------------
#Iterate through both vrt_sel_order lists in parallel and connect verticies
#These are the longest edges of the polygon OR the helper edges that were selected
#-------------------------------------------------------------------------------

#Removing first and last vrt of list because they already have edges between them
vrt_sel_order_a = vrt_sel_order_a[1:-1]
vrt_sel_order_b = vrt_sel_order_b[1:-1]

for v_1, v_2 in zip(vrt_sel_order_a, vrt_sel_order_b):
    lx.eval('select.element layer:%s type:vertex mode:add index:%s' % (sel_mesh_ID, v_1))
    lx.eval('select.element layer:%s type:vertex mode:add index:%s' % (sel_mesh_ID, v_2))
    lx.eval('poly.split')
    lx.eval('select.drop vertex')
    
lx.eval('select.typeFrom edge')