def intf_ENTMOVE(E): """Supply an entity ID number (or a list of IDs) followed by a coordinate list (e.g. [3.5 -2 0]) on the stack and this function will remove them from the stack and move each point in the entity by the ammounts in the coordinate list vector.""" input1ok= False if E.The.StackSize() >= 2: # CHECK INPUT #1 # Check that next ready stack item is a LST of 3 VALs. check= E.The.StackCopyItemLast() # Input verification. Next item on stack now. # Probably should use inc.point_formatted_LST here. See ENTPGRAM. if check.whatami == "LST": if len(check.val)==3: #if not filter(lambda x:x.whatami!="VAL",check.val): if all([x.whatami=="VAL" for x in check.val]): input1ok= True if not input1ok or not inc.entid_or_LST_of_entids(E.The,2): print("Input Error: move") print(intf_ENTMOVE.__doc__) return # Without doing much of anything. myoffset= [ xyz.val for xyz in E.The.StackPop().val ] # A list [3.5 -2 0]. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. myent= MMEL.El[myeid] myent.translate(myoffset) else: print("WARNING: Entity ID# %d does not exist." % myeid) OUT.default(MMEL,E) # AUTODUMP
def intf_ENTPTS(E): """Supply a number on the stack and this function will return the geometry of that entity. If a list of entity IDs is supplied, return geometry data for each.""" if not inc.entid_or_LST_of_entids(E.The,1): print("Input Error: pts") print(intf_ENTPTS.__doc__) return # Without doing much of anything. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: # NEEDS TO CHECK IF EID EXISTS! if myeid in MMEL.El: # Check if eid exists. pids= MMEL.El[myeid].epts # List of point IDs for this entity. for pid in pids: x= mm.Entity.allplist.PLdict[pid].x y= mm.Entity.allplist.PLdict[pid].y z= mm.Entity.allplist.PLdict[pid].z z= objectifier.StackOB_VAL(z) # Can't be just regular Python ints. y= objectifier.StackOB_VAL(y) x= objectifier.StackOB_VAL(x) p= objectifier.StackOB_LST([x, y, z]) p.names= ['x','y','z'] E.The.StackPush(p) else: print("Warning: No entity #%d. Skipping." % myeid)
def intf_ENTDUP(E): """Supply an entity ID or list of entity IDs on the stack and this function will create a new entity of the same type and using the same points. The new entity id or list of ids will be returned to the stack.""" if not inc.entid_or_LST_of_entids(E.The,1): print("Input Error: entdup") print(intf_ENTDUP.__doc__) return # Without doing much of anything. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. listify= True else: myeids= [ myeids ] # Also a (1 item) list of ints. listify= False new_eid= list() for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. src_ent= MMEL.El[myeid] new_ent= src_ent.duplicate() MMEL.add_ent(new_ent) if listify: new_eid.append( objectifier.StackOB_VAL(new_ent.eid) ) else: new_eid= objectifier.StackOB_VAL(new_ent.eid) else: print("WARNING: Entity ID# %d does not exist." % myeid) if new_eid: if listify: new_eid= objectifier.StackOB_LST(new_eid) E.The.StackPush(new_eid)
def intf_ENTDUPS(E): """Returns a list of every entity ID in the memory model which has an earlier (lower EID) corresponding entity which shares all of the exact same points. This is handy for managing duplicate entities. To completely clean up a model of duplicated entities, all edup? ~ -> """ if not inc.entid_or_LST_of_entids(E.The,1): print("Input Error: doubles") print(intf_ENTERASE.__doc__) return # Without doing much of anything. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. else: myeids= [ myeids ] # Also a (1 item) list of ints. some_doubles= list() for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. if not myeid in some_doubles: new_doubles= MMEL.find_doubles_of(MMEL.El[myeid]) some_doubles+= new_doubles else: print("WARNING: Entity ID# %d does not exist." % myeid) if some_doubles: some_doubles_so= [objectifier.StackOB_VAL(eid) for eid in some_doubles] some_doubles_so= objectifier.StackOB_LST(some_doubles_so) E.The.StackPush(some_doubles_so) else: E.The.StackPush( objectifier.StackOB_LST( list() ))
def intf_ENTCHTAG(E): """ From level three either an entity ID value or a list of entity ID values off the stack. From level two, a TXT object of an existing tag is taken off the stack. Finally from level one, the TXT object of the new replacement tag is taken. Any specified entities which are tagged with the specified tags will have those tags removed and replaced with the new one. <entID> ''roof'' ''wall'' chtag -> [<entID> <entID> <entID>] ''roof'' ''wall'' chtag -> """ if ( not inc.entid_or_LST_of_entids(E.The,3) or not inc.TXT(E,2) or not inc.TXT(E,1) ): print("Input Error: chtag") print(intf_ENTCHTAG.__doc__) return # Without doing much of anything. refreshview= False # No need unless view attributes (@) have been affected. newtag= E.The.StackPop().val oldtag= E.The.StackPop().val myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of VALs. myeids= [x.val for x in myeids] # Should now be a list of VALs. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. if MMEL.El[myeid].has_tag(oldtag): print("Untagging entity #%d with tag ''%s''" % (myeid,oldtag)) MMEL.El[myeid].del_tag(oldtag) MMEL.El[myeid].add_tag(newtag) if '@' in oldtag or '@' in newtag: refreshview= True else: print("Warning: No entity #%d. Skipping." % myeid) if refreshview: OUT.default(MMEL,E) # AUTODUMP
def intf_ENTPGRAM(E): """Takes an entity or list of entities from v3 and two point formatted lists from v2 and v1 (which could come from a line entity number supplied to the `pts` function) and creates a parallelogram. This parallelogram consists of the original supplied line entity, a new parallel line entity, two new line entites connecting the endpoints of the other lines, and two trifaces which cover the entire area of the parallelogram.""" # !! Need to check for some eids being TRIs. Filter that out. if ( not inc.entid_or_LST_of_entids(E.The,3) or not inc.point_formatted_LST(E.The,2) or not inc.point_formatted_LST(E.The,1) ): print("Input Error: pgram") print(intf_ENTPGRAM.__doc__) return # Without doing much of anything. oB= [ xyz.val for xyz in E.The.StackPop().val ] # A list [3.5 -2 0]. oA= [ xyz.val for xyz in E.The.StackPop().val ] # A list [3.5 -2 0]. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. else: myeids= [ myeids ] # Also a (1 item) list of ints. neweidlist= [] for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. src_ent= MMEL.El[myeid] new_ent= src_ent.duplicate() new_ent.translate([ oB[0]-oA[0], oB[1]-oA[1], oB[2]-oA[2] ]) As= mm.Entity.allplist.PLdict[ src_ent.epts[0] ] Ae= mm.Entity.allplist.PLdict[ src_ent.epts[1] ] Bs= mm.Entity.allplist.PLdict[ new_ent.epts[0] ] Be= mm.Entity.allplist.PLdict[ new_ent.epts[1] ] neweidlist.append(new_ent.eid) MMEL.add_ent(new_ent) line_entS= mm.Line_Entity( [As,Bs] ) neweidlist.append(line_entS.eid) MMEL.add_ent(line_entS) line_entE= mm.Line_Entity( [Ae,Be] ) neweidlist.append(line_entE.eid) MMEL.add_ent(line_entE) tri_entA= mm.Tri_Entity( [As, Ae, Bs] ) neweidlist.append(tri_entA.eid) MMEL.add_ent(tri_entA) tri_entB= mm.Tri_Entity( [Bs, Be, Ae] ) neweidlist.append(tri_entB.eid) MMEL.add_ent(tri_entB) else: print("WARNING: Entity ID# %d does not exist." % myeid) if neweidlist: neweids= objectifier.StackOB_LST( [objectifier.StackOB_VAL(x) for x in neweidlist] ) E.The.StackPush(neweids) OUT.default(MMEL,E) # AUTODUMP
def intf_MMITEM(E): """Dump the memory model of only the supplied entity ID or list of entity IDs to interpreter in a way that's helpful to the user. <entID> mmitem -> [<entID> <entID> <entID>] mmitem -> """ if not inc.entid_or_LST_of_entids(E.The,1): print("Input Error: mmitem\n" + intf_MMITEM.__doc__) return # Without doing much of anything. if not inc.entid_or_LST_of_entids(E.The,1): print("Input Error: mmitem") print(intf_MMITEM.__doc__) return # Without doing much of anything. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: if myeid in MMEL.El: print(MMEL.El[myeid].mmlist_repr())
def intf_ENTTAG(E): """From level two either an entity ID value or a list of entity ID values is taken off the stack. From level one, a TXT object or a list of TXT objects is taken off the stack. The specified entities are tagged with the text items. <entID> ''roof'' tag -> [<entID> <entID> <entID>] ''roof'' tag -> [<entID> <entID>] [''roof'' ''house''] tag -> last ''door'' tag -> """ if not inc.entid_or_LST_of_entids(E.The,2) or not inc.TXT_or_LST_of_TXTs(E.The,1): print("Input Error: tag") print(intf_ENTTAG.__doc__) return # Without doing much of anything. refreshview= False # No need unless view attributes (@) have been set. mytags= E.The.StackPop().val if type(mytags)==type(list()): #mytags= map(lambda x:x.val, mytags) # Should now be a list of TXTs. mytags= [x.val for x in mytags] # Should now be a list of TXTs. else: mytags= [ mytags ] # Also a (1 item) list of ints. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of VALs. myeids= [x.val for x in myeids] # Should now be a list of VALs. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. for mytag in mytags: if len(mytag) > 1 and '@' == mytag[1]: refreshview= True existing_att_tags= MMEL.El[myeid].has_tag_starting_with(mytag[0:2]) if existing_att_tags: for et in existing_att_tags: MMEL.El[myeid].del_tag(et) print("Tagging entity #%d with tag ''%s''" % (myeid,mytag)) if not MMEL.El[myeid].has_tag(mytag): MMEL.El[myeid].add_tag(mytag) else: print("Warning: No entity #%d. Skipping." % myeid) if refreshview: OUT.default(MMEL,E) # AUTODUMP
def intf_ENTERASE(E): """Supply an entity ID or a list of entity IDs on the stack and this function will delete it. Points used in the specified entity will be removed if not used elsewhere.""" if not inc.entid_or_LST_of_entids(E.The,1): print("Input Error: erase") print(intf_ENTERASE.__doc__) return # Without doing much of anything. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. MMEL.del_ent(myeid) else: print("WARNING: Entity ID# %d does not exist." % myeid) OUT.default(MMEL,E) # AUTODUMP
def intf_ENTDETAG(E): """Supply an entity ID or list of entity IDs on the stack and this function will remove all tags from the supplied entities. To remove all tags from all entities, use `all detag`. Entity IDs are consumed.""" if not inc.entid_or_LST_of_entids(E.The,1): print("Input Error: detag") print(intf_ENTDETAG.__doc__) return # Without doing much of anything. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of ints. myeids= [x.val for x in myeids] # Should now be a list of ints. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. MMEL.El[myeid].tags= list() else: print("WARNING: Entity ID# %d does not exist." % myeid) OUT.default(MMEL,E) # AUTODUMP
def intf_ENTUNTAG(E): """ From level two either an entity ID value or a list of entity ID values off the stack. From level one, a TXT object or a list of TXT objects is taken off the stack. Any specified entities which are tagged with any of the specified tags will have those tags removed. <entID> ''roof'' untag -> [<entID> <entID> <entID>] ''roof'' untag -> [<entID> <entID>] [''roof'' ''house''] untag -> last ''door'' untag -> """ if not inc.entid_or_LST_of_entids(E.The,2) or not inc.TXT_or_LST_of_TXTs(E.The,1): print("Input Error: untag") print(intf_ENTUNTAG.__doc__) return # Without doing much of anything. refreshview= False # No need unless view attributes (@) have been set. mytags= E.The.StackPop().val if type(mytags)==type(list()): #mytags= map(lambda x:x.val, mytags) # Should now be a list of TXTs. mytags= [x.val for x in mytags] # Should now be a list of TXTs. else: mytags= [ mytags ] # Also a (1 item) list of ints. myeids= E.The.StackPop().val if type(myeids)==type(list()): #myeids= map(lambda x:x.val, myeids) # Should now be a list of VALs. myeids= [x.val for x in myeids] # Should now be a list of VALs. else: myeids= [ myeids ] # Also a (1 item) list of ints. for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. for mytag in mytags: if MMEL.El[myeid].has_tag(mytag): print("Untagging entity #%d with tag ''%s''" % (myeid,mytag)) MMEL.El[myeid].del_tag(mytag) if '@' in mytag: refreshview= True else: print("Warning: No entity #%d. Skipping." % myeid) if refreshview: OUT.default(MMEL,E) # AUTODUMP
def intf_ENTROTATE(E): """Rotate one or more entities around a provided axis by a provided angle. This function takes 3 items off the stack. In order of entry, the third item is either an entity ID value or a list of one or more entity IDs. These are the entities which will be modified by the rotation. The second item is the axis of rotation. It can be an entity ID value of a line entity (tri entities are not supported) or it can be a list containing precisely two lists which each contain three values. This list contains two coordinate lists for points on (defining) a line. This line is the axis of rotation. If you point your right thumb from the first point on this line to the second point, your fingers will curve in a postive rotation. Finally, the first item popped off the stack (last entered) is the angle in degrees of the rotation. An example is `[2 4 13] [[0 0 0][0 0 1]] 45 rotate ->`, which would rotate entities 2, 4, and 13 by 45 degrees counter clockwise when seen looking from the second reference axis point ([0 0 1]) to the first ([0 0 0]).""" # Input must be in one of the following forms: # A. V V V -> # B. V [[V V V][V V V]] V -> # C. [V...V] V V -> # D. [V...V] [[V V V][V V V]] V -> # == Check Input == input1ok,input2ok= False,False if E.The.StackSize() >= 3: # === Check Item #1 === # Check that next ready stack item is a VAL (degrees to rotate). check= E.The.StackCopyItemLast() # Input verification. Next item on stack now. if check.whatami == "VAL": input1ok= True # === Check Item #2 === # Check that stack item 2 (penultimate) is a LST of 2 LST, OR a VAL. check= E.The.StackCopyItemN(2) if check.whatami == "LST": if len(check.val) == 2: #if not filter(lambda x:x.whatami!="LST",check.val): if all([x.whatami=="LST" for x in check.val]): #if (not filter(lambda x:x.whatami!="VAL",check.val[0].val) and # not filter(lambda x:x.whatami!="VAL",check.val[1].val) ): if ( all([x.whatami=="VAL" for x in check.val[0].val]) and all([x.whatami=="VAL" for x in check.val[1].val]) ): input2ok= True elif check.whatami == "VAL": input2ok= True # Might want to check here if entityID exists. if not input1ok or not input2ok or not inc.entid_or_LST_of_entids(E.The,3): print("Input Error: rotate") print(intf_ENTROTATE.__doc__) return # Without doing much of anything. # == Parse Input == # === Parse Item #1 === myangle= E.The.StackPop().val # degrees # === Parse Item #2 === axisP0,axisP1= [0,0,0],[0,0,1] # Defaults if there are problems. axis_object= E.The.StackPop() # either 1 line eid VAL OR LST:[LST LST]] if axis_object.whatami == "LST": P0object= axis_object.val[0] # A LST of 3 VALs. if len(P0object.val) == 3: #axisP0= map(lambda x:x.val, P0object.val) # Should now be a list of floats. axisP0= [x.val for x in P0object.val] # Should now be a list of floats. else: print("Error: First axis point defined badly. Assuming: [0 0 0]") P1object= axis_object.val[1] if len(P1object.val) == 3: #axisP1= map(lambda x:x.val, P1object.val) # Should now be a list of floats. axisP1= [x.val for x in P1object.val] # Should now be a list of floats. else: print("Error: Second axis point defined badly. Assuming: [0 0 1]") # LST:[ LST:[ VAL VAL VAL ] LST:[ VAL VAL VAL ] ] elif axis_object.whatami == "VAL": axis_eid= int(axis_object.val) if axis_eid in MMEL.El: # Check if axis_eid exists. axis_ent= MMEL.El[axis_eid] if axis_ent.etype is "Line": x= mm.Entity.allplist.PLdict[ axis_ent.epts[0] ].x y= mm.Entity.allplist.PLdict[ axis_ent.epts[0] ].y z= mm.Entity.allplist.PLdict[ axis_ent.epts[0] ].z axisP0=[x,y,z] x= mm.Entity.allplist.PLdict[ axis_ent.epts[1] ].x y= mm.Entity.allplist.PLdict[ axis_ent.epts[1] ].y z= mm.Entity.allplist.PLdict[ axis_ent.epts[1] ].z axisP1=[x,y,z] else: print("Warning: Specified axis entity was not a line. Assuming: [[0 0 0][0 0 1]]") else: print("Warning: Specified axis entity did not exist. Assuming: [[0 0 0][0 0 1]]") else: print("Error: This should never happen. Input check in rotation function failed.") return # === Parse Item #3 === myents_object= E.The.StackPop() # either 1 eid or a LST of eid VALs if myents_object.whatami=="LST": #myeids= map(lambda x:x.val, myents_object.val) # Should now be a list of ints. myeids= [x.val for x in myents_object.val] # Should now be a list of ints. else: myeids= [ myents_object.val ] # Also a (1 item) list of ints. # == Iterate Over Target Entities == for myeid in myeids: if myeid in MMEL.El: # Check if eid exists. myent= MMEL.El[myeid] #print('myent.rotate(%s,%s,%s)' % (myangle.__repr__(),axisP0.__repr__(),axisP1.__repr__())) # Looks like this: myent.rotate(22.5,[-1.0, -2.0, -3.0],[4.4, 5.5, 6.6]) #DO THE ROTATION HERE!!!!!!!!!!! myent.rotate(myangle,axisP0,axisP1) else: print("WARNING: Entity ID# %d does not exist." % myeid) OUT.default(MMEL,E) # AUTODUMP