InputFrame Class¶

Description¶

Input frame.

It includes image, camera parameters, timestamp, camera transform matrix against world coordinate system, and tracking status,

among which, camera parameters, timestamp, camera transform matrix and tracking status are all optional, but specific algorithms may have special requirements on the input.

index¶

Index, an automatic incremental value, which is different for every input frame.

C: int easyar_InputFrame_index(const easyar_InputFrame * This)¶

C++17: int index()¶

Traditional C++: int index()¶

Java: public int index()¶

Kotlin: fun index(): Int¶

Objective-C: - (int)index¶

Swift: public func index() -> Int32¶

C#: public virtual int index()¶

image¶

Gets image.

C: void easyar_InputFrame_image(const easyar_InputFrame * This, easyar_Image * * Return)¶

C++17: std::shared_ptr<Image> image()¶

Traditional C++: void image(Image * * Return)¶

Java: public @Nonnull Image image()¶

Kotlin: fun image(): Image¶

Objective-C: - (easyar_Image *)image¶

Swift: public func image() -> Image¶

C#: public virtual Image image()¶

hasCameraParameters¶

Checks if there are camera parameters.

C: bool easyar_InputFrame_hasCameraParameters(const easyar_InputFrame * This)¶

C++17: bool hasCameraParameters()¶

Traditional C++: bool hasCameraParameters()¶

Java: public boolean hasCameraParameters()¶

Kotlin: fun hasCameraParameters(): Boolean¶

Objective-C: - (bool)hasCameraParameters¶

Swift: public func hasCameraParameters() -> Bool¶

C#: public virtual bool hasCameraParameters()¶

cameraParameters¶

Gets camera parameters.

C: void easyar_InputFrame_cameraParameters(const easyar_InputFrame * This, easyar_CameraParameters * * Return)¶

C++17: std::shared_ptr<CameraParameters> cameraParameters()¶

Traditional C++: void cameraParameters(CameraParameters * * Return)¶

Java: public @Nonnull CameraParameters cameraParameters()¶

Kotlin: fun cameraParameters(): CameraParameters¶

Objective-C: - (easyar_CameraParameters *)cameraParameters¶

Swift: public func cameraParameters() -> CameraParameters¶

C#: public virtual CameraParameters cameraParameters()¶

hasTemporalInformation¶

Checks if there is temporal information (timestamp).

C: bool easyar_InputFrame_hasTemporalInformation(const easyar_InputFrame * This)¶

C++17: bool hasTemporalInformation()¶

Traditional C++: bool hasTemporalInformation()¶

Java: public boolean hasTemporalInformation()¶

Kotlin: fun hasTemporalInformation(): Boolean¶

Objective-C: - (bool)hasTemporalInformation¶

Swift: public func hasTemporalInformation() -> Bool¶

C#: public virtual bool hasTemporalInformation()¶

timestamp¶

Timestamp. In seconds.

C: double easyar_InputFrame_timestamp(const easyar_InputFrame * This)¶

C++17: double timestamp()¶

Traditional C++: double timestamp()¶

Java: public double timestamp()¶

Kotlin: fun timestamp(): Double¶

Objective-C: - (double)timestamp¶

Swift: public func timestamp() -> Double¶

C#: public virtual double timestamp()¶

hasSpatialInformation¶

Checks if there is spatial information (cameraTransform and trackingStatus).

C: bool easyar_InputFrame_hasSpatialInformation(const easyar_InputFrame * This)¶

C++17: bool hasSpatialInformation()¶

Traditional C++: bool hasSpatialInformation()¶

Java: public boolean hasSpatialInformation()¶

Kotlin: fun hasSpatialInformation(): Boolean¶

Objective-C: - (bool)hasSpatialInformation¶

Swift: public func hasSpatialInformation() -> Bool¶

C#: public virtual bool hasSpatialInformation()¶

cameraTransform¶

Camera transform matrix against world coordinate system. Camera coordinate system and world coordinate system are all right-handed. For the camera coordinate system, the origin is the optical center, x-right, y-up, and z in the direction of light going into camera. (The right and up, on mobile devices, is the right and up when the device is in the natural orientation.) The data arrangement is row-major, not like OpenGL's column-major.

C: easyar_Matrix44F easyar_InputFrame_cameraTransform(const easyar_InputFrame * This)¶

C++17: Matrix44F cameraTransform()¶

Traditional C++: Matrix44F cameraTransform()¶

Java: public @Nonnull Matrix44F cameraTransform()¶

Kotlin: fun cameraTransform(): Matrix44F¶

Objective-C: - (easyar_Matrix44F *)cameraTransform¶

Swift: public func cameraTransform() -> Matrix44F¶

C#: public virtual Matrix44F cameraTransform()¶

trackingStatus¶

Gets device motion tracking status: MotionTrackingStatus .

C: easyar_MotionTrackingStatus easyar_InputFrame_trackingStatus(const easyar_InputFrame * This)¶

C++17: MotionTrackingStatus trackingStatus()¶

Traditional C++: MotionTrackingStatus trackingStatus()¶

Java: public int trackingStatus()¶

Kotlin: fun trackingStatus(): Int¶

Objective-C: - (easyar_MotionTrackingStatus)trackingStatus¶

Swift: public func trackingStatus() -> MotionTrackingStatus¶

C#: public virtual MotionTrackingStatus trackingStatus()¶

create¶

Creates an instance.

C: void easyar_InputFrame_create(easyar_Image * image, easyar_CameraParameters * cameraParameters, double timestamp, easyar_Matrix44F cameraTransform, easyar_MotionTrackingStatus trackingStatus, easyar_InputFrame * * Return)¶

C++17: static std::shared_ptr<InputFrame> create(std::shared_ptr<Image> image, std::shared_ptr<CameraParameters> cameraParameters, double timestamp, Matrix44F cameraTransform, MotionTrackingStatus trackingStatus)¶

Traditional C++: static void create(Image * image, CameraParameters * cameraParameters, double timestamp, Matrix44F cameraTransform, MotionTrackingStatus trackingStatus, InputFrame * * Return)¶

Java: public static @Nonnull InputFrame create(@Nonnull Image image, @Nonnull CameraParameters cameraParameters, double timestamp, @Nonnull Matrix44F cameraTransform, int trackingStatus)¶

Kotlin: companion object fun create(image: Image, cameraParameters: CameraParameters, timestamp: Double, cameraTransform: Matrix44F, trackingStatus: Int): InputFrame¶

Objective-C: + (easyar_InputFrame *)create:(easyar_Image *)image cameraParameters:(easyar_CameraParameters *)cameraParameters timestamp:(double)timestamp cameraTransform:(easyar_Matrix44F *)cameraTransform trackingStatus:(easyar_MotionTrackingStatus)trackingStatus¶

Swift: public static func create(_ image: Image, _ cameraParameters: CameraParameters, _ timestamp: Double, _ cameraTransform: Matrix44F, _ trackingStatus: MotionTrackingStatus) -> InputFrame¶

C#: public static InputFrame create(Image image, CameraParameters cameraParameters, double timestamp, Matrix44F cameraTransform, MotionTrackingStatus trackingStatus)¶

createWithImageAndCameraParametersAndTemporal¶

Creates an instance with image, camera parameters, and timestamp.

C: void easyar_InputFrame_createWithImageAndCameraParametersAndTemporal(easyar_Image * image, easyar_CameraParameters * cameraParameters, double timestamp, easyar_InputFrame * * Return)¶

C++17: static std::shared_ptr<InputFrame> createWithImageAndCameraParametersAndTemporal(std::shared_ptr<Image> image, std::shared_ptr<CameraParameters> cameraParameters, double timestamp)¶

Traditional C++: static void createWithImageAndCameraParametersAndTemporal(Image * image, CameraParameters * cameraParameters, double timestamp, InputFrame * * Return)¶

Java: public static @Nonnull InputFrame createWithImageAndCameraParametersAndTemporal(@Nonnull Image image, @Nonnull CameraParameters cameraParameters, double timestamp)¶

Kotlin: companion object fun createWithImageAndCameraParametersAndTemporal(image: Image, cameraParameters: CameraParameters, timestamp: Double): InputFrame¶

Objective-C: + (easyar_InputFrame *)createWithImageAndCameraParametersAndTemporal:(easyar_Image *)image cameraParameters:(easyar_CameraParameters *)cameraParameters timestamp:(double)timestamp¶

Swift: public static func createWithImageAndCameraParametersAndTemporal(_ image: Image, _ cameraParameters: CameraParameters, _ timestamp: Double) -> InputFrame¶

C#: public static InputFrame createWithImageAndCameraParametersAndTemporal(Image image, CameraParameters cameraParameters, double timestamp)¶

createWithImageAndCameraParameters¶

Creates an instance with image and camera parameters.

C: void easyar_InputFrame_createWithImageAndCameraParameters(easyar_Image * image, easyar_CameraParameters * cameraParameters, easyar_InputFrame * * Return)¶

C++17: static std::shared_ptr<InputFrame> createWithImageAndCameraParameters(std::shared_ptr<Image> image, std::shared_ptr<CameraParameters> cameraParameters)¶

Traditional C++: static void createWithImageAndCameraParameters(Image * image, CameraParameters * cameraParameters, InputFrame * * Return)¶

Java: public static @Nonnull InputFrame createWithImageAndCameraParameters(@Nonnull Image image, @Nonnull CameraParameters cameraParameters)¶

Kotlin: companion object fun createWithImageAndCameraParameters(image: Image, cameraParameters: CameraParameters): InputFrame¶

Objective-C: + (easyar_InputFrame *)createWithImageAndCameraParameters:(easyar_Image *)image cameraParameters:(easyar_CameraParameters *)cameraParameters¶

Swift: public static func createWithImageAndCameraParameters(_ image: Image, _ cameraParameters: CameraParameters) -> InputFrame¶

C#: public static InputFrame createWithImageAndCameraParameters(Image image, CameraParameters cameraParameters)¶

createWithImage¶

Creates an instance with image.

C: void easyar_InputFrame_createWithImage(easyar_Image * image, easyar_InputFrame * * Return)¶

C++17: static std::shared_ptr<InputFrame> createWithImage(std::shared_ptr<Image> image)¶

Traditional C++: static void createWithImage(Image * image, InputFrame * * Return)¶

Java: public static @Nonnull InputFrame createWithImage(@Nonnull Image image)¶

Kotlin: companion object fun createWithImage(image: Image): InputFrame¶

Objective-C: + (easyar_InputFrame *)createWithImage:(easyar_Image *)image¶

Swift: public static func createWithImage(_ image: Image) -> InputFrame¶

C#: public static InputFrame createWithImage(Image image)¶