먼저 사용되는 기술 배경은 다음과 같다.

• Window10
• VirtualBox 7.x.x
• Ubuntu 18.04(on VirtualBox)
• ROS Melodic
• Android Studio (노트북의 모바일 핫스팟에 네트워크가 연결된 상태다)
• Galaxy S20FE

이전에 rosjava, rosandroid를 사용해서 ROS와의 통신을 구축해보려고했는데 특정 라이브러리가 maven에서 날라간 것으로 보인다. 정확히는 `org.ros.message.MessageListener` 가 안돼서 Subscriber를 동작시킬 수가 없었다. 

 repositories {
    google {
        content {
            includeGroupByRegex("com\\.android.*")
            includeGroupByRegex("com\\.google.*")
            includeGroupByRegex("androidx.*")
        }
    }
    maven { url = uri("https://github.com/rosjava/rosjava_mvn_repo/raw/master") }
    mavenCentral()
    gradlePluginPortal()
}

이렇게 까지 해서 버전 하나하나 바꿔가며 리소스를 받으려했는데 실패했다..

어차피 rosbridge_server로 rosbridge_websocket을 열면 웹소켓 서버가 열리니까, 이걸로 선회했다.

# WebSocketClient 만들기

ROS 작업을 하기 전에 안드로이드 쪽 코드를 먼저 작성한다.

Java Native에 들어있는 WebSocket을 사용해도 됐지만 최적화가 이미 잘 되어있고 stable한 라이브러리인 okhttp3를 사용했다.

[versions]
okhttp = "4.12.0"

[libraries]
okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }

시작 전 인터넷 권한 꼭 manifest에 허용해둬야한다.

private var webSocket: WebSocket? = null
private val client = OkHttpClient.Builder()
    .readTimeout(0, TimeUnit.MILLISECONDS)
    .build()

fun connect() {
    val request = Request.Builder().url(url).build()
    webSocket = client.newWebSocket(request, createWebSocketListener())
}

웹소켓 객체를 먼저 만든다. 웹소켓 서버 url을 받아서 request 인스턴스를 만들고, websocket listener와 함께 client로 생성하면 된다. 읽기 타임아웃은 0으로 설정했다. WebSocket 특성상 열어두고 계속 쓸건데 타임아웃이 있다면 응답이 오기전에 끊어질 것이다.

var onMessageReceived: ((String, String) -> Unit)? = null
var onConnectionOpened: (() -> Unit)? = null
var onConnectionClosed: ((code: Int, reason: String) -> Unit)? = null
var onConnectionFailed: ((Throwable) -> Unit)? = null

private fun createWebSocketListener() = object : WebSocketListener() {
    override fun onOpen(webSocket: WebSocket, response: Response) {
        onConnectionOpened?.invoke()
    }

    override fun onMessage(webSocket: WebSocket, text: String) {
        val json = JSONObject(text)
        val topic = json.optString("topic name")
        val message = json.optJSONObject("msg")?.toString() ?: ""
        onMessageReceived?.invoke(topic, message)
    }

    override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
        webSocket.close(CODE_EXIT, null)
    }

    override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
        onConnectionClosed?.invoke(code, reason)
    }

    override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
        onConnectionFailed?.invoke(t)
    }
}

JSON오브젝트로 감싸놨다. ros에서 오는 응답 형태가 아래처럼 json형태로 내려온다. onMessage는 로그 title이고 `{  }` 로 감싸진게 message다.

onMessage: {
    "topic": "/chatter", 
    "msg": {"data": "hello SSAFY 1724739832.18"},
    "op": "publish"
}

응답 처리할 람다함수를 각자 지정해놨다. 역할이 하나라서 invoke로 실행해도 아무 문제 없다. 구독한 토픽에서 메시지가 들어오면 onMessage메서드에 text가 들어온다.

양방향 통신이기 때문에 토픽을 구독하고, 발행하는 코드도 당연히 존재한다. 발행시 주의할 점은 JSONObject를 rosbridge_server가 받고있기 때문에 json으로 감싸줘야 제대로 값이 들어간다. 정확히는 JSON String이다.

