iGeom Interface

Geom

class itaps.iGeom.Geom([options])

Return a new Geom object with any implementation-specific options defined in options.

Parameters:

• options – Implementation-specific options string

rootSet

Return the handle of the root set for this instance. The entire geometry in this instance can be accessed from this set.

boundBox

Return the bounding box of the entire model.

topoLevel

Return the topology level of the geometry as an integer, where 0 = basic entities only, 1 = manifold entities, 2 = non-manifold entities.

parametric

Return True if the interface has information about parameterization, False otherwise.

tolerance

Return a tuple representing the tolerance at the modeler level. The first value is an integer representing the type of the tolerance, where 0 = no tolerance information, 1 = modeler-level tolerance, 2 = entity-level tolerances. If this value is 1, the second value returns the modeler-level tolerance. If this value is 2, use getEntTolerance() to query the tolerance on a per-entity basis.

load(filename[, options])

Load a geometry from a file.

Parameters:

• filename – File name from which the geometry is to be loaded
• options – Implementation-specific options string

save(filename[, options])

Save the geometry to a file.

Parameters:

• filename – File name to which the geometry is to be saved
• options – Implementation-specific options string

createSphere(radius)

Create a sphere with the specified radius.

Parameters:

• radius – The radius of the sphere

Returns:

The created entity

createBrick(dimensions)

Create a sphere with the x, y, and z dimensions specified in dimensions. You may also call this method with createBrick(x, y, z).

Parameters:

• dimensions – The dimensions of the brick

Returns:

The created entity

createCylinder(height, major_rad, minor_rad)

Create a cylinder with the specified height, major_rad, and minor_rad.

Parameters:

• height – The height of the cylinder
• major_rad – The cylinder’s major radius
• minor_rad – The cylinder’s minor radius

Returns:

The created entity

createPrism(height, sides, major_rad, minor_rad)

Create a prism with the specified height, sides, major_rad, and minor_rad.

Parameters:

• height – The height of the prism
• sides – The number of sides of the prism
• major_rad – The prism’s major radius
• minor_rad – The prism’s minor radius

Returns:

The created entity

createCone(height, major_rad, minor_rad, top_rad)

Create a cylinder with the specified height, major_rad, minor_rad, and top_rad.

Parameters:

• height – The height of the cone
• major_rad – The cone’s major radius
• minor_rad – The cone’s minor radius
• minor_rad – The cone’s top radius

Returns:

The created entity

createTorus(major_rad, minor_rad)

Create a torus with the specified major_rad and minor_rad.

Parameters:

• major_rad – The torus’s major radius
• minor_rad – The torus’s minor radius

Returns:

The created entity

deleteAll()

Delete all entities in the model.

deleteEnt(entity)

Delete the specified entity.

Parameters:

• entity – An entity to delete

getVtxCoords(src[, dest, storage_order, out])

Get the coordinates of the vertices specified in src.

If dest is supplied, return parameterized coordinates relative to the entity or entities specified in dest. dest may either be an entity (or array of entities) or a tuple of the entities and the basis of the parameterized coordinates. If the basis is not specified, it is inferred from the first entity in dest.

With dest supplied, if src is a single Entity or an array with one element, return the coordinates of that entity relative to each entity in dest. Likewise, if dest is a single entity,return the coordinates of each of src relative to that entity.

Parameters:

• src – Vertex or array of vertices being queried
• dest – Either 1) an entity or array of entities, or 2) a tuple containing (1) followed by the expected basis of the coordinates.
• storage_order – Storage order of vertices to be returned

Returns:

If entities and dest (if specified) are both single Entities, the coordinates of src Otherwise, an array of coordinates.

getEntCoords(coords[, src, dest, storage_order, out])

Transform the supplied coords relative to the bases in src and dest.

src and dest, if supplied, represent the parameterization of the input and output coordinates, respectively. Both may either be an entity (or array of entities) or a tuple of the entities and the basis of the parameterized coordinates. If the basis is not specified, it is inferredfrom the first entity in src or dest.

If src is supplied, coords should be parameterized relative to the entities in src. If src is a single Entity or an array with one element, transform the coordinates of each element in coords relative to that element. Likewise, if coords is a single vector, transform the its coordinates relative to that each entity in src.

If dest is supplied, the resulting coordinates will be parameterized relative to the entities in dest. A similar relation between arrays and single elements of dest exists as with src.

Parameters:

