This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# 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') |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment