Image Tracker

Related documentations
Target Manager
Recommended Conditions for Target Images
Tracker Coordinate System

The Image Tracker recognizes and tracks planar images. It can demonstrate not only 3D objects but also videos, even the transparent one.

Create Instants
Start / Stop Tracker
Use Tracking Information
Set Target Image
Add / Replace Target Image
Train Target Image Instantly
Change Tracking Mode

Create Instants

>ImageTrackerViewController.swift

var cameraDevice:MasCameraDevice = MasCameraDevice()
var trackingManager:MasTrackerManager = MasTrackerManager()

Start / Stop Tracker

To start / stop Tracker after loading the map, refer to the following code.

>ImageTrackerViewController.swift

@objc func resumeAR()
{
    ...
    trackingManager.start(.TRACKER_TYPE_IMAGE)
}

@objc func pauseAR()
{
    trackingManager.stopTracker()
    ...
}

Use Tracking Information

In the folder where SDK is installed, go to ‘data > SDKSample > Original > ImageTarget' folder, and there is sample target image. Print the image.

If you use the sample code, the following content will be augmented for each image.

  • Blocks.jpg: The alpha video is augmented.
  • Lego.jpg: The normal video is augmented.
  • Glacier.jpg: The cube with the texture is augmented.

To apply tracking results to augmented objects, refer to the following code.

You must be used Convert Matrix for Metal.('metalMatrixConverter')

>ImageTrackerViewController.swift

func draw(in view: MTKView) {
        ...
        let trackingState:MasTrackingState = trackingManager.updateTrackingState()
            let result:MasTrackingResult = trackingState.getTrackingResult()
            
            let backgroundImage:MasTrackedImage = trackingState.getImage()
            var backgroundProjectionMatrix:matrix_float4x4 = cameraDevice.getBackgroundPlaneProjectionMatrix()
            let metalMatrixConverter:matrix_float4x4 = getScaleMatrix(1.0, y: -1.0, z: 1.0)
            backgroundProjectionMatrix = backgroundProjectionMatrix * metalMatrixConverter

            let projectionMatrix:matrix_float4x4 = cameraDevice.getProjectionMatrix()
        
            if let cameraQuad = backgroundCameraQuad {
                cameraQuad.setProjectionMatrix(projectionMatrix: backgroundProjectionMatrix)
                cameraQuad.draw(commandEncoder: commandEncoder, image: backgroundImage)
            }
            
            let trackingCount:Int32 = result.getCount()
            
            if trackingCount > 0 {
                for i in stride(from: 0, to: trackingCount, by: 1) {
                    let trackable:MasTrackable = result.getTrackable(i)
                    let poseMatrix:matrix_float4x4 = trackable.getPose() * metalMatrixConverter
                    
                    if trackable.getName() == "Lego" {
                        if videoCaptureController.getState() == MEDIA_STATE.PLAYING {
                            videoCaptureController.play()
                            videoCaptureController.update()
                            
                            videoPanelRenderer.setProjectionMatrix(projectionMatrix: projectionMatrix)
                            videoPanelRenderer.setPoseMatrix(poseMatrix: poseMatrix)
                            videoPanelRenderer.setTranslation(x: 0.0, y: 0.0, z: 0.0)
                            videoPanelRenderer.setScale(x: 0.26, y: 0.15, z: 1.0)
                            videoPanelRenderer.draw(commandEncoder: commandEncoder, videoTextureId: videoCaptureController.getMetalTextureId())
                        }
                    } else if trackable.getName() == "Blocks" {
                        if chromakeyVideoCaptureController.getState() == MEDIA_STATE.PLAYING {
                            chromakeyVideoCaptureController.play()
                            chromakeyVideoCaptureController.update()
                            
                            chromakeyVideoPanelRenderer.setProjectionMatrix(projectionMatrix: projectionMatrix)
                            chromakeyVideoPanelRenderer.setPoseMatrix(poseMatrix: poseMatrix)
                            chromakeyVideoPanelRenderer.setTranslation(x: 0.0, y: 0.0, z: 0.0)
                            chromakeyVideoPanelRenderer.setScale(x: 0.26, y: 0.18, z: 1.0)
                            chromakeyVideoPanelRenderer.draw(commandEncoder: commandEncoder, videoTextureId: chromakeyVideoCaptureController.getMetalTextureId())
                        }
                    } else if trackable.getName() == "Glacier" {
                        textureCube!.setProjectionMatrix(projectionMatrix: projectionMatrix)
                        textureCube!.setPoseMatrix(poseMatrix: poseMatrix)
                        textureCube!.setTranslation(x: 0.0, y: 0.0, z: -0.025)
                        textureCube!.setScale(x: 0.15, y: 0.15, z: 0.05)
                        textureCube!.draw(commandEncoder: commandEncoder)
                    } else {
                        colorCube!.setProjectionMatrix(projectionMatrix: projectionMatrix)
                        colorCube!.setPoseMatrix(poseMatrix: poseMatrix)
                        colorCube!.setTranslation(x: 0.0, y: 0.0, z: -0.075)
                        colorCube!.setScale(x: 0.15, y: 0.15, z: 0.15)
                        colorCube!.draw(commandEncoder: commandEncoder)
                    }
                }
            } else {
                videoCaptureController.pause()
                chromakeyVideoCaptureController.pause()
            }
        ...
    }

Set Target Image

By calling function addTrackerData to register the map file and calling function loadTrackerData, the target image can be tracked. To set a target image, refer to the following code.

>ImageTrackerViewController.swift

func startEngine()
{
    ...
    let blocksTrackerMapPath:String = Bundle.main.path(forResource: "Blocks", ofType: "2dmap", inDirectory: "data/SDKSample")!
    let glacierTrackerMapPath:String = Bundle.main.path(forResource: "Glacier", ofType: "2dmap", inDirectory: "data/SDKSample")!
    let legoTrackerMapPath:String = Bundle.main.path(forResource: "Lego", ofType: "2dmap", inDirectory: "data/SDKSample")!
        
    trackingManager.start(.TRACKER_TYPE_IMAGE)
    trackingManager.setTrackingOption(.NORMAL_TRACKING)
    trackingManager.addTrackerData(blocksTrackerMapPath)
    trackingManager.addTrackerData(glacierTrackerMapPath)
    trackingManager.addTrackerData(legoTrackerMapPath)
        
    trackingManager.loadTrackerData()
}

Add / Replace Target Image

  1. Create a map file refer to Documentation > Tools > Target Manager.

  2. Download the file you created.

  3. Unzip the downloaded file and copy it to the desired path.

  4. Set a target image.

Train Target Image Instantly

If you want to use a raw image file as an image target without an offline training process via Target Manager, enter a JSON object as the first parameter of addTrackerData().

A sample JSON format is like below.

{
    "image":"add_image",
    "image_path":"ImageTarget/Blocks.png",
    "image_width":0.26,
}

The "image":"add_image" pair should be located at first. The value of "image_path" is an image path and the value of "image_width" is a real width (meter unit) of an image target.
A sample code is like below.

TrackerManager.getInstance().addTrackerData("{\"image\":\"add_image\",\"image_path\":\"ImageTarget/Blocks.png\",\"image_width\":0.26}", true);

When copying to the assets folder, set the second parameter to true to indicate that it is a relative path and a file in the assets folder. If copying to external storage, enter the full path and set the second parameter to false. The instant training permits only jpg and png formats. An image width as a pixel size should be more than 320 and the best is 640.

※ Instant training of an image takes twice as much time as loading a 2dmap.
※ You must call loadTrackerData () after calling addTrackerData ().

Change Tracking Mode

5 Tracking Modes of Image Tracker:

NORMAL_TRACKING, EXTENDED_TRACKING, MULTI_TRACKING, JITTER_REDUCTION_ACTIVATION, JITTER_REDUCTION_DEACTIVATIO

  • NORMAL_TRACKING: Default Setting. Traceable one target image.
trackingManager.setTrackingOption(.NORMAL_TRACKING)
  • EXTENDED_TRACKING: Traceable even at the far distance from the target image.
trackingManager.setTrackingOption(.EXTENDED_TRACKING)
  • MULTI_TRACKING: Possible to recognize and track up to three target images at the same time.
trackingManager.setTrackingOption(.MULTI_TRACKING)
  • JITTER_REDUCTION_ACTIVATION: Jitter reduction.
trackingManager.setTrackingOption(.JITTER_REDUCTION_ACTIVATION)
  • JITTER_REDUCTION_DEACTIVATION: Disable the jitter reduction option.
trackingManager.setTrackingOption(.JITTER_REDUCTION_DEACTIVATION)