• coords – Coordinate(s) being queried
• src – Either 1) an entity or array of entities, or 2) a tuple containing (1) followed by the expected basis of the coordinates.
• dest – Either 1) an entity or array of entities, or 2) a tuple containing (1) followed by the expected basis of the coordinates.
• storage_order – Storage order of the coordinates supplied and returned

Returns:

If source is a single vector, and src and dest (if specified) are both single Entities, then a single transformed coordinates. Otherwise, an array of coordinates.

measure(entities[, out])

Return the measure (length, area, or volume, as applicable) of the specified entities.

Parameters:

• entities – Entity or array of entities being queried

Returns:

If entities is a single Entity, the measure of that entity. Otherwise, an array of measures.

getEntType(entities[, out])

Get the entity type for the specified entities.

Parameters:

• entities – Entity or array of entities being queried

Returns:

If entities is a single Entity, the type of the entity. Otherwise, an array of the entity types.

getFaceType(entity)

Return an implementation-defined string describing the type of the specified face.

Parameters:

• entity – The entity to query

Returns:

A string describing the face’s type

isEntParametric(entities[, out])

Return whether the specified entities have parameterization.

Parameters:

• entities – Entity or array of entities being queried

Returns:

If entities is a single Entity, a boolean representing whether the entity has parameterization. Otherwise, an array of booleans.

isEntPeriodic(entities[, out])

Return whether the specified entities are periodic.

Parameters:

• entities – Entity or array of entities being queried

Returns:

If entities is a single Entity, a boolean representing whether the entity is periodic. Otherwise, an array of booleans.

isFcDegenerate(entities[, out])

Return whether the specified faces are degenerate.

Parameters:

• entities – Entity or array of entities being queried

Returns:

If entities is a single Entity, a boolean representing whether the face is degenerate. Otherwise, an array of booleans.

getEntBoundBox(entities[, storage_order, out])

Return the bounding box for the specified entities.

Parameters:

• entities – Entity or array of entities being queried
• storage_order – Storage order of vertices to be returned

Returns:

If entities is a single Entity, the coordinates of the bounding box. Otherwise, an array of coordinates.

getEntRange(entities[, basis, storage_order, out])

Return the parametric range of the specified entities. If basis is specified, assume that the parameterization of entities is in that basis. Otherwise, infer the basis from the first element of entities.

Parameters:

• entities – Entity or array of entities being queried
• basis – The Basis of the supplied coordinates
• storage_order – Storage order of the vectors returned

Returns:

If entities is a single Entity, a pair of vectors representing the parametric range. Otherwise, A pair of arrays of vectors.

getEntTolerance(entities[, out])

Return the tolerance for the specified entities.

Parameters:

• entities – Entity or array of entities being queried

Returns:

If entities is a single Entity, the tolerance (as a float). Otherwise, an array of tolerances.

getEntAdj(entities, type[, out])

Get entities of the specified type adjacent to elements of entities. If entities is a single Entity, returns an array of adjacent entities. If entities is an array of entities, return an OffsetListSingle instance.

Parameters:

• entities – Entity or array of entities being queried
• type – Type of adjacent entities being requested

Returns:

If entities is a single Entity, an array of adjacent entities. Otherwise, an OffsetListSingle instance.

getEnt2ndAdj(entities, bridge_type, type[, out])

Get “2nd order” adjacencies to an array of entities, that is, from each entity, through other entities of a specified “bridge” dimension, to other entities of another specified “to” dimension. If entities is a single Entity, returns an array of adjacent entities. If entities is an array of entities, return an OffsetListSingle instance.

Parameters:

• entities – Entity or array of entities being queried
• bridge_type – Type of bridge entity for 2nd order adjacencies
• type – Type of adjacent entities being requested

Returns:

If entities is a single Entity, an array of adjacent entities. Otherwise, an OffsetListSingle instance.

isEntAdj(entities1, entities2[, out])

Return an array indicating whether the entities in the array entities1 are pairwise adjacent to those in entities2. If entities1 is a single Entity or an array with one element, then return an array indicating that entity’s adjacency with each entity in entities2 (likewise when entities2 is a single entity).

Parameters:

• entities1 – Entity or array of entities being queried
• entities2 – Entity or array of entities being queried

Returns:

If entities1 and entities2 are both single Entities, a boolean indicating whether they are adjacent. Otherwise, an array of booleans.

getEntClosestPt(entities, coords[, storage_order, out])

Return the pairwise closest points on entities to the points specified in coords. If entities is a single Entity or an array with one element, return the closest points on that entity to the points in coords. Likewise, if coords is a single point, return the closest points on each of entities to that point.

