objc2_vision/generated/

VNGeometry.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-core-foundation")]
use objc2_core_foundation::*;
#[cfg(feature = "objc2-core-graphics")]
use objc2_core_graphics::*;
use objc2_foundation::*;

use crate::*;

extern_class!(
    /// VNPoint represents a single, immutable, two-dimensional point in an image.
    ///
    /// It should be noted that VNPoint is not intended as an overall replacement of CGPoint, NSPoint or vec2, but is used by observations that need to present points which may contain additional metadata.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/vision/vnpoint?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct VNPoint;
);

unsafe impl NSCoding for VNPoint {}

unsafe impl NSCopying for VNPoint {}

unsafe impl CopyingHelper for VNPoint {
    type Result = Self;
}

unsafe impl NSObjectProtocol for VNPoint {}

unsafe impl NSSecureCoding for VNPoint {}

impl VNPoint {
    extern_methods!(
        /// Returns a VNPoint object that represents the location of (0.0, 0.0).
        #[unsafe(method(zeroPoint))]
        #[unsafe(method_family = none)]
        pub unsafe fn zeroPoint() -> Retained<VNPoint>;

        /// Returns a new VNPoint object that is shifted by X and Y offsets of the vector.
        ///
        /// Parameter `vector`: The vector offset to be applied to a source point.
        ///
        /// Parameter `point`: The source point.
        ///
        /// Returns: the translated point.
        #[unsafe(method(pointByApplyingVector:toPoint:))]
        #[unsafe(method_family = none)]
        pub unsafe fn pointByApplyingVector_toPoint(
            vector: &VNVector,
            point: &VNPoint,
        ) -> Retained<VNPoint>;

        /// Returns the Euclidean distance between two VNPoint objects.
        #[deprecated]
        #[unsafe(method(distanceBetweenPoint:point:))]
        #[unsafe(method_family = none)]
        pub unsafe fn distanceBetweenPoint_point(point1: &VNPoint, point2: &VNPoint) -> c_double;

        /// Returns the Euclidean distance to another point.
        ///
        /// Parameter `point`: The destination point.
        ///
        /// Returns: the Euclidean distance between the target and specified points.
        #[unsafe(method(distanceToPoint:))]
        #[unsafe(method_family = none)]
        pub unsafe fn distanceToPoint(&self, point: &VNPoint) -> c_double;

        /// Initializes a VNPoint object from X and Y coordinates.
        #[unsafe(method(initWithX:y:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithX_y(
            this: Allocated<Self>,
            x: c_double,
            y: c_double,
        ) -> Retained<Self>;

        #[cfg(feature = "objc2-core-foundation")]
        /// Initializes a VNPoint object from a CGPoint.
        #[unsafe(method(initWithLocation:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLocation(this: Allocated<Self>, location: CGPoint) -> Retained<Self>;

        #[cfg(feature = "objc2-core-foundation")]
        /// Returns the X and Y coordinates of the point, as CGPoint type, with respect to the origin of the coordinate system the point is defined in.
        #[unsafe(method(location))]
        #[unsafe(method_family = none)]
        pub unsafe fn location(&self) -> CGPoint;

        /// Returns the X coordinate of the point with respect to the origin of the coordinate system the point is defined in.
        #[unsafe(method(x))]
        #[unsafe(method_family = none)]
        pub unsafe fn x(&self) -> c_double;

        /// Returns the Y coordinate of the point with respect to the origin of the coordinate system the point is defined in.
        #[unsafe(method(y))]
        #[unsafe(method_family = none)]
        pub unsafe fn y(&self) -> c_double;
    );
}

/// Methods declared on superclass `NSObject`.
impl VNPoint {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// VNPoint3D represents a single, immutable, three-dimensional point in an image.
    ///
    /// It should be noted that VNPoint3D is not intended as an overall replacement of simd float4x4, but is used by observations that need to present points which may contain additional metadata.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/vision/vnpoint3d?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct VNPoint3D;
);

unsafe impl NSCoding for VNPoint3D {}

unsafe impl NSCopying for VNPoint3D {}

unsafe impl CopyingHelper for VNPoint3D {
    type Result = Self;
}

unsafe impl NSObjectProtocol for VNPoint3D {}

unsafe impl NSSecureCoding for VNPoint3D {}

impl VNPoint3D {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl VNPoint3D {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// VNVector is a two-dimensional vector represented its X and Y axis projections. Once created, VNVector objects are immutable.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/vision/vnvector?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct VNVector;
);

unsafe impl NSCoding for VNVector {}

unsafe impl NSCopying for VNVector {}

unsafe impl CopyingHelper for VNVector {
    type Result = Self;
}

unsafe impl NSObjectProtocol for VNVector {}

unsafe impl NSSecureCoding for VNVector {}

impl VNVector {
    extern_methods!(
        /// Returns a VNVector object with zero length. The theta for zeroVector is not defined (NaN).
        #[unsafe(method(zeroVector))]
        #[unsafe(method_family = none)]
        pub unsafe fn zeroVector() -> Retained<VNVector>;

        /// Returns a vector that is normalized by preserving direction, such as |v|, or vector length = 1.0.
        #[unsafe(method(unitVectorForVector:))]
        #[unsafe(method_family = none)]
        pub unsafe fn unitVectorForVector(vector: &VNVector) -> Retained<VNVector>;

        /// Returns a vector that whose X and Y projections multiplied by a scalar value.
        #[unsafe(method(vectorByMultiplyingVector:byScalar:))]
        #[unsafe(method_family = none)]
        pub unsafe fn vectorByMultiplyingVector_byScalar(
            vector: &VNVector,
            scalar: c_double,
        ) -> Retained<VNVector>;

        /// Adds two vectors v1 and v2 and returns a resulting vector v, such as v = v1 + v2.
        #[unsafe(method(vectorByAddingVector:toVector:))]
        #[unsafe(method_family = none)]
        pub unsafe fn vectorByAddingVector_toVector(
            v1: &VNVector,
            v2: &VNVector,
        ) -> Retained<VNVector>;

        /// Substructs vector v1 from v2 and returns a resulting vector v, such as v = v2 - v1.
        #[unsafe(method(vectorBySubtractingVector:fromVector:))]
        #[unsafe(method_family = none)]
        pub unsafe fn vectorBySubtractingVector_fromVector(
            v1: &VNVector,
            v2: &VNVector,
        ) -> Retained<VNVector>;

        /// Caclulates a dot product (aka 'scalar product' or 'inner product') of two vectors v1 and v2 and returns dot product value.
        #[unsafe(method(dotProductOfVector:vector:))]
        #[unsafe(method_family = none)]
        pub unsafe fn dotProductOfVector_vector(v1: &VNVector, v2: &VNVector) -> c_double;

        /// Initializes a vector in Cartesian Coordinate space, using its X and Y axis projections.
        #[unsafe(method(initWithXComponent:yComponent:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithXComponent_yComponent(
            this: Allocated<Self>,
            x: c_double,
            y: c_double,
        ) -> Retained<Self>;

        /// Initializes a vector in polar coordinate space, using R and Theta (radians), where R is the length of the vector and
        /// Theta is the ange that the vector forms with the positive direction of X axis.
        #[unsafe(method(initWithR:theta:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithR_theta(
            this: Allocated<Self>,
            r: c_double,
            theta: c_double,
        ) -> Retained<Self>;

        /// Initializes a vector in Cartesian Coordinate space, using two VNPoints - the head and the tail of the vector.
        #[unsafe(method(initWithVectorHead:tail:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithVectorHead_tail(
            this: Allocated<Self>,
            head: &VNPoint,
            tail: &VNPoint,
        ) -> Retained<Self>;

        /// Signed projection on X-axis, or X component of the vector. Sign determines direction the vector is facing in X direction.
        #[unsafe(method(x))]
        #[unsafe(method_family = none)]
        pub unsafe fn x(&self) -> c_double;

        /// Signed projection on Y-axis, or Y component of the vector. Sign determines direction the vector is facing in Y direction.
        #[unsafe(method(y))]
        #[unsafe(method_family = none)]
        pub unsafe fn y(&self) -> c_double;

        /// Radius, or absolute value, or length of the vector.
        #[unsafe(method(r))]
        #[unsafe(method_family = none)]
        pub unsafe fn r(&self) -> c_double;

        /// Angle between the vector direction and positive direction of X axis.
        #[unsafe(method(theta))]
        #[unsafe(method_family = none)]
        pub unsafe fn theta(&self) -> c_double;

        /// Returns a length, or absolute value, of the vector.
        #[unsafe(method(length))]
        #[unsafe(method_family = none)]
        pub unsafe fn length(&self) -> c_double;

        /// Returns a length ^ 2 of a vector.
        #[unsafe(method(squaredLength))]
        #[unsafe(method_family = none)]
        pub unsafe fn squaredLength(&self) -> c_double;
    );
}

/// Methods declared on superclass `NSObject`.
impl VNVector {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// VNCircle is two-dimensional circle represented by the center point 'center' and its radius 'radius'. Once created, VNCircle objects are immutable.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/vision/vncircle?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct VNCircle;
);

unsafe impl NSCoding for VNCircle {}

unsafe impl NSCopying for VNCircle {}

unsafe impl CopyingHelper for VNCircle {
    type Result = Self;
}

unsafe impl NSObjectProtocol for VNCircle {}

unsafe impl NSSecureCoding for VNCircle {}

impl VNCircle {
    extern_methods!(
        /// Returns a VNCircle object with center at the Origin [0.0; 0.0] and zero radius.
        #[unsafe(method(zeroCircle))]
        #[unsafe(method_family = none)]
        pub unsafe fn zeroCircle() -> Retained<VNCircle>;

        /// Initializes VNCircle object with given circle center and circle radius.
        #[unsafe(method(initWithCenter:radius:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCenter_radius(
            this: Allocated<Self>,
            center: &VNPoint,
            radius: c_double,
        ) -> Retained<Self>;

        /// Initializes VNCircle object with given circle center and circle diameter.
        #[unsafe(method(initWithCenter:diameter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCenter_diameter(
            this: Allocated<Self>,
            center: &VNPoint,
            diameter: c_double,
        ) -> Retained<Self>;

        /// Returns YES if the point is inside the circle, including the boundary.
        #[unsafe(method(containsPoint:))]
        #[unsafe(method_family = none)]
        pub unsafe fn containsPoint(&self, point: &VNPoint) -> bool;

        /// Returns YES if the point is within the ring bound by two circles [radius - delta; radius + delta].
        #[unsafe(method(containsPoint:inCircumferentialRingOfWidth:))]
        #[unsafe(method_family = none)]
        pub unsafe fn containsPoint_inCircumferentialRingOfWidth(
            &self,
            point: &VNPoint,
            ring_width: c_double,
        ) -> bool;

        /// Returns circle center.
        #[unsafe(method(center))]
        #[unsafe(method_family = none)]
        pub unsafe fn center(&self) -> Retained<VNPoint>;

        /// Returns circle radius.
        #[unsafe(method(radius))]
        #[unsafe(method_family = none)]
        pub unsafe fn radius(&self) -> c_double;

        /// Returns circle diameter.
        #[unsafe(method(diameter))]
        #[unsafe(method_family = none)]
        pub unsafe fn diameter(&self) -> c_double;
    );
}

/// Methods declared on superclass `NSObject`.
impl VNCircle {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// The VNContour class describes a contour provided by a VNContoursObservation.
    ///
    ///
    /// VNContour objects are lightweight objects that act as a façade which allows access to a small slice of the usually much larger block of data owned by a VNContoursObservation that represents all of the contours detected in an image.
    /// While the interface does present the notion of a hierarchy of parent/child contours, the implementation purposefully does not contain any explicit internal bookkeeping for this relationship.  Instead, contours are uniquely identified via their indexPath property.
    /// As a side effect of this choice, repeated calls to methods that would return relational contours (e.g., -childContours or -childContourAtIndex:error:) are NOT guaranteed to return the same VNContour instances over and over again.  If this kind of parent/child object stability is an absolute requirement of the client, then they are responsible for creating the necessary data structures to represent and build that instance-stable hierarchy.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/vision/vncontour?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct VNContour;
);