fun subscribe(topic: String) {
    val subscribeMsg = JSONObject().apply {
        put("op", "subscribe")
        put("topic", topic)
    }
    webSocket?.send(subscribeMsg.toString())
}

fun publish(topic: String, message: String) {
    val publishMsg = JSONObject().apply {
        put("op", "publish")
        put("topic", topic)
        put("msg", JSONObject(message))
    }
    webSocket?.send(publishMsg.toString())
}

이런 형태의 메시지를 바로 소켓통신으로 전송했다고 보면된다.

# MainActivity

rosClient = ROSWebSocketClient("ws://$CONNTECT_IP:9090")

먼저 웹소켓 서버url을 넣어서 인스턴스를 만든다. CONNETECT_IP의 중요성이 크다...

client에서 람다함수를 구체화 하기전, 우리는 메시지를 쏘고, 받는다는 점에서 익숙한 개념을 하나 떠올릴 수 있다. Flow의 emit, collect가 딱 맞는다.

단위 기능 테스트 중이라서 따로 ViewModel까지 작성하지는 않았다.

private lateinit var rosClient: ROSWebSocketClient
private val messageFlow = MutableStateFlow("") // StateFlow니까 초기화 값 필요

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    enableEdgeToEdge()
    setContentView(R.layout.activity_main)
    ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
        val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
        v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
        insets
    }

    rosClient = ROSWebSocketClient("ws://$CONNTECT_IP:9090")

    lifecycleScope.launch {
        messageFlow.collect { message ->
            tvMessages.append(message)
        }
    }
}

최신 state만 유지하기 보다는 일단 들어오는 값들을 모두 보고싶어서 collect로 했다.

rosClient 람다 설정해주는 함수는 아래와 같다. 

private fun initROSClient() {
    rosClient.apply {
        lifecycleScope.launch(Dispatchers.IO) {
            // 네트워크 작업이라 IO에서 동작
            connect()
        }

        onConnectionOpened = {
            lifecycleScope.launch {
                messageFlow.emit("ROS 연결성공")
                subscribe("/chatter")
            }
        }

        onMessageReceived = { topic, message ->
            lifecycleScope.launch {
                messageFlow.emit("토픽: $topic, 메시지: $message\n")
            }
        }

        onConnectionClosed = { code, reason ->
            lifecycleScope.launch {
                messageFlow.emit("연결 종료: $code, $reason\n")
            }
        }

        onConnectionFailed = { error ->
            lifecycleScope.launch {
                messageFlow.emit("연결 실패: ${error.message}\n")
            }
        }
    }
}

웹소켓에 connect되고 나서 바로 chatter 토픽을 구독한다. talker-listener 예시를 사용하기 위해서 이렇게 했다.

하나 더 추가해줘야할 게 액티비티가 onDestroy 될 경우를 대비한 websocket 통신 끊기다.

override fun onDestroy() {
    super.onDestroy()
    rosClient.disconnect()
}


// 클라이언트 코드에서는 아래와 같이 작성됨
fun disconnect() {
    webSocket?.close(CODE_EXIT, "disconnect")
}

이러면 안드로이드에서 작성해야되는 건 끝났다. 문제는 이제 어떻게 가상머신 위의 ROS에서 보내는 토픽을 구독해서 android 까지 가져오는 걸 어떻게 하는 지가 남는다. 이게 제일 중요하다. 

# 통신 설정하기

버추얼 박스에 일단 ROS 통신용으로 사용할 호스트 전용 어탭터를 열었다.

우분투로 들어가 ifconfig으로 이 어댑터의 ip를 확인해서 적어둔다. rosbridge_server를 열게되면 이 아이피 밑에서 포트번호 9090으로 열린다.

그럼 아까 CONNECT_IP에 저 노랗게 가려둔 IP를 적으면 될까? 안된다.

지금 안드로이드 - 윈도우10 - ROS on 우분투 이렇게 연결되어있는데, 저렇게 들어가면 접속할 수가 없다. 이제 윈도우에서 설정을 해줘야된다.

방화벽을 열어서 인바운드 규칙으로 포트 등록을 해준다. 이렇게 안하면 보안때문에 포트에 접근하지 못하는 경우가 생길 수 도 있다.

이제 ipconfig을 cmd에 써서 띄워보자.

이게 내 노트북의 IP다. 안드로이드의 데이터가 노트북으로 들어와서 ROS쪽으로 넘어갈 것이기 때문에 우리는 이 윈도우를 중계기로 써서, 웹소켓을 연결할 것이다.

그래서 포트 포워딩이 필요하다. 윈도우와 안드로이드가 통신하는데 안드로이드에서 바로 직결하면 다른 포트를 바라보고있다. 다시 윈도우 cmd를 열어서 아래 명령어를 입력하면 포트포워딩이 끝난다. IP 주소들은 모두 IPv4다.

netsh interface portproxy add v4tov4 listenport=9090 listenaddress={내 노트북 핫스팟 IP} connectpost=9090 connectaddress={ROS IP}

이건 등록하는 것이고 아래 두 개는 제거, 조회다.

• netsh interface portproxy delete v4tov4 listenport=9090 listenaddress={내 노트북 핫스팟 IP}
• netsh interface portproxy show v4tov4

이걸 하고 나면 윈도우를 거치는 게 아니라

flowchart LR
    A[안드로이드] <-->B{윈도우}
    B <--> C[ROS Ubuntu]
    A[안드로이드] <-->|포트포워딩| C[ROS Ubuntu]

안드로이드 - 윈도우 - ROS 과정에서 벗어나 안드로이드 - ROS가 바로 직결된다.

ROS에서 talker 예제를 켜두고, android에서 chatter를 구독해서 나온 결과다.

도움이 됐다면 댓글이나 공감 버튼 한 번씩 누르고 가주세요!

https://school.programmers.co.kr/learn/challenges?tab=algorithm_practice_kit

푸는 동안 사고과정 및 개선점

import java.util.*;

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        ArrayList<Integer> arr = new ArrayList();
        HashMap<String, PriorityQueue<Song>> s = new HashMap();
        HashMap<String, Integer> g = new HashMap();
        for(int i = 0; i < genres.length; i++){
            g.put(genres[i], g.getOrDefault(genres[i], 0)+plays[i]); // 얘는 장르별 총 재생 수 넣게
            s.putIfAbsent(genres[i], new PriorityQueue<Song>((o1,o2)->{
                if(o2.plays == o1.plays){
                    // 재생수가 같으면 id가 낮은걸로 정렬
                    return o1.id - o2.id;
                }
                return o2.plays-o1.plays;
            }));
            s.get(genres[i]).add(new Song(i, plays[i]));
        } // 입력을 받았다. 각 장르 별로 plays 순 내림정렬, plays가 같으면 id 오름정렬.
        // 각 장르 별로 2개씩 뽑으면 되는데, 1개만 있다면 그거만 선택한다
        // 많이 재생된 장르를 먼저 수록한다 -> 이게 좀 애매
        
        // 키-값 쌍을 List로 변환
        List<Map.Entry<String, Integer>> list = new ArrayList(g.entrySet());
        // value를 기준으로 내림차순 정렬
        Collections.sort(list, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));
        
        for(Map.Entry<String, Integer> entry: list){
            // 재생 수로 정렬된 키를 갖다가
            String genre = entry.getKey();
            int cnt = 0;
            while(cnt < 2){
                if(!s.get(genre).isEmpty()){
                    // 리스트가 남아있으면
                    arr.add(s.get(genre).poll().id);
                    cnt++;
                }else{
                    // 리스트가 비어있는 경우
                    break;
                }
            }
        }
        int[] answer = new int[arr.size()];
        int idx = 0;
        for(int id: arr){
            answer[idx++] = id;
        }
        
        return answer;
    }
}

class Song{
    int id; 
    int plays;
    Song(int id, int plays){
        this.id = id;
        this.plays = plays;
    }
}

IDE안쓰고 그냥 바로 풀었다. Map 조작에 조금 익숙해진 것 같다.

조건이 좀 많아서 까다로웠던 문제다. 

1. 총 재생 수가 많은 장르 순서대로
2. 장르 내에서 재생 수가 많은 순서대로
3. 재생 수가 같다면 id가 작은 순서대로 
4. 2개까지 뽑아서 id를 기록해라

작게 부분을 나눠서 작성하니까 조금 더 편했던 것 같다.

HashMap의 value로 Collection을 사용해보니까 활용할 수 있는 방향이 많을 것 같다고 생각했다. 

# 추가 공부

이번 문제 풀면서 검색헀던 건 HashMap에서 key 기준으로 정렬하는 방법이었다.

List<Map.Entry<String, Integer>> list = new ArrayList(g.entrySet());
Collections.sort(list, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));

entrySet을 ArrayList에 넣을 수 있다는 걸 처음알았다.

entryset타입은 Map.Entry형태니까 주의해야되고, compareTo로 내림차순 정렬이 된 list를 만들었다

Collections.sort(list, (o1, o2) -> o1.getValue().compareTo(o2.getValue()));

이러면 오름차순이다.

compareTo의 앞에 있는걸 기준으로 compareTo안의 값이 크면 오름차순, 작으면 내림차순으로 정렬된다. Comparator를 람다로 작성한 형태라고 보면 될 것 같다.

도움이 됐다면 댓글이나 공감 버튼 한 번씩 누르고 가주세요!

https://school.programmers.co.kr/learn/challenges?tab=algorithm_practice_kit

푸는 동안 사고과정 및 개선점

import java.util.*;

class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue();
        for(int i: scoville){
            pq.add(i);
        } // 기본이 min heap
        int s = 0;
        while(s<K){
            if(pq.isEmpty()){
                answer = -1;
                break;
            }
            int easy = pq.poll();
            int eeasy = pq.poll();
            s = easy + (2*eeasy);
            answer++;
        }
        
        
        return answer;
    }
}

처음에 문제이해를 완전히 잘못했다. 모든 음식의 스코빌지수가 K이상이 되어야한다.

import java.util.*;

class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue();
        for(int i: scoville){
            pq.add(i);
        } // 기본이 min heap
        while(pq.peek()<K){
            if(pq.isEmpty()){
                answer = -1;
                break;
            }
            if(pq.size()>=2){
                int easy = pq.poll();
                int eeasy = pq.poll();
                pq.add(easy + (2*eeasy)); // 새 음식 만들어서 추가
                answer++;
            }
        }
        
        return answer;
    }
}

이게 수정한 코드다. 시간초과나는 엄청 큰 케이스를 제외하고서 다 통과된다...

조금만 생각해보면 해결되는 부분이었다. K 이상으로 음식을 만들면 되니까 minheap을 뽑았을 때 K이상인 경우 break를 줘버리는 것이다.

import java.util.*;

class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue();
        for(int i: scoville){
            pq.add(i);
        } // 기본이 min heap
        while(pq.peek()<K){
            if(pq.size()>=2){
                int easy = pq.poll();
                int eeasy = pq.poll();
                pq.add(easy + (2*eeasy)); // 새 음식 만들어서 추가
                answer++;
            }else{
                answer = -1;
                break;
            }
            if(pq.peek() >= K) break;
        }
        
        return answer;
    }
}

pq 사이즈로 break 조건도 바꿔서 넣어봤다.

# 추가 공부

`PriorityQueue` 활용하기

기본이 minheap이다 그래서 reverseOrder해버리면 maxheap이 된다.

PriorityQueue<Integer> maxHeap = new PriorityQueue(Collections.reverseOrder());
PriorityQueue<Integer> maxHeap = new PriorityQueue((o1, o2)-> {return o2-o1;});

자료구조를 다른걸 사용할 때는 이렇게도 쓸 수 있다.

PriorityQueue<Student> pq = new PriorityQueue<>((s1, s2) -> {
    if (s1.grade == s2.grade) {
        return s1.name.compareTo(s2.name);
    }
    return s2.grade - s1.grade;
});