Parameters:

• entities – Entity or array of entities being queried
• coords – XYZ coordinate(s) being queried
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities is a single Entity, and coords is a vector, return a vector representing the closest point. Otherwise, return an array of vectors.

getEntNormal(entities, coords[, basis=Basis.xyz, storage_order, out])

Return the pairwise normals on entities at the points specified in coords. If entities is a single Entity or an array with one element, return the normals on that entity at the points in coords. Likewise, if coords is a single point, return the normals on each of entities at that point.

Parameters:

• entities – Entity or array of entities being queried
• coords – Coordinate(s) being queried
• basis – The Basis of the supplied coordinates
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities is a single Entity, and coords is a vector, return a vector representing the normal. Otherwise, return an array of vectors.

getEntNormalPl(entities, coords[, storage_order, out])

Return the pairwise closest points and normals on entities to/at the points specified in coords. If entities is a single Entity or an array with one element, return the closest points/normals on that entity at the points in coords. Likewise, if coords is a single point, return the closest points/normalson each of entities at that point.

Parameters:

• entities – Entity or array of entities being queried
• coords – XYZ coordinate(s) being queried
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities is a single Entity, and coords is a vector, return a tuple of the closest point and the normal. Otherwise, return a tuple of arrays of the closest points and normals.

getEntTangent(entities, coords[, basis=Basis.xyz, storage_order, out])

Return the pairwise tangents on entities at the points specified in coords. If entities is a single Entity or an array with one element, return the tangents on that entity at the points in coords. Likewise, if coords is a single point, return the tangents on each of entities at that point.

Parameters:

• entities – Entity or array of entities being queried
• coords – Coordinate(s) being queried
• basis – The Basis of the supplied coordinates
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities is a single Entity, and coords is a vector, return a vector representing the tangent. Otherwise, return an array of vectors.

getEntCurvature(entities, coords[, basis=Basis.xyz, type, storage_order, out])

Return the pairwise curvatures on entities at the points specified in coords. If entities is a single Entity or an array with one element, return the curvatures on that entity at the points in coords. Likewise, if coords is a single point, return the curvatures on each of entities at that point.

If type is specified, this method assumes that the elements of entities are of that type. Otherwise, the type is inferred from the first element of entities.

Parameters:

• entities – Entity or array of entities being queried
• coords – Coordinate(s) being queried
• basis – The Basis of the supplied coordinates
• type – The Type of the supplied entities
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities or coords are arrays, a pair of arrays of vectors representing the two curvatures of each entity. Otherwise, either 1) a single curvature vector when entities is a single edge, a vector, or 2) a pair of curvature vectors when entities is a single face.

Note

If entities or coords are arrays, this method will always return pairs of curvatures, even for edges. Only the first curvature is valid, however.

getEntEval(entities, coords[, type, storage_order, out])

Return pairwise data about entities at the points specified in coords. If entities is a single Entity or an array with one element, return the data for that entity at the points in coords. Likewise, if coords is a single point, return the data for each of entities at that point.

The data returned depends on the type of the entities. If type is edge, return the closest point, tangent, and curvature of entities at coords. If type is face, return the closest point, normal, and bothcurvatures of entities at coords. If type is unspecified, it is inferred from the first element of entities.

Parameters:

• entities – Entity or array of entities being queried
• coords – Coordinate(s) being queried
• type – The Type of the supplied entities
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities or coords are arrays, a tuple of arrays of vectors representing the data for each entity. Otherwise, a tuple of vectors.

getEnt1stDerivative(entities, coords[, storage_order, out])

Return pairwise data about the 1st deriviative of the specified entities at coords as an OffsetListTuple instance with fields named u and v.

Parameters:

• entities – Entity or array of entities being queried
• coords – Coordinate(s) being queried
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities is a single Entity, a pair of vectors representing the 1st derivative. Otherwise, an OffsetListTuple instance with fields named u and v.

getEnt2ndDerivative(entities, coords[, storage_order, out])

Return pairwise data about the 2nd deriviative of the specified entities at coords as an OffsetListTuple instance with fields named uu, vv, and uv.

Parameters:

• entities – Entity or array of entities being queried
• coords – Coordinate(s) being queried
• storage_order – Storage order of the vertices supplied and returned

Returns:

If entities is a single Entity, a triple of vectors representing the 2nd derivative. Otherwise, an OffsetListTuple instance with fields named uu, vv, and uv.