unsafe impl NSCopying for VNContour {}

unsafe impl CopyingHelper for VNContour {
    type Result = Self;
}

unsafe impl NSObjectProtocol for VNContour {}

#[cfg(feature = "VNRequestRevisionProviding")]
unsafe impl VNRequestRevisionProviding for VNContour {}

impl VNContour {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        /// The path to the target VNContour as it is stored in the owning VNContoursObservation's hierarchy of contours.
        #[unsafe(method(indexPath))]
        #[unsafe(method_family = none)]
        pub unsafe fn indexPath(&self) -> Retained<NSIndexPath>;

        /// The total number of child contours in the target contour.
        ///
        /// The use of this property is preferred over childContours.count due to the cost of building the child objects.
        #[unsafe(method(childContourCount))]
        #[unsafe(method_family = none)]
        pub unsafe fn childContourCount(&self) -> NSInteger;

        /// The array of the contours enclosed by the target contour.
        ///
        /// This property may come with the cost of instantiating new VNContour objects; therefore, clients are strongly encouraged to hold the results in a local variable instead of repeatedly invoking it.
        #[unsafe(method(childContours))]
        #[unsafe(method_family = none)]
        pub unsafe fn childContours(&self) -> Retained<NSArray<VNContour>>;

        /// Returns a VNContour object that is a child of this VNContour at the specified index.
        ///
        /// Parameter `childContourIndex`: The index into the childContours array.
        ///
        /// Parameter `error`: The error returned if the child contour cannot be provided.
        ///
        /// Returns: The VNContour object at the specified index path, or nil of a failure occurs.
        #[unsafe(method(childContourAtIndex:error:_))]
        #[unsafe(method_family = none)]
        pub unsafe fn childContourAtIndex_error(
            &self,
            child_contour_index: NSUInteger,
        ) -> Result<Retained<VNContour>, Retained<NSError>>;

        /// The number of points that describe the contour.
        #[unsafe(method(pointCount))]
        #[unsafe(method_family = none)]
        pub unsafe fn pointCount(&self) -> NSInteger;

        #[cfg(feature = "objc2-core-graphics")]
        /// The contour represented as a CGPath in normalized coordinates.
        ///
        /// The path is owned by this object and therefore will be alive as long as the the observation is alive.
        #[unsafe(method(normalizedPath))]
        #[unsafe(method_family = none)]
        pub unsafe fn normalizedPath(&self) -> Retained<CGPath>;

        /// The aspect ratio of the contour from the original image aspect ratio expressed as width/height
        #[unsafe(method(aspectRatio))]
        #[unsafe(method_family = none)]
        pub unsafe fn aspectRatio(&self) -> c_float;

        /// Simplifies the contour's collection of points into a polygon using the Ramer Douglas Peucker Algorithm.
        ///
        /// See
        /// <https
        /// ://en.wikipedia.org/wiki/Ramer–Douglas–Peucker_algorithm>
        ///
        /// Parameter `epsilon`: Points that have a perpendicular distance to the line segment they are on which are greater than epsilon are kept, others are eliminated.
        ///
        /// Parameter `error`: The error returned if a simplified contour cannot be created.
        ///
        /// Returns: A new VNContour object with a simplified polygon consisting of a subset of the points that defined the original VNContour.
        #[unsafe(method(polygonApproximationWithEpsilon:error:_))]
        #[unsafe(method_family = none)]
        pub unsafe fn polygonApproximationWithEpsilon_error(
            &self,
            epsilon: c_float,
        ) -> Result<Retained<VNContour>, Retained<NSError>>;
    );
}