| IOLink Python 1.11.0

Loading...
Searching...
No Matches
Public Member Functions | Properties | List of all members
iolink.iolink.Region2u64 Class Reference
Inheritance diagram for iolink.iolink.Region2u64:

## Public Member Functions
| get_dimension_count (self)
| get_origin (self)
| get_size (self)
| get_element_count (self)
| get_min (self)
| get_max (self)
| get_is_empty (self)
| contains (self, *args)
| intersect (self, other)
| intersection (self, other)
| extract_slice_from_axis (self, dimension, origin)
| __eq__ (self, other)
| to_string (self)
| __repr__ (self)
| __init__ (self, *args)

## Properties
| thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
| dimension_count = property(get_dimension_count, doc=get_dimension_count.__doc__)
| origin = property(get_origin, doc=get_origin.__doc__)
| size = property(get_size, doc=get_size.__doc__)
| element_count = property(get_element_count, doc=get_element_count.__doc__)
| min = property(get_min, doc=get_min.__doc__)
| max = property(get_max, doc=get_max.__doc__)
| is_empty = property(get_is_empty, doc=get_is_empty.__doc__)

## Detailed Description

    A multi-dimensional region defined by its origin and its size.

    Origin is always the left-bottom corner of the region.

    :param T: The type of region indexers
    :param N: The dimension of the region.

    Region definition is different according to its indexer type.
    Float-indexed-regions are defined from origin point (Org) to Max = Org + region size.
    Integer-indexed-regions are defined from Org to Max = Org + region size - 1

    Up-boundaries are not included for integer-indexers-regions (except when size is 0
    and region is a point).

    Up-boundaries are included for float-indexers-regions.

    Aliases can be used to made this class more practical to use. They use the
    following convention:
       RegionNX

    Where N is the dimension and X the type. The types currently available are:
    - F for single precision floats.
    - D for double precision floats.
    - U64 for uint64_t.

    Examples:
    - Region2u64: 2 dimensional uint64_t region.

## Member Function Documentation

## ◆ __eq__()

iolink.iolink.Region2u64.__eq__ | ( |  | self,
|  |  | other
| ) |  |

        Returns the intersection region between current and given one
        :type other: iolink::Region< uint64_t,2 >
        :param other: region
        :rtype: boolean
        :return: if current region and given one are identical
            (same origin if both null size, same origin and size otherwise)

## ◆ contains()

iolink.iolink.Region2u64.contains | ( |  | self,
|  | * | args
| ) |  |

        *Overload 1:*

        Returns if the current region contains the given one
        :type other: iolink::Region< uint64_t,2 >
        :param other: region to test if it is contained into current one
        :rtype: boolean
        :return: if the given region is contained into current one

        |

        *Overload 2:*

        Returns if the given region contains the given position vector
        :type position: iolink::Region< uint64_t,2 >::VectorType
        :param position: point to test if it is contained into current one
        :rtype: boolean
        :return: if the given position is contained into current region

## ◆ extract_slice_from_axis()

iolink.iolink.Region2u64.extract_slice_from_axis | ( |  | self,
|  |  | dimension,
|  |  | origin
| ) |  |

        Returns a region of size one along one axis

        :type dimension: int
        :param dimension: axis on which the slice must be selected
        :type origin: int
        :param origin: position of slice in given dimension

        :rtype: iolink::Region< uint64_t,2 >
        :return: the slice at given position for given dimension
        :raises: InvalidArgument if dimension or origin are out of range

        e.g. a 3D region {{0, 0, 0}, {5, 6, 7}}
        - extractSliceFromAxis(0, 3) returns 3D region {{3, 0, 0}, {1, 6, 7}}
        - extractSliceFromAxis(1, 4) returns 3D region {{0, 4, 0}, {5, 1, 7}}
        - extractSliceFromAxis(2, 5) returns 3D region {{0, 0, 5}, {5, 6, 1}}

        e.g. a 3D region with non-null origin { {2, 3, 4}, {5, 6, 7}}

        extractSliceFromAxis(0, 3) returns 3D region {{5, 3, 4}, {1, 6, 7}}

## ◆ get_dimension_count()

iolink.iolink.Region2u64.get_dimension_count | ( |  | self | ) |

    Return number of dimension of this region

## ◆ get_element_count()

iolink.iolink.Region2u64.get_element_count | ( |  | self | ) |

        Return number of elements (pixel, voxel, samples) contained in the region.
        For Integer-indexed-regions, it return product of each dimensions.
        This method has no sense for Float-indexed-regions and thus return 0

## ◆ get_is_empty()

iolink.iolink.Region2u64.get_is_empty | ( |  | self | ) |

        Indicates if region is empty
        :rtype: boolean
        :return: if region is empty

## ◆ get_max()

iolink.iolink.Region2u64.get_max | ( |  | self | ) |

        return max region coordinates
        :rtype: iolink::Region< uint64_t,2 >::VectorType
        :return: max region vector

## ◆ get_min()

iolink.iolink.Region2u64.get_min | ( |  | self | ) |

        return min region coordinates
        :rtype: iolink::Region< uint64_t,2 >::VectorType
        :return: min region vector

## ◆ get_origin()

iolink.iolink.Region2u64.get_origin | ( |  | self | ) |

    Return region's origin

## ◆ get_size()

iolink.iolink.Region2u64.get_size | ( |  | self | ) |

        return size of region
        :rtype: iolink::Region< uint64_t,2 >::SizeType
        :return: size vector of the region

## ◆ intersect()

iolink.iolink.Region2u64.intersect | ( |  | self,
|  |  | other
| ) |  |

        Returns if the given region intersects the given position vector
        :type other: iolink::Region< uint64_t,2 >
        :param other: region to test if it intersects with current one
        :rtype: boolean
        :return: if the given region intersects current region

## ◆ intersection()

iolink.iolink.Region2u64.intersection | ( |  | self,
|  |  | other
| ) |  |

        Returns the intersection region between current and given one
        :type other: iolink::Region< uint64_t,2 >
        :param other: region
        :rtype: iolink::Region< uint64_t,2 >
        :return: intersection region if it intersects or empty region otherwise

## ◆ to_string()

iolink.iolink.Region2u64.to_string | ( |  | self | ) |

    Return a string representation

The documentation for this class was generated from the following file:

- Release/python/iolink/iolink.py