getPtRayIntersect(points, vectors[, storage_order, out])

Intersect a ray or rays with the model and return the entities intersected, the coordinates of intersection, and the distances along the ray(s) at which the intersection occurred. If points and vectors are single vectors, return a tuple containing the above data. If both arearrays of vectors, return an OffsetListTuple instance with fields named entities, isect, and param.

Parameters:

• points – Vector or array of vectors for the sources of the rays
• vectors – Vector or array of vectors for the direction of the rays
• storage_order – Storage order of the vectors returned

Returns:

If points and vectors are single vectors, a tuple of intersection data. If both are arrays of vectors, an OffsetListTuple instance with fields named entities, isect, and param.

getPtClass(points[, storage_order, out])

Return the entity (or entities) on which a point (or points) lies.

Parameters:

• points – Point or array of points to query
• storage_order – Storage order of the points supplied

Returns:

If points is a single point, the entity on which it lies. Otherwise, an array of entities.

getEntNormalSense(faces, regions[, out])

Return the pairwise sense of a face or array of faces with respect to a region or array of regions. The sense is returned as -1, 0, or 1, representing “reversed”, “both”, or “forward”. A sense value of “both” indicates that face bounds the region once with each sense.

If faces is a single Entity or an array with one element, return the sense of that entity with respect to each entity in regions. Likewise, if regions is a single Entity, return the sense of each of faces with respect to that region.

Parameters:

• faces – The face or array of faces to query
• regions – The region or array of regions to query

Returns:

If faces and regions are both single Entities, return the sense (as an integer). Otherwise, return an array of senses.

getEgFcSense(edges, faces[, out])

Return the pairwise sense of an edge or array of edges with respect to a face or array of faces. The sense is returned as -1, 0, or 1, representing “reversed”, “both”, or “forward”. A sense value of “both” indicates that edge bounds the face once with each sense.

If edges is a single Entity or an array with one element, return the sense of that entity with respect to each entity in faces. Likewise, if faces is a single Entity, return the sense of each of edges with respect to that face.

Parameters:

• edges – The edge or array of edges to query
• faces – The face or array of faces to query

Returns:

If edges and faces are both single Entities, return the sense (as an integer). Otherwise, return an array of senses.

getEgVtxSense(edges, vertices1, vertices2[, out])

Return the pairwise sense of a pair of vertices or pair of array of vertices with respect to an edge or array of edges. The sense is returned as -1, 0, or 1, representing “reversed”, “both”, or “forward”. A sense value of “both” indicates that the vertices bound the edge once with each sense.

If vertices1 and vertices2 are both single Entities or arrays with one element each, return the sense of those vertices with respect to each entity in edges. Likewise, if edges is a single Entity, return the sense of each of vertices1 and vertices2 with respect to that edge.

Parameters:

• edges – The edge or array of edges to query
• vertices1 – The first vertex or array of vertices to query
• vertices2 – The second vertex or array of vertices to query

Returns:

If edges, vertices1, and vertices2 are alll single Entities, return the sense (as an integer). Otherwise, return an array of senses.

copyEnt(entity)

Copy the specified entity and return the duplicate.

Parameters:

• entity – The entity to copy

Returns:

The created entity

moveEnt(entity, direction)

Translate an entity in a particular direction.

Parameters:

• entity – The entity to translate
• direction – A vector representing the displacement

rotateEnt(entity, angle, axis)

Rotate an entity about an axis.

Parameters:

• entity – The entity to rotate
• angle – The angle (in degrees) to rotate the entity
• axis – The axis about which to rotate the entity

reflectEnt(entity, axis)

Reflect an entity about an axis.

Parameters:

• entity – The entity to reflect
• axis – The axis about which to reflect the entity

scaleEnt(entity, scale)

Scale an entity in the x, y, and z directions.

Parameters:

• entity – The entity to scale
• scale – A vector of the x, y, and z scaling factors

sweepEntAboutAxis(entity, angle, axis)

Sweep (extrude) the specified entity about an axis.

Parameters:

• entity – The entity to entity
• angle – The angle (in degrees) to sweep the entity
• axis – The axis about which to sweep the entity

Returns:

The created entity

uniteEnts(entities)

Geometrically unite the specified entities and return the result. This method may also be called with uniteEnts(ent1, ent2, ent3).

Parameters:

• entities – The entities to unite

Returns:

The resulting entity

subtractEnts(entity1, entity2)

Geometrically subtract entity2 from entity1 and return the result.

Parameters:

• entity1 – The entity to be subtracted from
• entity2 – The entity to subtract

Returns:

The resulting entity

intersectEnts(entity1, entity2)

Geometrically intersect entity1 and entity2 and return the result.

Parameters:

• entity1 – An entity to intersect
• entity2 – An entity to intersect

Returns:

The resulting entity

sectionEnt(entity, normal, offest, reverse)

Section an entity along a plane and return the result.

Parameters:

• entity – The entity to section
• normal – The normal of the plane
• offset – The plane’s offset from the origin
• reverse – True is the resulting entity should be reversed, false otherwise.

Returns:

The resulting entity

imprintEnts(entities)

Imprint the specified entities.

Parameters:

• entities – The entities to be imprinted

mergeEnts(entities, tolerance)

Merge the specified entities if they are within the specified tolerance.

Parameters:

• entities – The entities to merge
• tolerance – Tolerance for determining if entities should be merged

createEntSet(ordered)

Create an EntitySet, either ordered or unordered. Unordered entity sets can contain a given entity or set only once.

Parameters:

• ordered – True if the list should be ordered, false otherwise

Returns:

The newly-created EntitySet

destroyEntSet(set)

Destroy an entity set.

Parameters:

• set – Entity set to be destroyed

createTag(name, size, type)

Create a Tag with specified name, size, and type. The tag’s size is the number of values of type type that can be held. type can be a NumPy dtype (or an object convertible to one; int and Entity are special-cased), or a single character:

Type object	Type char	Result
numpy.int32	'i'	Integer
numpy.float64	'd'	Double
Entity	'E'	Entity handle
numpy.byte	'b'	Binary data

Parameters:

• name – Tag name
• size – Size of tag in number of values
• type – Type object or character representing the tag’s type

Returns:

The created Tag

destroyTag(tag, force)

Destroy a Tag. If force is true and entities still have values set for this tag, the tag is deleted anyway and those values disappear. Otherwise the tag is not deleted if entities still have values set for it.

Parameters:

• tag – Tag to delete
• force – True if the tag should be deleted even if there are values set for it

getTagHandle(name)

Get the handle of an existing tag with the specified name.

Parameters:

• name – The name of the tag to find

Returns:

The Tag with the specified name

getAllTags(entities[, out])

Get all the tags associated with a specified entity or entity set.

Parameters:

• entities – Entity or entity set being queried

Forwarding

In addition to the methods listed above, Geom automatically forwards method calls to the root EntitySet. Thus,

geom.getEntities(iBase.Type.all)

is equivalent to:

geom.rootSet.getEntities(iBase.Type.all)

EntitySet

class itaps.iGeom.EntitySet(set[, instance])

Return a new set referring to the handled contained in set. If set is an itaps.iBase.EntitySet instance, instance must also be specified.

len(entset)

Return the number of entities in the entity set. Equivalent to entset.getNumOfType(iBase.Type.all).

iter(entset)

Return an iterator over the elements in the entity set. Equivalent to entset.iterate().

instance

Return the Geom instance from which this entity set was created.

isList

Return whether this entity set is ordered.

getNumOfType(type)

Get the number of entities with the specified type in this entity set.

Parameters:

• type – Type of entity requested

Returns:

The number of entities in this entity set of the requested type

getEntities([type=iBase.Type.all, out])

Get entities of a specific type in this entity set. All entities of a given type are requested by specifying itaps.iBase.Type.all.

Parameters:

• type – Type of entities being requested

Returns:

Array of entity handles from this entity set meeting the requirements of type

getNumEntSets([hops=-1])

Get the number of sets contained in this entity set. If this entity set is not the root set, hops indicates the maximum number of contained sets from this set to one of the contained sets, inclusive of this set.

Parameters:

• hops – Maximum number of contained sets from this set to a contained set, not including itself

Returns:

Number of entity sets found

getEntSets([hops=-1, out])

Get the sets contained in this entity set. If this entity set is not the root set, hops indicates the maximum number of contained sets from this set to one of the contained sets, inclusive of this set.

Parameters:

• hops – Maximum number of contained sets from this set to a contained set, not including itself

Returns:

Array of entity sets found

add(entities)

Add an entity, entity set, or array of entities to this entity set.

Parameters:

• entities – The entity, entity set, or array of entities to add

remove(entities)

Remove an entity, entity set, or array of entities from this entity set.

Parameters:

• entities – The entity, entity set, or array of entities to remove

contains(entities)

Return whether an entity, entity set, or array of entities is contained in this entity set.