그리디한 문제를 풀 때 이렇게 하곤 했다.

도움이 됐다면 댓글이나 공감 버튼 한 번씩 누르고 가주세요!

https://github.com/kimmandoo/android-drill/tree/main/FaceMesh

안드로이드 온디바이스 AI API로 제공되는 라이브러리 중 MLKit이 있다. 그 중 얼굴 Mesh 감지를 이용한 졸음감지를 해보려고 단위 기능 개발을 진행했다.

https://developers.google.com/ml-kit/vision/face-mesh-detection?hl=ko

굉장히 API 가 잘돼있다. 따로 asset 추가할 필요없이 gradle 의존성을 추가하면 번들링될 때 포함되어 빌드된다.

Mesh를 이용하는 이유는 눈 주변의 point들을 감지해서 눈이 감겼는지, 떠있는 지 확인할 수 있는 가장 간편한 방법이라고 생각했기 때문이다.

이렇게 생긴 그물망이 얼굴이 감지되면 부착되고, 각 파트별로 point가 지정되어있고, contour로 유형이 분류 되어있다.

3점을 조합해서 구역을 감지하는 것도 된다. 그래서 예시로 나온 문장을 보면 아래와 같다.

삼각형 정보: 감지된 얼굴의 논리적 삼각형 표면을 나타내는 데 사용됩니다. 각 삼각형에는 3D 포인트 3개가 포함되어 있습니다. 예를 들어 지점 #0, #37, #164는 코와 입술 사이에 작은 삼각형 영역을 구성합니다.

구현을 위해 필요한 라이브러리로는 아래와 같다.

[versions]
faceMeshDetection = "16.0.0-beta3"
cameraCore = "1.3.4"

[libraries]
androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "cameraCore" }
androidx-camera-lifecycle = { module = "androidx.camera:camera-lifecycle", version.ref = "cameraCore" }
androidx-camera-view = { module = "androidx.camera:camera-view", version.ref = "cameraCore" }
androidx-camera-core = { group = "androidx.camera", name = "camera-core", version.ref = "cameraCore" }
face-mesh-detection = { module = "com.google.mlkit:face-mesh-detection", version.ref = "faceMeshDetection" }

사진을 찍는 게 아니라, 카메라를 띄워서 스트리밍같이 사용할 것이다. camera-core가 핵심이다.

카메라를 쓰려면 우선 Manifest를 지정해두고, 권한 받는 과정이 필요하다.

<uses-feature
    android:name="android.hardware.camera"
    android:required="false" />
<uses-permission android:name="android.permission.CAMERA" />

private fun checkPermission() = REQUIRED_PERMISSIONS.all {
    ContextCompat.checkSelfPermission(baseContext, it) == PackageManager.PERMISSION_GRANTED
}

private fun requestPermissions() {
    ActivityCompat.requestPermissions(
        this, REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS
    )
}

override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    if (requestCode == REQUEST_CODE_PERMISSIONS) {
        if (checkPermission()) {
            openCamera()
        } else {
            Toast.makeText(
                this,
                "카메라 권한 필요",
                Toast.LENGTH_SHORT
            ).show()
            finish()
        }
    }
}

companion object {
    private const val REQUEST_CODE_PERMISSIONS = 10
    private val REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.CAMERA)
}

`REQUEST_CODE_PERMISSIONS`는 알아서 넣으면 된다.

`onRequestPermissionsResult`는 권한 요청에 대한 REQUEST_CODE를 검증하기 위한 함수인데 ActivityResult로 만들어서 launcher로 받아도 무난하다. 지금은 액티비티로 구현해서 이렇고 fragment로가면 지금이랑 다른 형태가 된다.

# FaceMeshDectector 사용하기

meshDetector = FaceMeshDetection.getClient(
    FaceMeshDetectorOptions.Builder()
        .setUseCase(FaceMeshDetectorOptions.FACE_MESH)
        .build()
)

먼저 client를 만들어둔다. 이 안에 이미지를 넣어서 mesh를 씌우는 것이다. MLKit 공식문서에 있는 ImageAnalyzer를 사용했다.

