dataObject([dims [, dtype=’uint8’[, continuous = 0][, data = valueOrSequence]]]) -> constructor to get a new dataObject.
| Parameters : | dims : {List of Integer}, optional
dtype : {str}, optional
continuous : {str}, optional
data : {str}, optional
|
|---|---|
| Returns : | dataObject {dataObject} : |
Notes
The itom.dataObject contains a n-dimensional matrix and corresponding meta-data. It has a direct c++-representation for the python-c++ interface. The n-dimensional matrix can have different element types. Recently the following types are supported:
Warning ‘uint32’ is not fully openCV-compatible and hence causes instability!
In order to handle huge matrices, the data object can divide one matrix into subparts in memory. Each subpart (called matrix-plane) is two-dimensional and covers data of the last two dimensions. In c++-context each of these matrix-planes is of type cv::Mat_<type> and can be used with every operator given by the openCV-framework (version 2.3.1 or higher).
The dimensions of the matrix are structured descending. So if we assume to have a n-dimensional matrix A, where each dimension has its size s_i, the dimensions order is n, .., z, y, x and the corresponding sizes of A are [s_n, s_(n-1), s_(n-2), ..., s_y, s_x].
In order to make the data object compatible to continuously organized data structures, like numpy-arrays, it is also possible to have all matrix-planes in one data-block in memory (not recommended for huge matrices). Nevertheless, the indicated data structure with the two-dimensional sub-matrix-planes is still existing. The data organization is equal to the one of open-cv, hence, two-dimensional matrices are stored row-by-row (C-style)...
Deep Copy, Shallow Copy and ROI
It is possible to set a n-dimensional region of interest (ROI) to each matrix, the virtual dimensions, which will be delivered if the user asks for the matrix size. To avoid copy operations where possible a simple =_Operator will also make a shallow copy of the object. Shallow copies share the same data (elements and meta data) with the original object, hence manipulations of one object will affect the original object and all shallow copies.
The opposite a deep copy of a dataObject (by sourceObject.copy()) creates a complete mew matrix with own meta data object.
Example:
#Create an object
dObj = dataObject([5, 10, 10], 'int8')
# Make a shallow copy
dObjShallow = dObj
# Make a shallow copy on ROI
dObjROI = dObj[1, :, :]
# Set the value of element [1, 0, 0] to 0
dObj[1, 0, 0] = 0
# Make a deep copy of the dObjROI
dObjROICopy = dObjROI.copy()
# Set the value of dObjROICopy element [0, 0, 0] to 127 without effecting other objects
dObjROICopy[0, 0, 0] = 127
Constructor The function dataObject([dims [, dtype=’uint8’[, continuous = 0][, data = valueOrSequence]]]) creates a new itom-dataObject filled with undefined data. If no parameters are given, an uninitilized DataObject (dims = 0, no sizes) is created.
As second possibility you can also use the copy-constructor ‘dataObject(AnyArray)’, where AnyArray must be any array-like structure which is parsable by the numpy-interface.
Further static methods for object construction are dataObject.zeros(..), dataObject.ones(..), dataObject.rand(..), dataObject.randN(..) and dataObject.eye(..).
| Parameters : | newLine : {str}
|
|---|
Notes
Appends a protocol line to the protocol. The current ROIs of the dataObject are added automatically. Also a new line is added automatically to the protocol. The content of the protocol can be addressed by ‘dataObject.tags[‘protocol’]’
Notes
doctodo
Notes
doctodo
Notes
doctodo
Notes
doctodo
| Returns : | doctodo : |
|---|
Notes
Every value of this dataObject is replaced by its complex-conjugate value. If the data type of this dataObject is no complex data type, a TypeError is raised.
| Returns : | copy of this dataObject : |
|---|
Notes
If the data type of this dataObject is no complex data type, a TypeError is raised.
| Parameters : | regionOnly : {}, optional |
|---|
Notes
doctodo
Notes
When calling this method, the complete content of the dataObject is printed to the standard output stream.
| Parameters : | key : {str}
|
|---|
Notes
Remove a tag from the tag space the tag space.
| Parameters : | doctodo : |
|---|---|
| Returns : | doctodo : |
Notes
doctodo
| Parameters : | key : {str}
|
|---|---|
| Returns : | checkExists : {bool} |
Notes
Checks if a specific tag already exists and return the result as a boolean value.
| Parameters : | size : {int},
dtype : {str}, optional
|
|---|---|
| Returns : | The dataObject : {dataObject} |
Notes
Static method for creating a two-dimensional, square, eye-matrix of type itom-dataObject.
Notes
doctodo
Notes
locateROI returns a tuple with two elements. The first is a list with the original sizes of this matrix, the second is a list with the offset for each axe in order to get from the original first element to the first element in the given ROI
| Returns : | doctodo : |
|---|
Notes
doctodo
| Parameters : | doctodo : |
|---|
Notes
doctodo
Notes
doctodo
| Parameters : | dims : {List of Integer}
dtype : {str}, optional
continuous : {str}, optional
|
|---|---|
| Returns : | The dataObject : {dataObject} |
Notes
Creates a new itom-dataObject filled with ones.
| Parameters : | dims : {List of Integer}
dtype : {str}, optional
continuous : {str}, optional
|
|---|---|
| Returns : | The dataObject : {dataObject} |
Notes
Creates a new itom-dataObject filled with uniform distributed random numbers. In case of an integer type, the uniform noise is from min<ObjectType>(inclusiv) to max<ObjectType>(inclusiv). For floating point types, the noise is between 0(inclusiv) and 1(exclusiv).
| Parameters : | dims : {List of Integer}
dtype : {str}, optional
continuous : {str}, optional
|
|---|---|
| Returns : | The dataObject : {dataObject} |
Notes
Creates a new itom-dataObject filled with gaussian distributed random numbers. In case of an integer type, the gausian noise mean value is (max+min)/2.0 and the standard deviation is (max-min/)6.0 to max. For floating point types, the noise mean value is 0 and the standard deviation is 1.0/3.0.
| Returns : | reshaped shallow copy of data object : |
|---|
Notes
Not implemented yet.
| Parameters : | axisNum : {int}
axisDescription : {str}
|
|---|
Notes
Set the axis description (e.g. intensity) of axisNum
| Parameters : | axisNum : {int}
axisOffset : {double}
|
|---|
Notes
Set the axis offset in [px] of axisNum to axisOffset, Unit-Coordinate = ( px-Coordinate - Offset)* Scale
| Parameters : | axisNum : {int}
axisScale : {double}
|
|---|
Notes
Set the axis scale in [unit / px] of axisNum to axisScale, Unit-Coordinate = ( px-Coordinate - Offset)* Scale
| Parameters : | axisNum : {int}
axisUnit : {str}
|
|---|
Notes
Set the axis unit (e.g. mm) of axisNum
| Parameters : | key : {str}
tagvalue : {str or double}
|
|---|
Notes
Set the value of a tag within the meta data tagspace. If tag does not exist, it is created. Do NOT use ‘special character’ within the tag key because they are not XML-save.
| Parameters : | index : {PyDataObject}, optional |
|---|
Notes
doctodo
| Returns : | ShallowCopy : {dataObject}
|
|---|
Notes
This method removes every dimension with size equal to 1. Take care, that none of the last two dimensions is considered by this squeeze-command. The squeezed return value is a shallow copy of the original dataObject and hence changes in its values will also change the original data set. (This command is equal to numpy.squeeze)
Notes
doctodo
| Returns : | doctodo : |
|---|
Notes
doctodo
| Parameters : | dims : {List of Integer}
dtype : {str}, optional
continuous : {str}, optional
|
|---|---|
| Returns : | The dataObject : {dataObject} |
Notes
Creates a new itom-dataObject filled with zeros.
tuple containing the axis descriptions.
This attribute gives access to the internal axis descriptions expressed as a tuple strings. One entry for each object dimensions is due. This tuple is readonly, but you can either set an entire new tuple or change specific elements using the method setAxisDescription(index,value)
setter: Tuple of double value with size equal object dims.
getter: Readonly tuple of double value with size equal object dims.
Notes
{tuple of str} : ReadWrite
tuple containing the axis offsets [px].
This attribute gives access to the internal axis offsets [px] expressed as a tuple double values. One entry for each object dimensions is due. This tuple is readonly, but you can either set an entire new tuple or change specific elements using the method setAxisOffset(index,value).
Definition: Unit-Coordinate = ( px-Coordinate - Offset)* Scale setter: Tuple of double value with size equal object dims.
getter: Readonly tuple of double value with size equal object dims.
Notes
{tuple of double} : ReadWrite
tuple containing the axis scales [unit/px].
This attribute gives access to the internal axis scales [unit/px] expressed as a tuple double values. One entry for each object dimensions is due. This tuple is readonly, but you can either set an entire new tuple or change specific elements using the method setAxisScale(index,value)
Definition: Unit-Coordinate = ( px-Coordinate - Offset)* Scale setter: Tuple of double value with size equal object dims. getter: Readonly tuple of double value with size equal object dims.
Notes
{tuple of double} : ReadWrite
tuple containing the axis units.
This attribute gives access to the internal axis units expressed as a tuple strings. One entry for each object dimensions is due. This tuple is readonly, but you can either set an entire new tuple or change
specific elements using the method setAxisUnit(index,value)
setter: Tuple of double value with size equal object dims.
getter: Readonly tuple of double value with size equal object dims.
Notes
{tuple of str} : ReadWrite
base object
true if matrix is continuously organized, else false. If matrix is continuously organized this function returns true, else false. If true, the whole matrix is allocated in one huge block in memory, hence, this data object can be transformed into a numpy representation (npDataObject) without reallocating memory. Notes —– {bool} : ReadOnly
number of dimensions of this data object Notes —– {int} : ReadOnly
get type string of data in this data object This attribute returns the dataObject-Type as a string. This type string has one of these values: ‘uint8’, ‘int8’, ‘uint16’, ‘int16’, ‘uint32’, ‘int32’, ‘float32’, ‘float64’, ‘complex64’, ‘complex128’
Notes
{str} : ReadOnly
new dictionary with all tags inside
Notes
{dict} : ReadOnly
tag dictionary for this data object.
By this attribute you get access to the read-only tag dictionary or you can set an entire new dictionary. You can add single elements using the method setTag(key,value) or you can delete tags using deleteTag(key). The value of the tags can be either numeric or string values. Do NOT use ‘special character’ within the tag key because they are not XML-save. setter: The dataObject dictionary is filled with the entries in ‘newDictionary’. getter: A readonly dictionary with all Metadata-Tags of the dataObject.
Notes
{bool} : ReadWrite
get/set the values within the ROI as a one-dimensional tuple.
This method gets or sets the values within the ROI. If this attribute is called by means of a getter, a tuple is returned which is created by iterating through the values of the data object (row-wise). In the same way of iterating, the values are set to the data object if you provide a tuple of the size of the data object or its ROI, respectively.
Example
b = dataObject[1,1:10,1,1].value
# or for the first value
b = dataObject[1,1:10,1,1].value[0]
# The elements of the tuple are adressed with b[idx].
value unit description.
Notes
{str} : ReadWrite
value offset [default: 0.0].
Notes
{float???} : ReadOnly
value scale [default: 1.0].
Notes
{float???} : ReadWrite
value unit string.
Notes
{str} : ReadWrite
Access the 3x3 rotational matrix in the dataObject tagspace
This attribute gives access to the xyRotationalMatrix in the metaData-Tagspace. The getter method retuns a 3x3-Array deepcopied from the internal matrix, Implemented to offer compability to x3p format.
Notes
{3x3 array of doubles} : ReadWrite