|
def | __init__ (self, name, source, images, plugin=None, isTimeDependent=None, kwargs) |
|
def | calculateAABB (self, overwrite=False) |
|
def | calculateImageRange (self) |
|
def | clear (self) |
|
def | setShared (self, isShared) |
|
def | getDataset (self) |
|
def | getImageRange (self) |
|
def | getRealImageRange (self) |
|
def | getArrayDims (self) |
|
def | getVoxelSize (self) |
|
def | getVolumeTransform (self, make2DVol=True) |
|
def | getTransform (self) |
|
def | setTransform (self, trans) |
|
def | getVolumeCorners (self) |
|
def | getTimestepList (self) |
|
def | setTimestepList (self, timesteps) |
|
def | getOrientMap (self) |
|
def | getTimeOrientMap (self) |
|
def | getTimestepIndices (self) |
|
def | getVolumeStacks (self) |
|
def | getPropTuples (self) |
|
def | getNearestTimestepIndices (self, timestep) |
|
def | __init__ (self, name, plugin=None, kwargs) |
|
def | __getattr__ (self, name) |
|
def | getLabel (self) |
|
def | getPropTuples (self) |
|
def | getName (self) |
|
def | setName (self, name) |
|
def | getReprTypes (self) |
|
def | removeRepr (self, rep) |
|
def | getDataset (self) |
|
def | setTimestepList (self, tslist) |
|
def | setTimestepScheme (self, starttime, interval) |
|
def | getTimestepList (self) |
|
def | getTimestepScheme (self) |
|
def | __repr__ (self) |
|
◆ __init__()
def __init__ |
( |
|
self, |
|
|
|
name, |
|
|
|
source, |
|
|
|
images, |
|
|
|
plugin = None , |
|
|
|
isTimeDependent = None , |
|
|
|
kwargs |
|
) |
| |
◆ calculateAABB()
def calculateAABB |
( |
|
self, |
|
|
|
overwrite = False |
|
) |
| |
◆ calculateImageRange()
def calculateImageRange |
( |
|
self | ) |
|
◆ clear()
◆ getArrayDims()
Get the 4 dimensions (columns, rows, height, time) for a 4D array containing the volume image data.
◆ getDataset()
◆ getImageRange()
def getImageRange |
( |
|
self | ) |
|
Returns the stored minimal and maximal values that would be expected in image data.
◆ getNearestTimestepIndices()
def getNearestTimestepIndices |
( |
|
self, |
|
|
|
timestep |
|
) |
| |
◆ getOrientMap()
Returns a map from rotators to lists of numbers indexing each image having that orientation. The ordering of
the indices is dependent on the ordering of self.images.
◆ getPropTuples()
def getPropTuples |
( |
|
self | ) |
|
◆ getRealImageRange()
def getRealImageRange |
( |
|
self | ) |
|
Get actual minimal and maximal image values as stored in the SharedImage objects themselves.
◆ getTimeOrientMap()
def getTimeOrientMap |
( |
|
self | ) |
|
Returns a map from (vec3,rotator) pairs to the indices of all images (in temporal order) having that
position and orientation. Each value in the map thus indexes the images defining a 2D slice in time. The
ordering of the indices is depedent on the ordering of self.images if multiple colocated images have the
same timestep.
◆ getTimestepIndices()
def getTimestepIndices |
( |
|
self | ) |
|
Returns a list of pairs containing the time for each timestep (ie. the average timing value of the images
defining the timestep) and a list if image indices for those images at that time. If this image is not time-
dependent, then each member of the list has the same time value but represents an independent image series
which are differentiated by position and orientation. The indices are always sorted in stack order. If multiple
stacks define volumes at the same position and time they will be listed one after the other. The ordering of the
indices is dependent on the ordering of self.images. 2D image series are treated as single image stacks, so the
result will be a list of lists containing single indices.
◆ getTimestepList()
def getTimestepList |
( |
|
self | ) |
|
Returns the list of timestep values for each step of this image.
◆ getTransform()
Return the actual image transform, defining a 3D volume for 3D images and 2D plane for 2D images.
◆ getVolumeCorners()
def getVolumeCorners |
( |
|
self | ) |
|
Get the 8 corner vectors of the image volume.
◆ getVolumeStacks()
def getVolumeStacks |
( |
|
self | ) |
|
Returns lists of index lists referring to the members of `images' which define volumes. Each member list indexes
the images for a volume in bottom-up order. If this object is time-dependent then each member list of the
returned list represents a stack for each timestep, and are given in temporal order. If the object is not
time-dependent, then each member list represents an independent stack in the series of images differentiated
by orientation and given in an arbitrary order. If multiple stacks define volumes at the same position and time
they will be listed together, so a list of indices in the returned list may define multiple overlaying volumes.
The ordering of the indices in the returned list depends on the order of images in self.images. 2D image series
are treated as single image stacks, so the result will be a list of lists containing single indices.
◆ getVolumeTransform()
def getVolumeTransform |
( |
|
self, |
|
|
|
make2DVol = True |
|
) |
| |
Get the transform from the unit cube to the hexahedron in world space defined by the image volume. if the image
is 2D and `make2DVol', the transform defined a 3D volume as thick as the largest pixel spacing value instead of
a 2D plane in space.
◆ getVoxelSize()
Get the size of each voxel in the volume in world space units.
◆ setShared()
def setShared |
( |
|
self, |
|
|
|
isShared |
|
) |
| |
◆ setTimestepList()
def setTimestepList |
( |
|
self, |
|
|
|
timesteps |
|
) |
| |
Set the timestep values for the frames of this image, `timesteps' must be as long as there are frames.
◆ setTransform()
def setTransform |
( |
|
self, |
|
|
|
trans |
|
) |
| |
Apply the transform object `trans' to this object. If this is a 2D object, `trans' is applied to every image
directly. If 3D, the translation component is used as the new origin, the voxel size is scaled by the scale
component (ie. scale of (1,1,1) preserves voxel size), and the rotational component is used as the orientation.
◆ aabb
◆ alphamasks
◆ histogram
◆ imagerange
◆ images
◆ is2D
◆ isTimeDependent
◆ maxcols
◆ maxrows
◆ proptuples
◆ source
The documentation for this class was generated from the following file: