Intelligent Tracking Tutorial

1. Overview

Intelligent tracking for fixed-wing drones refers to the use of integrated drone vision technology, deep learning technology, sensor technology, and real-time control technology to achieve automatic detection, recognition, and continuous tracking of dynamic or static targets.

2. Intelligent Tracking

2.1 Enable Intelligent Tracking

Get the lens required for tracking

//Specify drone device
val droneDevice = DeviceManager.getDeviceManager().getFirstDroneDevice() ?: return

//Use wide-angle lens for recognition and tracking
val specLensId = droneDevice.getCameraAbilitySetManger().getLenId(LensTypeEnum.WideAngle, droneDevice.getGimbalDeviceType())

Configure tracking parameters

val bean = ExtendAIDetectConfigBean().apply {
    //Current scene type: Recommended to use universal scene: SCENE_TYPE_UNIVERSAL
    sceneType = AiDetectSceneTypeEnum.SCENE_TYPE_UNIVERSAL,
    
    //Specify AI recognition content: Refer to DetectTargetEnum values, default is null, will recognize based on specified scene
    targetTypeList = null,
    
    //Specify lens: Different lenses have different capabilities
    lensId= specLensId,
    
    //Specify enabled AI function: Refer to FuncEnum
    dfAIFunc = FuncEnum.AI_DETECT
}

enum class FuncEnum(val value: Int) { // AI function enumeration
    // AI recognition
    AI_DETECT(40),

    //Object tracking
    OBJECT_TRACKING(41),

    //AI recognition + object tracking
    AI_DETECT_OBJECT_TRACKING(42),
}

Enable tracking command

val keyManager = deviceDrone?.getKeyManager()
val createKey = KeyTools.createKey(AITrackingKey.KeyExtendIntelligentLockEnter)

keyManager?.performAction(createKey, bean, object : CommonCallbacks.CompletionCallbackWithParam<Void> {
    override fun onSuccess(t: Void?) {
        Log.d(TAG, "[KeyExtendIntelligentLockEnter][onSuccess]")
    }

    override fun onFailure(error: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyExtendIntelligentLockEnter][onFailure][error]$error")
    }
})

2.2 Get Recognition Results

Listen for recognition result reports

val droneDevice = DeviceManager.getDeviceManager().getFirstDroneDevice() ?: return
val key = KeyTools.createKey(AIServiceKey.KeyAiDetectTarget)
val keyManager = droneDevice.getKeyManager()

//Create AI recognition listener
private val trackListener = object : CommonCallbacks.KeyListener<DetectTrackNotifyBean> {
    override fun onValueChange(oldValue: DetectTrackNotifyBean?, newValue: DetectTrackNotifyBean) {
         newValue.infoList.forEach {
            val type = DetectTargetEnum.getEnglishName(DetectTargetEnum.findEnum(it.type))
            Log.i(TAG, "Type:$type, $it")
         }
    }
 }

//Start listening for recognition reports
keyManager.listen(key, trackListener)

Recognition result parsing:
Refer to DetectTrackNotifyBean, DetectTargetEnum

data class DetectTrackNotifyBean(
    //Timestamp
    var timestamp: Long = 0,

    //frameId
    var frameId: Int = 0,
 
    //Resolution width
    var resolutionWidth: Int = 0,
   
    //Resolution height
    var resolutionHeight: Int = 0,
 
    //Count
    var objNum: Int = 0,
   
    //Target frame array
    var infoList: List<DetectObjectBean> = emptyList(),
    
    //Image unique ID (unique for current boot), set to 0 if no image is saved this time
    var imageId: Int = 0,
    
    //Image path, set to empty string if no image is saved this time
    var imageUrl: String = "",

    //Lens id
    var lensId: Int = 0,
)

Target frame array information:
Based on the resolution and target position information in the results, you can determine the position of the recognized target in the video frame

data class DetectObjectBean(
    //Target pixel coordinate x
    var startX: Float = 0f,
    
    //Target pixel coordinate y
    var startY: Float = 0f,
    
    //Target frame width
    var width: Float = 0f,
    
    //Target frame height
    var height: Float = 0f,
   
    //Target type
    var type: Int = 0,
    
    //Target tracking type
    var status: Int = 0,
    
    //Target ID
    var objectId: Int = 0,
)

2.3 Target Locking

Users can lock tracking targets based on recognition results, or select targets within a certain range for tracking

val droneDevice = DeviceManager.getDeviceManager().getFirstDroneDevice() ?: return
val key = KeyTools.createKey(AITrackingKey.KeyIntelligentLockStart)
val keyManager = droneDevice.getKeyManager()

//Lock parameter settings
val obj = result.infoList.firstOrNull() ?: return
val bean = TrackTargetRectBean(
    obj.startX, obj.startY, obj.startX + obj.width, 
    obj.startY + obj.height, result.lensId, 
    AiDetectSceneTypeEnum.SCENE_TYPE_UNIVERSAL, obj.objectId
)

//Start locking target
keyManager.performAction(key, bean, object : CommonCallbacks.CompletionCallbackWithParam<Void> {
    override fun onSuccess(t: Void?) {
        Log.d(TAG, "[KeyIntelligentLockStart][onSuccess]")
    }

    override fun onFailure(error: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyIntelligentLockStart][onFailure][error]$error")
    }
})

Lock parameter description

data class TrackTargetRectBean(
    //Starting point x coordinate
    val startX: Float = 0F,
    
    //Starting point y coordinate
    val startY: Float = 0F,
    
    //Width
    val width: Float = 0F,
    
    //Height
    val height: Float = 0F,

    //Current lens id
    var lensId: Int? = null,

    //Usage scene, default: SCENE_TYPE_UNIVERSAL
    var sceneType: AiDetectSceneTypeEnum,

    //Target ID
    var objectId: Int? = 0
)

2.4 Unlock Target

To unlock a target, simply set the width and height of the tracking frame to zero

val droneDevice = DeviceManager.getDeviceManager().getFirstDroneDevice() ?: return
val key = KeyTools.createKey(AITrackingKey.KeyIntelligentLockStart)
val keyManager = droneDevice.getKeyManager()

val bean = TrackTargetRectBean(0.5f, 0.5f, 0f, 0f, 0)

keyManager.performAction(key, bean, object : CommonCallbacks.CompletionCallbackWithParam<Void> {
    override fun onSuccess(t: Void?) {
        Log.d(TAG, "[KeyIntelligentLockStart][onSuccess]")
    }

    override fun onFailure(error: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyIntelligentLockStart][onFailure][error]$error")
    }
})

2.5 Stop Tracking

val droneDevice = DeviceManager.getDeviceManager().getFirstDroneDevice()?: return
val key = KeyTools.createKey(AITrackingKey.KeyExtendIntelligentLockExit)
val keyManager = droneDevice.getKeyManager()

val bean = ExtendAIExitBean().apply {
    //Specify the AI function to stop
    dfAIFunc = FuncEnum.AI_DETECT
    //Specify lens ID
    lensId = specLensId
}


keyManager.performAction(key, func, object : CommonCallbacks.CompletionCallbackWithParam<Void> {
    override fun onSuccess(t: Void?) {
        Log.d(TAG, "[KeyExtendIntelligentLockExit][onSuccess]")
    }

    override fun onFailure(error: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyExtendIntelligentLockExit][onFailure][error]$error")
    }
})

3. Parameter Settings

3.1 Tracking Mode

Note: Tracking mode can only be set after the aircraft takes off

val key = KeyTools.createKey(DFCommonCmdKey.KeyAircraftTracking)
val bean = DFAircraftTrackingBean(true, DFTrackingTypeEnum.STANDARD)
val keyManager =  DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()
keyManager?.performAction(key, bean, object: CommonCallbacks.CompletionCallbackWithParam<Void> {
    override fun onSuccess(t: Void?) {
        Log.d(TAG, "[KeyAircraftTracking][onSuccess]")
    }

    override fun onFailure(error: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyAircraftTracking][onFailure][error]$error")
    }
})

data class DFAircraftTrackingBean(
    var enable: Boolean = true,  //Whether to enable tracking
    var trackingType: DFTrackingTypeEnum = DFTrackingTypeEnum.STANDARD //Tracking mode
)

Fixed-wing drones support tracking modes including: standard tracking, synchronized tracking, circling tracking, etc. See DFTrackingTypeEnum

3.2 Tracking Angle

val key = KeyTools.createKey(DFFlightPropertyKey.KeyTrackAngle)
val keyManager =  DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()
//Parameter is angle value, range [0, 360]
keyManager?.setValue(key, 90f, object: CommonCallbacks.CompletionCallback {
    override fun onSuccess() {
        Log.d(TAG, "[KeyTrackAngle][onSuccess]")
    }

    override fun onFailure(code: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyTrackAngle][onFailure][error]$error")
    }
})

3.3 Tracking Angle Type

val key = KeyTools.createKey(DFFlightPropertyKey.KeyTrackAngleType)
val keyManager =  DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()
//Angle type: 1 absolute angle; 2 relative angle
keyManager?.setValue(key, 1f, object: CommonCallbacks.CompletionCallback {
    override fun onSuccess() {
        Log.d(TAG, "[KeyTrackAngleType][onSuccess]")
    }

    override fun onFailure(code: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyTrackAngleType][onFailure][error]$error")
    }
})

3.4 Tracking Radius

val key = KeyTools.createKey(DFFlightPropertyKey.KeyTrackRadius)
val keyManager =  DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()
//Tracking radius, unit: meters, range [200, 3000]
keyManager?.setValue(key, 2000f, object: CommonCallbacks.CompletionCallback {
    override fun onSuccess() {
        Log.d(TAG, "[KeyTrackRadius][onSuccess]")
    }

    override fun onFailure(code: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyTrackRadius][onFailure][error]$error")
    }
})

3.5 Tracking Distance

val key = KeyTools.createKey(DFFlightPropertyKey.KeyTrackDistance)
val keyManager =  DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()
//Tracking distance, unit: meters, range [0, 3000]
keyManager?.setValue(key, 2000f, object: CommonCallbacks.CompletionCallback {
    override fun onSuccess() {
        Log.d(TAG, "[KeyTrackDistance][onSuccess]")
    }

    override fun onFailure(code: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyTrackDistance][onFailure][error]$error")
    }
})

3.6 Tracking Circle Direction

val key = KeyTools.createKey(DFFlightPropertyKey.KeyTrackDirection)
val keyManager =  DeviceManager.getDeviceManager().getFirstDroneDevice()?.getKeyManager()
//Tracking circle direction -1: clockwise; 0: automatic; 1: counterclockwise;
keyManager?.setValue(key, 0, object: CommonCallbacks.CompletionCallback {
    override fun onSuccess() {
        Log.d(TAG, "[KeyTrackDirection][onSuccess]")
    }

    override fun onFailure(code: IAutelCode, msg: String?) {
        Log.e(TAG, "[KeyTrackDirection][onFailure][error]$error")
    }
})

4. Reference Code

Please refer to Demo AIRecognizeFragment