그 전에 xml상에서 camera-view의 PreviewView를 사용하고 있기 때문에 카메라를 띄울 화면을 지정해준다. 카메라를 PreviewView에 묶어둔다고 생각하면 된다.

val preview = Preview.Builder()
            .build()
            .also {
                it.setSurfaceProvider(previewView.surfaceProvider)
            }
            
try {
    cameraProvider.unbindAll()
    cameraProvider.bindToLifecycle(
        this,
        CameraSelector.DEFAULT_FRONT_CAMERA,
        preview,
        imageAnalysis
    )
} catch (e: Exception) {
    Log.d(TAG, "error: $e")
}

카메라도 ProcessCameraPrivider로 열기때문에 여기서 연 cameraProvider를 surface로 감싸서 PreviewView에 넣어주는 코드라고 보면된다.

이제 Mesh 탐색 코드를 봐야된다. 카메라에서 가져온 Input을 사용하는데, 프레임 별로 반응하다보니 너무 빨라서 일부러 delay를 0.2s로 걸어놨다.

imageAnalysis = ImageAnalysis.Builder()
    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
    .build()

ImageAnalysis 객체를 만들어서 분석 조건을 지정한다. 가장 최근 프레임만 유지하고 나머지는 버리는 전략을 채택했다. 코루틴 Flow의 collectLatest와 동일한 개념이라 보면된다. 

imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(this)) { imageProxy ->
    val mediaImage = imageProxy.image
    if (mediaImage != null) {
        val image =
            InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
        meshDetector.process(image)
            .addOnSuccessListener { faceMeshes ->
                lifecycleScope.launch {
                    delay(200)
                    for (faceMesh in faceMeshes) {
                        val leftEye = faceMesh.getPoints(FaceMesh.LEFT_EYE)
                        val rightEye = faceMesh.getPoints(FaceMesh.RIGHT_EYE)
                        Log.d(TAG, "face: $leftEye || $rightEye")

                        val leftEyeOpen = isEyeOpen(leftEye)
                        val rightEyeOpen = isEyeOpen(rightEye)

                        Log.d(TAG, "Left eye open: $leftEyeOpen, Right eye open: $rightEyeOpen")

                        // 양쪽 눈의 상태에 따라 전체적인 눈 감김 여부 판단
                        val bothEyesOpen = leftEyeOpen && rightEyeOpen
                        Log.d(TAG, "Both eyes open: $bothEyesOpen")

                    }
                }
            }
            .addOnFailureListener { e ->
                Log.d(TAG, "error: $e")
            }
            .addOnCompleteListener {
                imageProxy.close()
            }
    }
}

이제 눈의 가로, 세로 양끝 점을 기준으로 얼마나 감겼는지 판단하는 함수만 작성하면 끝난다.

private fun isEyeOpen(eyePoints: List<FaceMeshPoint>): Boolean {
    // 눈의 세로 양 끝
    val topPoint = eyePoints.minByOrNull { it.position.y }
    val bottomPoint = eyePoints.maxByOrNull { it.position.y }

    // 눈의 가로 양 끝
    val leftPoint = eyePoints.minByOrNull { it.position.x }
    val rightPoint = eyePoints.maxByOrNull { it.position.x }

    if (topPoint != null && bottomPoint != null && leftPoint != null && rightPoint != null) {
        val eyeHeight = bottomPoint.position.y - topPoint.position.y
        val eyeWidth = rightPoint.position.x - leftPoint.position.x
        val aspectRatio = eyeHeight / eyeWidth

        // 종횡비가 임계값보다 크면 눈이 떠져있음.
        val isOpen = aspectRatio > EYE_ASPECT_RATIO_THRESHOLD
        return isOpen
    }

    return false
}

EYE_ASPECT_RATIO_THRESHOLD는 필요한 경우 바꿔서 사용하면 된다. 나는 0.2f로 했다.

도움이 됐다면 댓글이나 공감 버튼 한 번씩 누르고 가주세요!