Parameters:

• entities – The entity, entity set, or array of entities to query

Returns:

If entities is an array of entities, an array of booleans corresponding to each element of entities. Otherwise, a single boolean.

isChild(set)

Return whether an entity set is a child of this entity set.

Parameters:

• set – The entity set to query:

Returns:

True if set is a child of this entity set, false otherwise

getNumChildren([hops=-1])

Get the number of child sets linked from this entity set. If hops is non-zero, this represents the maximum hops from this entity set to any child in the count.

Parameters:

• hops – Maximum hops from this entity set to a child set, not inclusive of the child set

Returns:

Number of children

getNumParents([hops=-1])

Get the number of parent sets linked from this entity set. If hops is non-zero, this represents the maximum hops from this entity set to any parents in the count.

Parameters:

• hops – Maximum hops from this entity set to a parent set, not inclusive of the parent set

Returns:

Number of parents

getChildren([hops=-1, out])

Get the child sets linked from this entity set. If hops is non-zero, this represents the maximum hops from this entity set to any child in the result.

Parameters:

• hops – Maximum hops from this entity set to a child set, not inclusive of the child set

Returns:

Array of children

getParents([hops=-1, out])

Get the parents sets linked from this entity set. If hops is non-zero, this represents the maximum hops from this entity set to any parent in the result.

Parameters:

• hops – Maximum hops from this entity set to a parent set, not inclusive of the parent set

Returns:

Array of parents

addChild(set)

Add set as a child to this entity set.

Parameters:

• set – The entity set to add

removeChild(set)

Remove set as a child from this entity set.

Parameters:

• set – The entity set to remove

iterate([type=iBase.Type.all, count=1])

Initialize an Iterator over the specified entity type for this entity set. If count is greater than 1, each step of the iteration returns an array of count entities. Equivalent to:

itaps.iGeom.Iterator(self, type, count)

Parameters:

• type – Type of entities being requested
• count – Number of entities to return on each step of iteration

Returns:

An Iterator instance

difference(set)

Subtract contents of an entity set from this set. Equivalent to self - set.

Parameters:

• set – Entity set to subtract

Returns:

Resulting entity set

intersection(set)

Intersect contents of an entity set with this set. Equivalent to self & set.

Parameters:

• set – Entity set to intersect

Returns:

Resulting entity set

union(set)

Unite contents of an entity set with this set. Equivalent to self | set.

Parameters:

• set – Entity set to unite

Iterator

class itaps.iGeom.Iterator(set[, type=iBase.Type.all, count=1])

Return a new iterator on the entity set set to iterate over entities of the specified type. If count is greater than 1, each step of the iteration will return an array of count entities. All entities of a given type are requested by specifying itaps.iBase.Type.all.

Parameters:

• set – Entity set to iterate over
• type – Type of entities being requested
• count – Number of entities to return on each step of iteration

instance

Return the :class:Geom instance from which this iterator was created.

reset()

Resets the iterator to the beginning.

Tag

class itaps.iGeom.Tag(tag[, instance])

Return a new tag referring to the handled contained in tag. If tag is an itaps.iBase.Tag instance, instance must also be specified.

tag[entities]

Get the tag data for an entity, entity set, or array of entities.

tag[entities] = data

Set the tag data for an entity, entity set, or array of entities to data.

del tag[entities]

Remove the tag data for an entity, entity set, or array of entities.

instance

Return the Geom instance from which this tag was created.

name

Get the name for this tag.

sizeValues

Get the size in number of values for this tag.

sizeBytes

Get the size in bytes for this tag.

type

Get the data type for this tag as a character code (see above).

get(entities[, out])

Get the tag data for an entity, entity set, or array of entities. This method is equivalent to tag[entities]`.

Parameters:

• entities – Entity, entity set, or array of entities to get

Returns:

The tag data for entities

getData(entities)

Get the tag data for an entity, entity set, or array of entities. This method is deprecated in favor of tag[entities].

setData(entities, data)

Set the tag data for an entity, entity set, or array of entities to data. This method is deprecated in favor of tag[entities] = data.

remove(entities)

Remove the tag data for an entity, entity set, or array of entities. This method is deprecated in favor of del tag[entities].

Enumerations

class itaps.iGeom.Basis

An enumeration of geometric bases for use in querying different coordinate systems.

xyz

Standard (world-space) coordinates

uv

Parametric coordinates for two-dimensional objects (faces)

u

Parametric coordinates for one-dimensional objects (edges)