I am developing a face recognition attendance application. The application successfully displays a face detector box, but the accuracy of the face detection is not satisfactory. The detector often misidentifies faces or fails to detect faces in certain conditions. I am looking for ways to improve the accuracy of the face detection in my application. Here are some specifics:

The face detector sometimes detects non-facial objects as faces.
The face detector box is directed towards the face, but it only detects half of the face.
I am using TensorFlow and ML Kit Face Detector for face detection.

I would appreciate any advice or solutions on how to enhance the accuracy of the face detection feature in my application.

I have tried implementing the following code to improve face detection accuracy:

Here is the XML:

        <!-- PreviewView for camera -->
        <androidx.camera.view.PreviewView
            android:id="@+id/previewView"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />

        <com.example.absensiapp.Drawing.OverlayView
            android:id="@+id/tracking_overlay"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:background="@android:color/transparent" />

Here is the backend code:

class RegistrasiFaceActivity : AppCompatActivity() {

    private lateinit var previewView: PreviewView
    private lateinit var registerButton: Button
    private lateinit var switchCameraButton: Button
    private lateinit var overlayView: OverlayView
    private lateinit var cameraExecutor: ExecutorService
    private var isUsingFrontCamera = true

    private val detector: FaceDetector by lazy {
        val highAccuracyOpts = FaceDetectorOptions.Builder()
            .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
            .build()
        FaceDetection.getClient(highAccuracyOpts)
    }

    private var faceClassifier: FaceClassifier? = null
    private var registerFace = false
    private var isProcessingFrame = false
    private lateinit var tracker: MultiBoxTracker

    companion object {
        private const val PERMISSIONS_REQUEST_CODE = 121
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_registrasi_face)

        previewView = findViewById(R.id.previewView)
        overlayView = findViewById(R.id.tracking_overlay)
        registerButton = findViewById(R.id.registerButton)
        switchCameraButton = findViewById(R.id.switchCameraButton)

        cameraExecutor = Executors.newSingleThreadExecutor()
        tracker = MultiBoxTracker(this)

        // Initialize FACE Recognition
        CoroutineScope(Dispatchers.Main).launch {
            try {
                faceClassifier = TFLiteFaceRecognition.create(
                    assets,
                    "mobile_face_net.tflite",
                    112, // pastikan input size sesuai
                    false,
                    applicationContext
                )
            } catch (e: IOException) {
                e.printStackTrace()
                Toast.makeText(applicationContext, "Classifier could not be initialized", Toast.LENGTH_SHORT).show()
                finish()
            }
        }

        checkAndRequestPermissions()

        registerButton.setOnClickListener {
            registerFace = true
        }

        switchCameraButton.setOnClickListener {
            isUsingFrontCamera = !isUsingFrontCamera
            bindCameraUseCases()
        }
    }

    private fun checkAndRequestPermissions() {
        val permissionsNeeded = mutableListOf<String>()
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            permissionsNeeded.add(Manifest.permission.CAMERA)
        }
        if (permissionsNeeded.isNotEmpty()) {
            ActivityCompat.requestPermissions(this, permissionsNeeded.toTypedArray(), PERMISSIONS_REQUEST_CODE)
        } else {
            bindCameraUseCases()
        }
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == PERMISSIONS_REQUEST_CODE) {
            if (grantResults.isNotEmpty() && grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
                bindCameraUseCases()
            } else {
                Toast.makeText(this, "Permissions denied", Toast.LENGTH_SHORT).show()
            }
        }
    }

    private fun bindCameraUseCases() {
        val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
        cameraProviderFuture.addListener({
            val cameraProvider = cameraProviderFuture.get()

            val preview = Preview.Builder()
                .build()
                .also {
                    it.setSurfaceProvider(previewView.surfaceProvider)
                }

            val cameraSelector = CameraSelector.Builder()
                .requireLensFacing(if (isUsingFrontCamera) CameraSelector.LENS_FACING_FRONT else CameraSelector.LENS_FACING_BACK)
                .build()

            val imageAnalyzer = ImageAnalysis.Builder()
                .setTargetResolution(Size(640, 480))
                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                .build()
                .also {
                    it.setAnalyzer(cameraExecutor, { imageProxy -> processImageProxy(imageProxy) })
                }

            try {
                cameraProvider.unbindAll()
                cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageAnalyzer)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }, ContextCompat.getMainExecutor(this))
    }

    @SuppressLint("UnsafeOptInUsageError")
    private fun processImageProxy(imageProxy: ImageProxy) {
        if (isProcessingFrame) {
            imageProxy.close()
            return
        }
        isProcessingFrame = true

        val rotationDegrees = imageProxy.imageInfo.rotationDegrees
        val image = imageProxy.image ?: run {
            imageProxy.close()
            isProcessingFrame = false
            return
        }

        val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
        val canvas = Canvas(bitmap)
        val paint = android.graphics.Paint().apply {
            color = android.graphics.Color.RED
            style = android.graphics.Paint.Style.STROKE
            strokeWidth = 5.0f
        }
        canvas.drawBitmap(bitmap, 0f, 0f, paint)

        val inputImage = InputImage.fromMediaImage(image, rotationDegrees)
        detector.process(inputImage)
            .addOnSuccessListener { faces ->
                processFaces(faces, bitmap, image.width, image.height)
                imageProxy.close()
                isProcessingFrame = false
            }
            .addOnFailureListener { e ->
                e.printStackTrace()
                imageProxy.close()
                isProcessingFrame = false
            }
    }

    private fun processFaces(faces: List<Face>, bitmap: Bitmap, imageWidth: Int, imageHeight: Int) {
        if (faces.isEmpty()) {
            return
        }

        val face = faces.first()
        val bounds = face.boundingBox

        // Pastikan kotak batas berada dalam dimensi bitmap
        val left = bounds.left.coerceAtLeast(0)
        val top = bounds.top.coerceAtLeast(0)
        val right = bounds.right.coerceAtMost(bitmap.width)
        val bottom = bounds.bottom.coerceAtMost(bitmap.height)

        val width = right - left
        val height = bottom - top

        if (width <= 0 || height <= 0) {
            return
        }

        // Potong wajah dari bitmap asli
        val crop = Bitmap.createBitmap(bitmap, left, top, width, height)

        // Ubah ukuran bitmap sesuai dengan ukuran yang diharapkan oleh model (112x112 dalam kasus ini)
        val scaledBitmap = Bitmap.createScaledBitmap(crop, 112, 112, false)

        // Gunakan bitmap yang telah diubah ukurannya langsung dengan fungsi recognizeImage
        val result = faceClassifier?.recognizeImage(scaledBitmap, registerFace)

        val rectF = RectF(bounds)

        // Calculate scale to transform bounding box to screen coordinates
        val scaleX = overlayView.width / imageWidth.toFloat()
        val scaleY = overlayView.height / imageHeight.toFloat()

        // Apply scale to bounding box
        rectF.left *= scaleX
        rectF.top *= scaleY
        rectF.right *= scaleX
        rectF.bottom *= scaleY

        val recognition = FaceClassifier.Recognition(face.trackingId.toString(), "", 0f, rectF)

        tracker.setFrameConfiguration(imageWidth, imageHeight, 0)

        // Bersihkan callback sebelumnya sebelum menambahkan yang baru
        overlayView.clearCallbacks()

        tracker.trackResults(listOf(recognition), System.currentTimeMillis())
        overlayView.addCallback(object : OverlayView.DrawCallback {
            override fun drawCallback(canvas: Canvas) {
                tracker.draw(canvas)
            }
        })
        overlayView.postInvalidate()

        if (registerFace) {
            showRegisterDialog(scaledBitmap, result!!)
        }
    }

    private fun showRegisterDialog(bitmap: Bitmap, recognition: FaceClassifier.Recognition) {
        val dialog = androidx.appcompat.app.AlertDialog.Builder(this)
            .setView(R.layout.dialog_register)
            .create()

        dialog.setOnShowListener {
            val imageView: ImageView = dialog.findViewById(R.id.dialog_image)!!
            val registerButton: Button = dialog.findViewById(R.id.dialog_register_button)!!

            imageView.setImageBitmap(bitmap)
            registerButton.setOnClickListener {
                CoroutineScope(Dispatchers.IO).launch {
                    faceClassifier?.register("Face", recognition)
                    withContext(Dispatchers.Main) {
                        Toast.makeText(this@RegistrasiFaceActivity, "Face Registered Successfully", Toast.LENGTH_SHORT).show()
                        dialog.dismiss()
                    }
                }
            }
        }

        dialog.show()
    }

    override fun onDestroy() {
        super.onDestroy()
        cameraExecutor.shutdown()
        detector.close()
    }
}

This is the TFLiteFaceRecognition code :

class TFLiteFaceRecognition private constructor(context: Context) : FaceClassifier {

    companion object {
        private const val OUTPUT_SIZE = 192
        private const val IMAGE_MEAN = 127.5f
        private const val IMAGE_STD = 127.5f
        private const val WIDTH = 112
        private const val HEIGHT = 112

        @Throws(IOException::class)
        private fun loadModelFile(assets: AssetManager, modelFilename: String): MappedByteBuffer {
            val fileDescriptor = assets.openFd(modelFilename)
            val inputStream = FileInputStream(fileDescriptor.fileDescriptor)
            val fileChannel = inputStream.channel
            val startOffset = fileDescriptor.startOffset
            val declaredLength = fileDescriptor.declaredLength
            return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength)
        }

        @Throws(IOException::class)
        suspend fun create(
            assetManager: AssetManager,
            modelFilename: String,
            inputSize: Int,
            isQuantized: Boolean,
            context: Context
        ): FaceClassifier {
            return TFLiteFaceRecognition(context).apply {
                this.inputSize = inputSize

                try {
                    tfLite = Interpreter(loadModelFile(assetManager, modelFilename))
                } catch (e: Exception) {
                    throw RuntimeException(e)
                }

                this.isModelQuantized = isQuantized
                val numBytesPerChannel = if (isQuantized) 1 else 4
                imgData = ByteBuffer.allocateDirect(1 * inputSize * inputSize * 3 * numBytesPerChannel)
                imgData.order(ByteOrder.nativeOrder())
                intValues = IntArray(inputSize * inputSize)
            }
        }
    }

    private var isModelQuantized = false
    private var inputSize = 0
    private lateinit var intValues: IntArray
    private lateinit var embeddings: Array<FloatArray>
    private lateinit var imgData: ByteBuffer
    private lateinit var tfLite: Interpreter
    private val registered = HashMap<String, FaceClassifier.Recognition>()

    interface ApiService {
        @POST("api/update-profile")
        suspend fun insertFace(@Body requestBody: FaceRequest)
    }

    data class FaceRequest(val name: String, val embedding: String)

    private val retrofit: Retrofit = Retrofit.Builder()
        .baseUrl(BuildConfig.BASE_URL)
        .addConverterFactory(GsonConverterFactory.create())
        .build()

    private val apiService: ApiService = retrofit.create(ApiService::class.java)

    override fun register(name: String, rec: FaceClassifier.Recognition) {
        CoroutineScope(Dispatchers.IO).launch {
            insertFaceToDatabase(name, rec.embedding as FloatArray)
            registered[name] = rec
        }
    }

    private fun findNearest(emb: FloatArray): Pair<String, Float>? {
        var ret: Pair<String, Float>? = null
        for ((name, value) in registered) {
            val knownEmb = (value.embedding as Array<FloatArray>)[0]
            var distance = 0f
            for (i in emb.indices) {
                val diff = emb[i] - knownEmb[i]
                distance += diff * diff
            }
            distance = kotlin.math.sqrt(distance)
            if (ret == null || distance < ret.second) {
                ret = Pair(name, distance)
            }
        }
        return ret
    }

    private fun imageToArray(bitmap: Bitmap): Array<Array<Array<FloatArray>>> {
        val resizedBitmap = Bitmap.createScaledBitmap(bitmap, WIDTH, HEIGHT, true)
        val intValues = IntArray(WIDTH * HEIGHT)
        resizedBitmap.getPixels(intValues, 0, WIDTH, 0, 0, WIDTH, HEIGHT)
        val floatValues = FloatArray(WIDTH * HEIGHT * 3)
        for (i in intValues.indices) {
            val value = intValues[i]
            floatValues[i * 3 + 0] = ((value shr 16 and 0xFF) - IMAGE_MEAN) / IMAGE_STD
            floatValues[i * 3 + 1] = ((value shr 8 and 0xFF) - IMAGE_MEAN) / IMAGE_STD
            floatValues[i * 3 + 2] = ((value and 0xFF) - IMAGE_MEAN) / IMAGE_STD
        }
        return Array(1) { Array(WIDTH) { Array(HEIGHT) { FloatArray(3) } }.also { array ->
            for (y in 0 until HEIGHT) {
                for (x in 0 until WIDTH) {
                    for (c in 0 until 3) {
                        array[y][x][c] = floatValues[(y * WIDTH + x) * 3 + c]
                    }
                }
            }
        }}
    }

    override fun recognizeImage(bitmap: Bitmap, storeExtra: Boolean): FaceClassifier.Recognition {
        val inputArray = imageToArray(bitmap)
        val outputArray = Array(1) { FloatArray(OUTPUT_SIZE) }

        tfLite.run(inputArray, outputArray)

        var distance = Float.MAX_VALUE
        var id = "0"
        var label = "?"

        if (registered.isNotEmpty()) {
            val nearest = findNearest(outputArray[0])
            if (nearest != null) {
                val name = nearest.first
                label = name
                distance = nearest.second
            }
        }

        val rec = FaceClassifier.Recognition(
            id,
            label,
            distance,
            RectF()
        )

        if (storeExtra) {
            rec.embedding = outputArray
        }

        return rec
    }

    private suspend fun insertFaceToDatabase(name: String, embedding: FloatArray) {
        withContext(Dispatchers.IO) {
            val embeddingString = embedding.joinToString(",")
            val request = FaceRequest(name, embeddingString)
            apiService.insertFace(request)
        }
    }
}

