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

Public Member Functions

Properties