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++: 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++: std::shared_ptr<Image> image()
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++: 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++: std::shared_ptr<CameraParameters> cameraParameters()
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++: 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++: 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++: 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, is right and up in the camera image, which can be different from these in the natural orientation of the device.) The data arrangement is row-major, not like OpenGL’s column-major.

C: easyar_Matrix44F easyar_InputFrame_cameraTransform(const easyar_InputFrame * This)
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()

cameraTransformType¶

Camera transform type.

C: easyar_CameraTransformType easyar_InputFrame_cameraTransformType(const easyar_InputFrame * This)
C++: CameraTransformType cameraTransformType()
Java: public int cameraTransformType()
Kotlin: fun cameraTransformType(): Int
Objective-C: - (easyar_CameraTransformType)cameraTransformType
Swift: public func cameraTransformType() -> CameraTransformType
C#: public virtual CameraTransformType cameraTransformType()

trackingStatus¶

Gets device motion tracking status: MotionTrackingStatus .

C: easyar_MotionTrackingStatus easyar_InputFrame_trackingStatus(const easyar_InputFrame * This)
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()

motion¶

Motion input data.

C: void easyar_InputFrame_motion(const easyar_InputFrame * This, easyar_OptionalOfMotionInputData * Return)
C++: std::optional<std::shared_ptr<MotionInputData>> motion()
Java: public @Nullable MotionInputData motion()
Kotlin: fun motion(): MotionInputData?
Objective-C: - (easyar_MotionInputData *)motion
Swift: public func motion() -> MotionInputData?
C#: public virtual Optional<MotionInputData> motion()

tryCreate¶

Creates an instance.

C: void easyar_InputFrame_tryCreate(easyar_Image * image, easyar_CameraParameters * cameraParameters, double timestamp, easyar_Matrix44F cameraTransform, easyar_CameraTransformType cameraTransformType, easyar_MotionTrackingStatus trackingStatus, easyar_OptionalOfInputFrame * Return)
C++: static std::optional<std::shared_ptr<InputFrame>> tryCreate(std::shared_ptr<Image> image, std::shared_ptr<CameraParameters> cameraParameters, double timestamp, Matrix44F cameraTransform, CameraTransformType cameraTransformType, MotionTrackingStatus trackingStatus)
Java: public static @Nullable InputFrame tryCreate(@Nonnull Image image, @Nonnull CameraParameters cameraParameters, double timestamp, @Nonnull Matrix44F cameraTransform, int cameraTransformType, int trackingStatus)
Kotlin: companion object fun tryCreate(image: Image, cameraParameters: CameraParameters, timestamp: Double, cameraTransform: Matrix44F, cameraTransformType: Int, trackingStatus: Int): InputFrame?
Objective-C: + (easyar_InputFrame *)tryCreate:(easyar_Image *)image cameraParameters:(easyar_CameraParameters *)cameraParameters timestamp:(double)timestamp cameraTransform:(easyar_Matrix44F *)cameraTransform cameraTransformType:(easyar_CameraTransformType)cameraTransformType trackingStatus:(easyar_MotionTrackingStatus)trackingStatus
Swift: public static func tryCreate(_ image: Image, _ cameraParameters: CameraParameters, _ timestamp: Double, _ cameraTransform: Matrix44F, _ cameraTransformType: CameraTransformType, _ trackingStatus: MotionTrackingStatus) -> InputFrame?
C#: public static Optional<InputFrame> tryCreate(Image image, CameraParameters cameraParameters, double timestamp, Matrix44F cameraTransform, CameraTransformType cameraTransformType, 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++: static std::shared_ptr<InputFrame> createWithImageAndCameraParametersAndTemporal(std::shared_ptr<Image> image, std::shared_ptr<CameraParameters> cameraParameters, double timestamp)
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. Nothing but CloudRecognizer can work with input created by this method.

C: void easyar_InputFrame_createWithImageAndCameraParameters(easyar_Image * image, easyar_CameraParameters * cameraParameters, easyar_InputFrame * * Return)
C++: static std::shared_ptr<InputFrame> createWithImageAndCameraParameters(std::shared_ptr<Image> image, std::shared_ptr<CameraParameters> cameraParameters)
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. Nothing but CloudRecognizer can work with input created by this method.

C: void easyar_InputFrame_createWithImage(easyar_Image * image, easyar_InputFrame * * Return)
C++: static std::shared_ptr<InputFrame> createWithImage(std::shared_ptr<Image> image)
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)