Create a gist now

Instantly share code, notes, and snippets.

What would you like to do?
# 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