This is the ImageUtils code

/** Utility class for manipulating images. */
object ImageUtils {
    // This value is 2 ^ 18 - 1, and is used to clamp the RGB values before their ranges
    // are normalized to eight bits.
    private const val kMaxChannelValue = 262143

    /**
     * Utility method to compute the allocated size in bytes of a YUV420SP image of the given
     * dimensions.
     */
    fun getYUVByteSize(width: Int, height: Int): Int {
        // The luminance plane requires 1 byte per pixel.
        val ySize = width * height

        // The UV plane works on 2x2 blocks, so dimensions with odd size must be rounded up.
        // Each 2x2 block takes 2 bytes to encode, one each for U and V.
        val uvSize = ((width + 1) / 2) * ((height + 1) / 2) * 2

        return ySize + uvSize
    }

    /**
     * Saves a Bitmap object to disk for analysis.
     *
     * @param bitmap The bitmap to save.
     */
    fun saveBitmap(bitmap: Bitmap) {
        saveBitmap(bitmap, "preview.png")
    }

    /**
     * Saves a Bitmap object to disk for analysis.
     *
     * @param bitmap The bitmap to save.
     * @param filename The location to save the bitmap to.
     */
    fun saveBitmap(bitmap: Bitmap, filename: String) {
        val root = Environment.getExternalStorageDirectory().absolutePath + File.separator + "tensorflow"
        //LOGGER.i("Saving %dx%d bitmap to %s.", bitmap.getWidth(), bitmap.getHeight(), root)
        val myDir = File(root)

        if (!myDir.mkdirs()) {
            //LOGGER.i("Make dir failed")
        }

        val fname = filename
        val file = File(myDir, fname)
        if (file.exists()) {
            file.delete()
        }
        try {
            val out = FileOutputStream(file)
            bitmap.compress(Bitmap.CompressFormat.PNG, 99, out)
            out.flush()
            out.close()
        } catch (e: Exception) {
            //LOGGER.e(e, "Exception!")
        }
    }

    fun convertYUV420SPToARGB8888(input: ByteArray, width: Int, height: Int, output: IntArray) {
        val frameSize = width * height
        for (j in 0 until height) {
            var uvp = frameSize + (j shr 1) * width
            var u = 0
            var v = 0

            for (i in 0 until width) {
                val y = 0xff and input[j * width + i].toInt()
                if (i and 1 == 0) {
                    v = 0xff and input[uvp++].toInt()
                    u = 0xff and input[uvp++].toInt()
                }

                output[j * width + i] = YUV2RGB(y, u, v)
            }
        }
    }

    private fun YUV2RGB(y: Int, u: Int, v: Int): Int {
        var y = y
        var u = u
        var v = v
        y = if (y - 16 < 0) 0 else y - 16
        u -= 128
        v -= 128

        val y1192 = 1192 * y
        var r = y1192 + 1634 * v
        var g = y1192 - 833 * v - 400 * u
        var b = y1192 + 2066 * u

        r = if (r > kMaxChannelValue) kMaxChannelValue else if (r < 0) 0 else r
        g = if (g > kMaxChannelValue) kMaxChannelValue else if (g < 0) 0 else g
        b = if (b > kMaxChannelValue) kMaxChannelValue else if (b < 0) 0 else b

        return -0x1000000 or (r shl 6 and 0xff0000) or (g shr 2 and 0xff00) or (b shr 10 and 0xff)
    }

    fun convertYUV420ToARGB8888(
        yData: ByteArray,
        uData: ByteArray,
        vData: ByteArray,
        width: Int,
        height: Int,
        yRowStride: Int,
        uvRowStride: Int,
        uvPixelStride: Int,
        out: IntArray
    ) {
        var yp = 0
        for (j in 0 until height) {
            val pY = yRowStride * j
            val pUV = uvRowStride * (j shr 1)

            for (i in 0 until width) {
                val uvOffset = pUV + (i shr 1) * uvPixelStride

                out[yp++] = YUV2RGB(
                    0xff and yData[pY + i].toInt(),
                    0xff and uData[uvOffset].toInt(),
                    0xff and vData[uvOffset].toInt()
                )
            }
        }
    }

    fun getTransformationMatrix(
        srcWidth: Int,
        srcHeight: Int,
        dstWidth: Int,
        dstHeight: Int,
        applyRotation: Int,
        maintainAspectRatio: Boolean
    ): Matrix {
        val matrix = Matrix()

        if (applyRotation != 0) {
            if (applyRotation % 90 != 0) {
                //LOGGER.w("Rotation of %d % 90 != 0", applyRotation)
            }

            // Translate so center of image is at origin.
            matrix.postTranslate(-srcWidth / 2.0f, -srcHeight / 2.0f)

            // Rotate around origin.
            matrix.postRotate(applyRotation.toFloat())
        }

        val transpose = (Math.abs(applyRotation) + 90) % 180 == 0

        val inWidth = if (transpose) srcHeight else srcWidth
        val inHeight = if (transpose) srcWidth else srcHeight

        if (inWidth != dstWidth || inHeight != dstHeight) {
            val scaleFactorX = dstWidth / inWidth.toFloat()
            val scaleFactorY = dstHeight / inHeight.toFloat()

            if (maintainAspectRatio) {
                val scaleFactor = Math.max(scaleFactorX, scaleFactorY)
                matrix.postScale(scaleFactor, scaleFactor)
            } else {
                matrix.postScale(scaleFactorX, scaleFactorY)
            }
        }

        if (applyRotation != 0) {
            matrix.postTranslate(dstWidth / 2.0f, dstHeight / 2.0f)
        }

        return matrix
    }
}

This is FaceClassifier code :

interface FaceClassifier {

    fun register(name: String, recognition: Recognition)

    fun recognizeImage(bitmap: Bitmap, getExtra: Boolean): Recognition

    class Recognition(
        val id: String? = null,
        val title: String?,
        val distance: Float? = null,
        var location: RectF? = null,
        var embedding: Any? = null,
        var crop: Bitmap? = null
    ) {

        constructor(title: String?, embedding: Any?) : this(
            id = null,
            title = title,
            distance = null,
            location = null,
            embedding = embedding,
            crop = null
        )

        fun updateEmbedding(extra: Any?) {
            this.embedding = extra
        }

        override fun toString(): String {
            var resultString = ""
            if (id != null) {
                resultString += "[$id] "
            }

            if (title != null) {
                resultString += "$title "
            }

            if (distance != null) {
                resultString += String.format("(%.1f%%) ", distance * 100.0f)
            }

            if (location != null) {
                resultString += "$location "
            }

            return resultString.trim()
        }
    }
}

This is Overlay code :

class OverlayView(context: Context, attrs: AttributeSet) : View(context, attrs) {
    private val callbacks = mutableListOf<DrawCallback>()

    fun addCallback(callback: DrawCallback) {
        callbacks.add(callback)
    }

    fun clearCallbacks() {
        callbacks.clear()
    }

    override fun draw(canvas: Canvas) {
        super.draw(canvas)
        for (callback in callbacks) {
            callback.drawCallback(canvas)
        }
    }

    /** Interface defining the callback for client classes. */
    interface DrawCallback {
        fun drawCallback(canvas: Canvas)
    }
}

This is MultiboxTracker code :

class MultiBoxTracker(context: Context) {
    private val screenRects = mutableListOf<Pair<Float, RectF>>()
    private val availableColors = LinkedList<Int>()
    private val trackedObjects = mutableListOf<TrackedRecognition>()
    private val boxPaint = Paint()
    private var frameToCanvasMatrix: Matrix? = null
    private var frameWidth = 0
    private var frameHeight = 0
    private var sensorOrientation = 0

