SDS2 Parametric API
 All Classes Namespaces Functions Variables Pages
Functions
sds2.obj Namespace Reference

Functions

def aabb_m
def aabb_pt
def aabb_union
def all_enum_families
def all_gs
def all_ms
def angle
def are_disjoint_aabbs
def are_overlapping_aabbs
def b
def b2g
def b_end_conn_ij
def bisector
def bolts_mo_m
def c
def conn_c_to_mo_e
def cross
def cs_on_m
def cs_on_mn
def default_except_handler
def default_repr
def dist
def dot
def dsel
def e
def end_conn_ij
def ends_mo_m
def enum_mem_types
def enum_mt_types
def enums_of_family
def g
def gen_mt
def GetXYZT
def h
def h2g
def h2mt
def h2mt_sans_rot
def h2rot
def hlist
def holes_mo_mt
def host_number
def host_number_mo
def host_number_mo_m
def ij_mo_b
def ij_mo_e
def ij_mo_mt
def ij_mo_w
def ijk_mo_h
def indexof_mo
def indices_indexable
def indices_mo
def interpolate
def inv
def is_c
def is_c_ref_pt_at_origin
def is_conn_c
def is_created_by
def is_created_by_bytes
def is_end_marked_for_process
def is_g
def is_gen_mt
def is_hlist
def is_m_active
def is_m_marked_for_process_or_solids
def is_m_pym
def is_mb
def is_mn_active
def is_mo
def is_mo_and
def is_mo_and_b
def is_mo_and_e
def is_mo_and_h
def is_mo_and_le
def is_mo_and_m
def is_mo_and_mt
def is_mo_and_re
def is_mo_and_w
def is_mo_le
def is_mo_m_pym
def is_mo_re
def is_parallel
def is_part_of_end_connection
def is_perp
def is_pyc
def is_v
def IsBolt
def IsEnd
def IsHole
def IsMaterial
def IsMember
def IsWeld
def l2g
def le
def le2g
def lock
def locked_ms
def m
def m2g
def m_gs
def mag
def materials_mo_m
def mb
def mb_from_mn
def mo_b
def mo_b_uuid
def mo_e
def mo_e_to_c
def mo_h
def mo_h_to_hlist
def mo_le
def mo_m
def mo_m_uuid
def mo_mt
def mo_mt_to_gen_mt
def mo_mt_uuid
def mo_re
def mo_ref_xform
def mo_repr
def mo_to_gen_mt
def mo_to_mo_mt
def mo_uuid
def mo_w
def mo_w_uuid
def modifies_or_empty
def mt
def mt2g
def mt_end_conn_ij
def negx
def negy
def negz
def new_mo
def optional_m
def optional_mo_m
def pt_repr
def re
def re2g
def seg
def sel
def sel_es
def sel_ms
def selected
def set_sel
def silently_ignore_exception
def solids_creator_uuid
def solids_creator_uuid_buffer
def to_mo
def to_wkpt2
def traceback_warning_list
def try_or_default
def try_or_none
def unit
def unlock
def uuid
def v
def v2g
def view_ms
def vis_pt
def vis_pts
def vis_vec
def vis_xform
def vs_on_m
def w
def w2g
def warning_list
def welds_mo_m
def wkpt1
def wkpt2
def wkpt_slope
def x
def x3d_repr
def xform
def xform_repr
def xy
def xyz
def y
def yz
def z

Detailed Description

The model module is the recommended API for read access to members, ends, materials, holes, bolts, and welds. Each of those categories are represented by a single type, model.object, and the objects are accessed via indexes. This module provides syntactic sugar for accessing those objects.

Examples: mo_m(1) #model.object for member 1 mo_e(1,0) #model.object for member 1's left end mo_le(1) #model.object for member 1's left end mo_re(1) #model.object for member 1's right end mo_mt(1,0) #model.object for first material on member 1 mo_h(1,0,0) #model.object for first hole on mo_mt(1,0) mo_b(1,0) #model.object for first bolt on member 1 mo_w(1,0) #model.object for first weld on member 1

SDS2 has multiple type representations for members, materials, holes, etc. This module provides functions to convert between them (see to_mo, gen_mt, hlist, mb) and functions to create model.objects from generic objects. This module uses a naming convention that drops the 'mo_' prefix for creating model.objects from generic functions. Examples: m(1) m(mo_m(1)) m(member.Memer(1)) m(MemberBase.GetMemberLink(1,False,False) mt(1,0) mt(mt(1,0)) mt(member.Member(1).Material(0))

Creating model.object members can be surprisingly (and maybe alarmingly) easy. assert m(1) == m(mt(1,0))

This module also provides access to member views and components which are not model.object types. vs_on_m(1) #vies on member 1 v(1,0) #first view on member 1 cs_on_m(1) #components on member 1 c(1,0) #first component on member 1

Function Documentation

def sds2.obj.aabb_m (   args)
 Axis aligned bounding box containing member head and all members in tail
 
 trb = head.bound_trb
 blf = head.bound_blf
 head_aabb = (blf.x, blf.y, trb.z, trb.x, trb.y, blf.z)
 return (head_aabb if len(tail) == 0
         else aabb_union(head_aabb, aabb_m(tail[0], *tail[1:]))
         )
def sds2.obj.aabb_pt (   args)
 Axis aligned bounding box containing point head and points in tail
 
 head_aabb = xyz(pt(head)) * 2
 return (head_aabb if len(tail) == 0
         else aabb_union(head_aabb, aabb_pt(tail[0], *tail[1:]))
def sds2.obj.aabb_union (   args)
 Union of two axis aligned bounding boxes
 
 return (min(min_x_a, min_x_b)
         , min(min_y_a, min_y_b)
         , min(min_z_a, min_z_b)
         , max(max_x_a, max_x_b)
         , max(max_y_a, max_y_b)
         , max(max_z_a, max_z_b)
         )
def sds2.obj.all_enum_families (   args)
 Return list of all model module family names (i.e. names of model module enumerated types)
 
 return set(
         (getattr(model,a).family for a in dir(model)
             if hasattr(getattr(model, a), 'family')
             )
         )
def sds2.obj.all_gs (   args)
 return GroupMember.GetGroups()
def sds2.obj.all_ms (   args)
 all members in the job
 
 return model.members(0)
def sds2.obj.angle (   args)
 return p3d.Angle(pt(u), pt(v))
def sds2.obj.are_disjoint_aabbs (   args)
 Are the two axis aligned bounding boxes disjoint
 
 return (min_x_a > max_x_b
         or min_y_a > max_y_b
         or min_z_a > max_z_b
         or min_x_b > max_x_a
         or min_y_b > max_y_a
         or min_z_b > max_z_a
         )
def sds2.obj.are_overlapping_aabbs (   args)
 Do the two axis aligned bounding boxes overlap
 
 return not are_disjoint_aabbs(a, b)
def sds2.obj.b (   args)
 return (mo_b(hn(args[0]), args[1]) if len(args) == 2
         else args[0] if is_mo_and_b(args[0])
         else b(*args[0])
         )
 
 Example: assert (mo_b(59, 0) == b(member.Member(59),0)
         and mo_b(59,0) == b((59,0))
         and mo_b(59,0) == b(mo_b(59,0))
         )
def sds2.obj.b2g (   args)
 Bolt to global
 
 return mo_ref_xform(b) * mo_ref_xform(m(b))
def sds2.obj.b_end_conn_ij (   args)
 return b.conn_mem_idx, b.conn_mem_end
def sds2.obj.bisector (   args)
 return p3d.Bisector(pt(u), pt(v))
def sds2.obj.bolts_mo_m (   args)
 return mo_m.bolts
def sds2.obj.c (   args)
 return((lambda i, j: cs_on_mn(hn(i), j))(*args) if len(args) > 1
         else args[0] if is_c(o)
         else c(*args[0])
         )
def sds2.obj.conn_c_to_mo_e (   args)
 Return model.object end corresponding to connection component
 
 return (mo_le(conn_c.member_number)
         if is_c_ref_pt_at_origin(conn_c) else mo_re(conn_c.member_number)
         )
def sds2.obj.cross (   args)
 return p3d.Cross(pt(u), pt(v))
def sds2.obj.cs_on_m (   args)
 return cs_on_mn(hn(generic_member))
def sds2.obj.cs_on_mn (   args)
 return Component.GetComponentsOnMember(member_number)
def sds2.obj.default_except_handler (   args)
 traceback_warning_list(str(e))
def sds2.obj.default_repr (   args)
 return (mo_repr(o) if is_mo(o)
         else '%s(%r)' % (o.__class__.__name__, o.__dict__)
         )
def sds2.obj.dist (   args)
 return p3d.Distance(pt(p), pt(q))
def sds2.obj.dot (   args)
 return p3d.Dot(pt(u), pt(v))
def sds2.obj.dsel (   args)
 Deselect args
 
 args = selected() if args is None else list(args)
 return (model.Deselect(filter(is_mo, args))
         + Component.Deselect(filter(is_c, args))
         )
def sds2.obj.e (   args)
 return (mo_e(hn(args[0]), args[1]) if len(args) > 1
         else args[0] if is_mo_and_e(args[0])
         else e(*args[0])
         )
 
 Example: assert (mo_le(1) == e(member.Member(1), 0)
         and mo_le(1) == e((1,0))
         and mo_le(1) == e(mo_le(1))
         )
def sds2.obj.end_conn_ij (   args)
 return b_end_conn_ij(o) if is_mo_and_b(o) else mt_end_conn_ij(o)
def sds2.obj.ends_mo_m (   args)
 return mo_m.ends
def sds2.obj.enum_mem_types (   args)
 return enums_of_family('MemberType')
def sds2.obj.enum_mt_types (   args)
 return enums_of_family('MaterialType')
def sds2.obj.enums_of_family (   args)
 return (getattr(model,a) for a in dir(model)
         if hasattr(getattr(model,a), 'family')
         and getattr(model,a).family == family
         )
 
 See all_enum_families() for available families
 
 Example: return enums_of_family('MemberType') #i.e. enum_mem_types()
def sds2.obj.g (   args)
 return (all_gs() if indexable_gs is None else indexable_gs)[idx]
def sds2.obj.gen_mt (   args)
 return mo_mt_to_gen_mt(mt(*args))
def sds2.obj.GetXYZT (   arg1)
Returns
Instance of type tuple
     C++ signature :
         boost::python::tuple GetXYZT(Xform)
def sds2.obj.h (   args)
 return (mo_h(**(dict(zip(
             ('m', 'mt', 'h')
             , list(ij_mo_mt(mt(*args[:-1]))) + [args[-1]]
             )))) if len(args) > 1
         else args[0] if is_mo_and_h(args[0])
         else args[0].modelobject() if is_hlist(args[0])
         else h(*args[0])
         )
 
 Example: assert (mo_h(1,0,0) == h(member.Member(1),0,0)
         and mo_h(1,0,0) == h((1,0),0)
         and mo_h(1,0,0) == h((1,0,0))
         and mo_h(1,0,0) == h(mo_h(1,0,0))
         and mo_h(1,0,0) == h(member.Member(1).Material(0).HoleList()[0])
         and mo_h(1,0,0) == h(member.Member(1).Material(0), 0)
         )
def sds2.obj.h2g (   args)
 Hole to global
 
 return h_2_mt(h) * mt2g(mo_to_mo_mt(h))
def sds2.obj.h2mt (   args)
 Hole to material
 
 return h2rot(h) * h2mt_sans_rot(h)
def sds2.obj.h2mt_sans_rot (   args)
 Hole to material sans hole rotation
 
 m = mo_ref_xform(h)
 m.SetTranslation(pt(h.ref_loc))
 return m
def sds2.obj.h2rot (   args)
 Hole to hold rotation
 
 return x3d.Transform3D().RotateZ(h.rot)
def sds2.obj.hlist (   args)
 return mo_h_to_hlist(h(*args))
 
 Example: assert (member.Member(1).Material(0).HoleList()[0].modelobject() == hlist((1,0,0)).modelobject()
         and h(1,0,0) == hlist((1,0,0)).modelobject()
         )
def sds2.obj.holes_mo_mt (   args)
 return mo_mt.holes
def sds2.obj.host_number (   args)
 Extract a member number
 
 return (o if isinstance(o, int)
         else host_number_mo(o) if is_mo(o)
         else o.number if hasattr(o, 'number')
         else o.MemberNumber if hasattr(o, 'MemberNumber')
         else o.member_number if hasattr(o, 'member_number')
         else host_number(o.HostMember()) if hasattr(o, 'HostMember')
         else host_number_mo(o.modelobject()) if hasattr(o, 'modelobject')
         else None
         )
 
 Example: assert (1 == host_number(1)
         and 1 == host_number(mo_m(1))
         and 1 == host_number(member.Member(1).Material(0))
         and 1 == host_number(mb(1))
         )
def sds2.obj.host_number_mo (   args)
 Return the member number of the member containing x
 
 return x._as_tuple[0]
def sds2.obj.host_number_mo_m (   args)
 return x.number
def sds2.obj.ij_mo_b (   args)
 return indices_mo(b, 0, 4)
 
 Example: assert 59,0 == ij_mo_b(mo_b(59,0))
def sds2.obj.ij_mo_e (   args)
 return indices_mo(e, 0, 1)
 
 Example: assert 1,0 == ij_mo_e(mo_le(1))
def sds2.obj.ij_mo_mt (   args)
 return indices_mo(mt, 0, 2)
 
 Example: assert list(ij_mo_mt(mo_mt(1,0))) == list(indices_mo(mo_mt(1,0), 0, 2))
def sds2.obj.ij_mo_w (   args)
 return indices_mo(w, 0, 5)
 
 Example: assert 1,0 == ij_mo_w(mo_w(1,0))
def sds2.obj.ijk_mo_h (   args)
 return indices_mo(h, 0, 2, 3)
 
 Example: assert [1,0,0] == list(ijk_mo_h(mo_h(1,0,0)))
def sds2.obj.indexof_mo (   args)
 return next((i for i in reversed(mo._as_tuple) if i!=-1), None)
 
 Example: assert (1 == indexof_mo(mo_m(1))
         and 0 == indexof_mo(mo_mt(1,0))
         and 2 == indexof_mo(mo_h(1,0,2))
         )
def sds2.obj.indices_indexable (   args)
 return (indexable[i] for i in indices)
 
 Example: assert 3,4 == indices_indexable((2, 3, 4, 5), 1, 2)
def sds2.obj.indices_mo (   args)
 return indices_indexable(mo._as_tuple, *ns)
 
 Example: assert 1,0 == indices_mo(mo_mt(1,0), 0, 2)
def sds2.obj.interpolate (   args)
 return p3d.Interpolate(pt(p), pt(q), s)
def sds2.obj.inv (   args)
 Return the inverse of a matrix
 
 return xform(matrix_concept).Inverse()
def sds2.obj.is_c (   args)
 return isinstance(o, Component.Component)
def sds2.obj.is_c_ref_pt_at_origin (   args)
 return c.ref_point.EpsilonEquals(pt(), accy)
def sds2.obj.is_conn_c (   args)
 Return True iff c is a connection component (i.e. a builtin component)
 
 return type(c) == Component.Component
def sds2.obj.is_created_by (   args)
 return is_created_by_bytes(obj, creator.uuid.bytes)
def sds2.obj.is_created_by_bytes (   args)
 return solids_creator_uuid_buffer(obj) == creator_uuid_bytes
def sds2.obj.is_end_marked_for_process (   args)
 return mo_e.process or mo_e.framing_sit
def sds2.obj.is_g (   args)
 return isinstance(o, GroupMember.Group)
def sds2.obj.is_gen_mt (   args)
 is_gen_mt(args)
def sds2.obj.is_hlist (   args)
 is_hlist(args)
def sds2.obj.is_m_active (   args)
 return optional_m(m, silently_ignore_exception) is not None
def sds2.obj.is_m_marked_for_process_or_solids (   args)
 mo_m = m(o)
 return (mo_m.create_3d
         or mo_m.asn_pcmk
         or mo_m.asn_hash
         or mo_m.node_stat != model.Untouched
         or any(is_end_marked_for_process(e) for e in mo_m.ends)
         )
def sds2.obj.is_m_pym (   args)
 return is_mo_m_pym(m(generic_member))
def sds2.obj.is_mb (   args)
 return isinstance(o, MemberBase.MemberBase)
def sds2.obj.is_mn_active (   args)
 return optional_mo_m(mn, silently_ignore_exception) is not None
def sds2.obj.is_mo (   args)
 return isinstance(o, mo)
def sds2.obj.is_mo_and (   args)
 return is_mo(o) and pred(o)
def sds2.obj.is_mo_and_b (   args)
 return is_mo_and(o, is_mo_b)
def sds2.obj.is_mo_and_e (   args)
 return is_mo_and(o, is_mo_e)
def sds2.obj.is_mo_and_h (   args)
 return is_mo_and(o, is_mo_h)
def sds2.obj.is_mo_and_le (   args)
 return is_mo_and(o, is_mo_le)
def sds2.obj.is_mo_and_m (   args)
 return is_mo_and(o, is_mo_m)
def sds2.obj.is_mo_and_mt (   args)
 return is_mo_and(o, is_mo_mt)
def sds2.obj.is_mo_and_re (   args)
 return is_mo_and(o, is_mo_re)
def sds2.obj.is_mo_and_w (   args)
 return is_mo_and(o, is_mo_w)
def sds2.obj.is_mo_le (   args)
 e = mo._as_tuple[1]
 return e > -1 and e % 2 == 0
def sds2.obj.is_mo_m_pym (   args)
 return mo_m.memt == model.Custom
def sds2.obj.is_mo_re (   args)
 e = mo._as_tuple[1]
 return e > -1 and e % 2 == 1
def sds2.obj.is_parallel (   args)
 return p3d.IsParallel(pt(u), pt(v))
def sds2.obj.is_part_of_end_connection (   args)
 return end_conn_id(obj) == ij_mo_e(e)
def sds2.obj.is_perp (   args)
 return p3d.IsPerpendicular(pt(u), pt(v))
def sds2.obj.is_pyc (   args)
 Return True iff o is a python componet
 
 return is_c(o) and not is_conn_c(o)
def sds2.obj.is_v (   args)
 return isinstance(o, view.MemberViewTuple)
def sds2.obj.IsBolt (   modelobject)
Returns
Instance of type bool
     Return True iff the modelobject represents a bolt.
     Example: LocateSingle('Locate bolt', IsBolt)
 
     C++ signature :
         bool IsBolt(modelobject)
def sds2.obj.IsEnd (   modelobject)
Returns
Instance of type bool
     Return True iff the modelobject represents an end.
     Example: LocateSingle('Locate end', IsEnd)
 
     C++ signature :
         bool IsEnd(modelobject)
def sds2.obj.IsHole (   modelobject)
Returns
Instance of type bool
     Return True iff the modelobject represents a hole.
     Example: LocateSingle('Locate hole', IsHole)
 
     C++ signature :
         bool IsHole(modelobject)
def sds2.obj.IsMaterial (   modelobject)
Returns
Instance of type bool
     Return True iff the modelobject represents a material.
     Example: LocateSingle('Locate material', IsMaterial)
 
     C++ signature :
         bool IsMaterial(modelobject)
def sds2.obj.IsMember (   modelobject)
Returns
Instance of type bool
     Return True iff the modelobject represents a member.
     Example: LocateSingle('Locate member', IsMember)
 
     C++ signature :
         bool IsMember(modelobject)
def sds2.obj.IsWeld (   modelobject)
Returns
Instance of type bool
     Return True iff the modelobject represents a weld.
     Example: LocateSingle('Locate weld', IsWeld)
 
     C++ signature :
         bool IsWeld(modelobject)
def sds2.obj.l2g (   args)
 Local to global for the given generic object
 
 return ((m2g(o) if is_mo_m(o)
     else le2g(o) if is_mo_le(o)
     else re2g(o) if is_mo_re(o)
     else mt2g(o) if is_mo_mt(o)
     else h2g(o) if is_mo_h(o)
     else b2g(o) if is_mo_b(o)
     else w2g(o)
     ) if is_mo(o)
     else v2g(o) if is_v(o)
     else l2g(to_mo(o))
     )
def sds2.obj.le (   args)
 return mo_le(hn(generic_member))
 
 Example: assert mo_le(1) == le(member.Member(1))
def sds2.obj.le2g (   args)
 Left end to global
 
 return mo_ref_xform(m(le))
def sds2.obj.lock (   args)
 return model.LockOnlyThis([m(a) for a in args])
def sds2.obj.locked_ms (   args)
 all members locked by the current process
 
 return model.members(4)
def sds2.obj.m (   args)
 Convert a member to a model.object member
 
 return mo_m(hn(generic_member))
 
 Example: assert (mo_m(1) == m(member.Member(1))
         and mo_m(1) == m(member.Member(1).Material(0))
         )
def sds2.obj.m2g (   args)
 Member to global
 
 return mo_ref_xform(m)
def sds2.obj.m_gs (   args)
 return GroupMember.GetGroupsForMember(hn(generic_member))
def sds2.obj.mag (   args)
 return p3d.Magnitude(pt(v))
def sds2.obj.materials_mo_m (   args)
 return mo_m.materials
def sds2.obj.mb (   args)
 return mb_from_mn(hn(generic_member), lock)
def sds2.obj.mb_from_mn (   args)
 return MemberBase.GetMemberLink(member_number, False, lock)
def sds2.obj.mo_b (   args)
 return new_mo(m, b=b)
def sds2.obj.mo_b_uuid (   args)
 return Uuid.FromBuffer(b.guid)
def sds2.obj.mo_e (   args)
 return new_mo(m, e)
def sds2.obj.mo_e_to_c (   args)
 Return component corresponding to model.object end
 
 return next(
         ifilter(
             is_c_ref_pt_at_origin
             if is_mo_le(end) else lambda c: not is_c_ref_pt_at_origin(c)
             , filter(is_conn_c, cs_on_mn(host_number_mo(end)))
             )
         , default
         )
def sds2.obj.mo_h (   args)
 return new_mo(m, mt=mt, h=h)
def sds2.obj.mo_h_to_hlist (   args)
 Convert model.object hole to hole_list
 
 return (lambda m, mt, h: gen_mt(m, mt).HoleList()[h])(*ijk_mo_h(mo_h))
def sds2.obj.mo_le (   args)
 return new_mo(m, 0)
def sds2.obj.mo_m (   args)
 return new_mo(m)
def sds2.obj.mo_m_uuid (   args)
 return Uuid.FromBuffer(m.guid_manufacturing)
def sds2.obj.mo_mt (   args)
 return new_mo(m, mt=mt)
def sds2.obj.mo_mt_to_gen_mt (   args)
 Convert model.object material to gen_mtrl
 
 return (lambda i, j: member.Member(i).Material(j))(*ij_mo_mt(mo_mt))
def sds2.obj.mo_mt_uuid (   args)
 return Uuid.FromBuffer(m.guid)
def sds2.obj.mo_re (   args)
 return new_mo(m, 1)
def sds2.obj.mo_ref_xform (   args)
 return xform(mo.ref_xform)
def sds2.obj.mo_repr (   args)
 return '%s%r' % ('mo', o._as_tuple)
def sds2.obj.mo_to_gen_mt (   args)
 return mo_mt_to_gen_mt(mo_to_mo_mt(mo))
 
 Example: assert mo_to_gen_mt(mo_h(1,0,0)).modelobject() == gen_mt(1,0).modelobject()
def sds2.obj.mo_to_mo_mt (   args)
 return mt(*ij_mo_mt(mo)) ;#can return a hole's material
 
 Example: assert mo_to_mo_mt(mo_mt(1,0)) == mo_to_mo_mt(mo_h(1,0,0))
def sds2.obj.mo_uuid (   args)
 return mo_m_uuid(mo) if is_mo_m(mo) else Uuid.FromBuffer(mo.guid)
def sds2.obj.mo_w (   args)
 return new_mo(m, w=w)
def sds2.obj.mo_w_uuid (   args)
 return Uuid.FromBuffer(w.guid)
def sds2.obj.modifies_or_empty (   args)
 return try_or_default(lambda: x.Modifies(), [], except_handler)
def sds2.obj.mt (   args)
 return (mo_mt(hn(args[0]), args[1]) if len(args) > 1
         else args[0] if is_mo_and_mt(args[0])
         else args[0].modelobject() if is_gen_mt(args[0])
         else mt(*args[0])
         )
 
 Example: assert (mo_mt(1,0) == mt(member.Member(1),0)
         and mo_mt(1,0) == mt((1,0))
         and mo_mt(1,0) == mt(mo_mt(1,0))
         and mo_mt(1,0) == mt(gen_mt(1,0))
         )
def sds2.obj.mt2g (   args)
 Material to global
 
 return mo_ref_xform(mt)
def sds2.obj.mt_end_conn_ij (   args)
 return mt.mem_conn_idx, mt.mem_conn_end
def sds2.obj.negx (   args)
 return -x(o)
def sds2.obj.negy (   args)
 return -y(o)
def sds2.obj.negz (   args)
 return -z(o)
def sds2.obj.new_mo (   args)
 mo constructor with keyword args
 
 return mo(m, e, mt, h, b, w)
def sds2.obj.optional_m (   args)
 return try_or_none(lambda: m(generic_member), except_handler)
def sds2.obj.optional_mo_m (   args)
 return try_or_none(lambda: mo_m(mn), except_handler)
def sds2.obj.pt_repr (   args)
 return 'pt' + repr(xyz(p))
def sds2.obj.re (   args)
 return mo_re(hn(generic_member))
 
 Example: assert mo_re(1) == re(member.Member(1))
def sds2.obj.re2g (   args)
 Right end to global
 
 x, y, z = xyz(l2g(m(re)))
 return xform((-x, y, -z, re.loc))
def sds2.obj.seg (   args)
 Line segment of the generic object
 
 m = l2g(o)
 return origin(m), wkpt2(o, m)
def sds2.obj.sel (   args)
 Select args
 
 args = selected() if args is None else list(args)
 return (model.Select(filter(is_mo, args))
         + Component.Select(filter(is_c, args))
         )
def sds2.obj.sel_es (   args)
 all selected ends
 
 return model.members(3)
def sds2.obj.sel_ms (   args)
 all selected members
 
 return model.members(2)
def sds2.obj.selected (   args)
 return model.GetSelection() + Component.GetSelectedComponents()
def sds2.obj.set_sel (   args)
 ds = dsel()
 return sel(args), ds
def sds2.obj.silently_ignore_exception (   args)
 silently_ignore_exception(args)
def sds2.obj.solids_creator_uuid (   args)
 return Uuid.FromBuffer(solids_creator_uuid_buffer(mo))
def sds2.obj.solids_creator_uuid_buffer (   args)
 return mo.solids_creator_uuid
def sds2.obj.to_mo (   args)
 if len(args) == 1:
     a0 = args[0]
     if isinstance(a0, m0):
         return a0
     elif hasattr(a0, 'modelobject'):
         return a0.modelobject()
     else:
         try:
             return to_mo(*a0)
         except:
             return mo(hn(a0))
 return new_mo(*args) if len(args) > 1 else None
 
 Example: assert [mo_mt(1,0), mo_h(1,0,0)] == map(to_mo, (gen_mt(1,0), hlist(1,0,0)))
def sds2.obj.to_wkpt2 (   args)
 Return a function that extracts the vector from wkpt1 to wkpt2 for a
 generic object o
 
 return (negz if is_mo_and_b(o)
         else negz if is_mo_and_h(o)
         else x
         )
def sds2.obj.traceback_warning_list (   args)
 warning_list('%s
 %s' % (msg, traceback.format_exc()))
def sds2.obj.try_or_default (   args)
 try:
     return f()
 except Exception, e:
     except_handler(e)
 return default
def sds2.obj.try_or_none (   args)
 return try_or_default(f, None, except_handler)
def sds2.obj.unit (   args)
 return p3d.Unit(pt(v))
def sds2.obj.unlock (   args)
 return model.Unlock([m(a) for a in (args if len(args) else locks())])
def sds2.obj.uuid (   args)
 return mo_uuid(o) if is_mo(o) else o.uuid
def sds2.obj.v (   args)
 return ((lambda i, j: vs_on_m(i)[j])(*args) if len(args) > 1
         else args[0] if is_v(args[0])
         else v(*args[0])
         )
def sds2.obj.v2g (   args)
 View to global
 
 return inv(v.global_to_view)
def sds2.obj.view_ms (   args)
 all members in the current view
 
 return model.members(1)
def sds2.obj.vis_pt (   args)
 Visualize p by using it as the anchor to a point location prompt
 
 p = pt(p)
 x = point.PointLocate(msg if msg else 'Anchored@%s' % repr(xyz(p)), point.Point(p))
 return x, p
def sds2.obj.vis_pts (   args)
 return map(vis_pt, pts)
def sds2.obj.vis_vec (   args)
 Visualize the vector by prompting for a point p then prompting for a second
 point with an anchor of p+v
 
 p = point.PointLocate(msg if msg else 'Locate vector base:')
 if p:
     x, p = vis_pt(pt(p) + pt(v), '|%d,%d,%d|==%d' % (v.x, v.y, v.z, mag(v)))
 return x, v
def sds2.obj.vis_xform (   args)
 Visualize the matrix
 
 vis_pt(origin(m))
 map(lambda t: vis_vec(*t)
         , zip(map(lambda v: scale * v, xyz(m)), ('x', 'y', 'z'))
         )
def sds2.obj.vs_on_m (   args)
 return view.GetMemberViews(generic_member)
def sds2.obj.w (   args)
 return (mo_w(hn(args[0]), args[1]) if len(args) == 2
         else args[0] if is_mo_and_w(args[0])
         else w(*args[0])
         )
 
 Example: assert (mo_w(1, 0) == w(member.Member(1),0)
         and mo_w(1,0) == w((1,0))
         and mo_w(1,0) == w(mo_w(1,0))
         )
def sds2.obj.w2g (   args)
 Weld to global
 
 return mo_ref_xform(w)
def sds2.obj.warning_list (   args)
 param.NonBlockingWarning(msg)
def sds2.obj.welds_mo_m (   args)
 return mo_m.welds
def sds2.obj.wkpt1 (   args)
 Work point 1 for generic object o using local to global materix m
 
 return origin(m if m else l2g(o))
def sds2.obj.wkpt2 (   args)
 Work point 2 for a generic object using local to global matrix m
 
 m = m if m else l2g(o)
 return origin(m) + wkpt_slope(o) * to_wkpt2(o)(m)
def sds2.obj.wkpt_slope (   args)
 Work point slope for generic object o
 
 return (o.wkpt_slope if hasattr(o, 'wkpt_slope')
         else o.len if hasattr(o, 'len')
         else o.length if hasattr(o, 'length')
         else wkpt_slope(to_mo(o))
         )
def sds2.obj.x (   args)
 return o.x
def sds2.obj.x3d_repr (   args)
 return 'xform(%s)' % o
def sds2.obj.xform (   args)
 Convert matrix_concept to a x3d.Tranform3D
 
 return (matrix_concept if type(matrix_concept)==x3d.Transform3D
         else x3d.Transform3D(*map(pt, matrix_concept))
         )
def sds2.obj.xform_repr (   args)
 return 'xform((%s,%s,%s,%s))' % xyzt(m)
def sds2.obj.xy (   args)
 return x(o), y(o)
def sds2.obj.xyz (   args)
 return x(o), y(o), z(o)
def sds2.obj.y (   args)
 return o.y
def sds2.obj.yz (   args)
 return y(o), z(o)
def sds2.obj.z (   args)
 return o.z