    init {
        for (color in COLORS) {
            availableColors.add(color)
        }

        boxPaint.color = Color.RED
        boxPaint.style = Paint.Style.STROKE
        boxPaint.strokeWidth = 10.0f
        boxPaint.strokeCap = Paint.Cap.ROUND
        boxPaint.strokeJoin = Paint.Join.ROUND
        boxPaint.strokeMiter = 100f
    }

    @Synchronized
    fun setFrameConfiguration(width: Int, height: Int, sensorOrientation: Int) {
        frameWidth = width
        frameHeight = height
        this.sensorOrientation = sensorOrientation
    }

    @Synchronized
    fun drawDebug(canvas: Canvas) {
        val boxPaint = Paint().apply {
            color = Color.RED
            alpha = 200
            style = Paint.Style.STROKE
        }

        for (detection in screenRects) {
            val rect = detection.second
            canvas.drawRect(rect, boxPaint)
        }
    }

    @Synchronized
    fun trackResults(results: List<FaceClassifier.Recognition>, timestamp: Long) {
        processResults(results)
    }

    private fun getFrameToCanvasMatrix(): Matrix {
        return frameToCanvasMatrix ?: Matrix()
    }

    @Synchronized
    fun draw(canvas: Canvas) {
        val rotated = sensorOrientation % 180 == 90
        val multiplier = minOf(
            canvas.height / (if (rotated) frameWidth else frameHeight).toFloat(),
            canvas.width / (if (rotated) frameHeight else frameWidth).toFloat()
        )
        frameToCanvasMatrix = ImageUtils.getTransformationMatrix(
            frameWidth,
            frameHeight,
            (multiplier * (if (rotated) frameHeight else frameWidth)).toInt(),
            (multiplier * (if (rotated) frameWidth else frameHeight)).toInt(),
            sensorOrientation,
            false
        )

        for (recognition in trackedObjects) {
            val trackedPos = RectF(recognition.location)

            getFrameToCanvasMatrix().mapRect(trackedPos)
            boxPaint.color = recognition.color

            // Gambar kotak deteksi wajah tanpa judul
            canvas.drawRect(trackedPos, boxPaint)
        }
    }

    private fun processResults(results: List<FaceClassifier.Recognition>) {
        val rectsToTrack = LinkedList<Pair<Float, FaceClassifier.Recognition>>()

        screenRects.clear()
        val rgbFrameToScreen = Matrix(getFrameToCanvasMatrix())

        for (result in results) {
            if (result.location == null) {
                continue
            }
            val detectionFrameRect = RectF(result.location)

            val detectionScreenRect = RectF()
            rgbFrameToScreen.mapRect(detectionScreenRect, detectionFrameRect)

            screenRects.add(Pair(result.distance ?: 0f, detectionScreenRect))

            if (detectionFrameRect.width() < MIN_SIZE || detectionFrameRect.height() < MIN_SIZE) {
                continue
            }

            rectsToTrack.add(Pair(result.distance ?: 0f, result))
        }

        trackedObjects.clear()
        if (rectsToTrack.isEmpty()) {
            return
        }

        for (potential in rectsToTrack) {
            val trackedRecognition = TrackedRecognition()
            trackedRecognition.detectionConfidence = potential.first
            trackedRecognition.location = RectF(potential.second.location)
            trackedRecognition.color = COLORS[trackedObjects.size]
            trackedObjects.add(trackedRecognition)

            if (trackedObjects.size >= COLORS.size) {
                break
            }
        }
    }

    private class TrackedRecognition {
        var location: RectF? = null
        var detectionConfidence: Float = 0f
        var color: Int = 0
    }

    companion object {
        private const val MIN_SIZE = 16.0f
        private val COLORS = intArrayOf(
            Color.BLUE,
            Color.RED,
            Color.GREEN,
            Color.YELLOW,
            Color.CYAN,
            Color.MAGENTA,
            Color.WHITE,
            Color.parseColor("#55FF55"),
            Color.parseColor("#FFA500"),
            Color.parseColor("#FF8888"),
            Color.parseColor("#AAAAFF"),
            Color.parseColor("#FFFFAA"),
            Color.parseColor("#55AAAA"),
            Color.parseColor("#AA33AA"),
            Color.parseColor("#0D0068")
        )
    }
}

Despite this, the accuracy has not improved as expected. I also recorded a screen capture of the application to illustrate the issue:

Click to watch my video

This is my project on GitHub

I expected the face detector to accurately detect the full face without misidentifying non-facial objects. However, the detector still only identifies half of the face and sometimes detects non-facial objects as faces.