📹 CCTV AI 영상 분석 앱

온디바이스 AI 기반 실시간 객체 감지 및 추적 시스템

📋 목차

개요
주요 기능
시스템 아키텍처
AI 모델
객체 추적 알고리즘
상품 픽업 감지 로직
서버 통신 프로토콜
기술 스택
디렉토리 구조
주요 클래스 설명

🎯 개요

Store Shield CCTV 앱은 Android 기반 온디바이스 AI 영상 분석 시스템으로, 무인점포 내 고객과 상품의 실시간 추적 및 행동 분석을 수행합니다. Qualcomm AI Hub 최적화 모델을 활용하여 모바일 환경에서도 빠르고 정확한 객체 감지 및 추적이 가능합니다.

핵심 역할

실시간 영상 분석: 카메라로 매장 내부를 촬영하며 AI로 객체 감지
고객 ID 추적: 입장한 고객에게 고유 ID를 부여하고 이동 경로 추적
상품 행동 감지: 고객이 상품을 집거나 내려놓는 행동 자동 인식
서버 데이터 전송: Socket.IO를 통해 실시간 이벤트를 Flask 서버로 전송

✨ 주요 기능

1️⃣ 실시간 객체 감지

YOLO-NAS: 사람, 컵, 바나나, 사과 실시간 감지
Lightweight Face Detection: 고객 얼굴 인식 및 ID 부여

2️⃣ 고객 ID 추적 시스템

등장 판정: 10프레임 연속 감지 시 고객 등장 확정
퇴장 판정: 10프레임 동안 미탐지 시 고객 퇴장 처리
ID 유지: 교차 상황에서도 안정적인 ID 추적

3️⃣ 커스텀 다중 객체 추적 (MOT)

IoU 기반 매칭: 프레임 간 객체 연결
속도 벡터 예측: 이동 방향 및 속도 계산
색상 특징: 상체/하체 RGB 평균값으로 유사 객체 구별
방향 점수: 이동 방향 일치도 계산

4️⃣ 상품 픽업/내려놓기 자동 감지

가상선 기반 감지: y=500 수평선을 기준으로 상품 이동 추적
이벤트 발생 조건:
- 선 아래 → 위: 집기 (act=1)
- 선 위 → 아래: 내려놓기 (act=0)
자동 매칭: 이벤트 발생 시 가장 가까운 고객 자동 연결

5️⃣ 키오스크 연동

고정 영역 설정: 키오스크 위치 좌표 지정
근접 고객 탐지: 키오스크에서 가장 가까운 고객 찾기
결제 프로세스: 서버 요청 시 근접 고객 정보 전송

🏗️ 시스템 아키텍처

┌─────────────────────────────────────────────────────────────┐
│                    CCTV Android App                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────────┐   ┌──────────────┐   ┌──────────────┐     │
│  │   Camera2    │→→→│ YOLO-NAS     │→→→│ SimpleTracker│     │
│  │   API        │   │ (INT8)       │   │ (MOT)        │     │
│  └──────────────┘   └──────────────┘   └──────────────┘     │
│         ↓                  ↓                    ↓           │
│  ┌──────────────┐   ┌──────────────┐   ┌──────────────┐     │
│  │ 100ms 간격   │   │ Face         │   │ 가상선 감지   │     │
│  │ 프레임 캡처  │   │ Detection    │   │ (y=500)       │     │
│  └──────────────┘   └──────────────┘   └──────────────┘     │
│                            ↓                                │
│                   ┌──────────────────┐                      │
│                   │   Socket.IO      │                      │ 
│                   │   Client         │                      │
│                   └──────────────────┘                      │
└─────────────────────────┼───────────────────────────────────┘
                          ↓
                ┌─────────────────────┐
                │   Flask Server      │
                │   (Socket.IO)       │
                └─────────────────────┘

🤖 AI 모델

YOLO-NAS (INT8 양자화)

파일명: yolonas_quantized.tflite
입력 크기: 640 × 640 × 3 (RGB)
출력:
- Bounding Boxes: [1, 8400, 4]
- Confidence Scores: [1, 8400]
- Class Indices: [1, 8400]
감지 객체: 사람, 컵, 바나나, 사과 (COCO 데이터셋 기반)
양자화: INT8 (모델 크기 축소 및 추론 속도 향상)

Lightweight Face Detection

파일명: face_det_lite_quantized.tflite
입력 크기: 640 × 480 (Grayscale)
출력:
- Heatmap: [1, 60, 80, 1]
- Boxes: [1, 60, 80, 4]
- Landmarks: [1, 60, 80, 10]
용도: 고객 얼굴 이미지 추출 및 ID 부여

Qualcomm AI Hub 최적화

출처: Qualcomm AI Hub에서 제공하는 사전 최적화 모델
타겟: Snapdragon 칩셋의 NPU (Neural Processing Unit)
최적화 내용:
- INT8 양자화로 모델 크기 축소
- 모바일 환경에 최적화된 연산 구조
- NNAPI 활용으로 하드웨어 가속

🎯 객체 추적 알고리즘

추적 알고리즘 개요

커스텀 MOT (Multi-Object Tracking)

DeepSORT가 아닌 IoU + 속도 예측 + 색상 특징 기반 경량 추적 알고리즘
모바일 환경에서 실시간 처리 가능하도록 최적화

주요 구성 요소

1️⃣ IoU 기반 매칭

현재 프레임의 탐지 결과 ↔ 이전 프레임의 추적 객체
└─ IoU (Intersection over Union) 계산
   └─ 임계값 0.25 이상이면 같은 객체로 판정

2️⃣ 속도 벡터 예측

// 이동 평균 필터 적용 (가중치 0.7)
velocityX = 0.7 * (현재X - 이전X) + 0.3 * 이전velocityX
velocityY = 0.7 * (현재Y - 이전Y) + 0.3 * 이전velocityY

// 다음 프레임 위치 예측
predictedX = currentX + velocityX
predictedY = currentY + velocityY

빠른 움직임 대응

속도가 큰 객체에 더 높은 방향 점수 부여
교차 상황에서 속도 부스트 (1.5배) 적용

3️⃣ 색상 특징 추출 (사람 전용)

사람 바운딩 박스에서:
├─ 상체 영역: 25%~50% 높이
├─ 하체 영역: 60%~85% 높이
└─ 중앙 추출: 좌우 20% 제외 (배경 노이즈 방지)

각 영역의 RGB 평균값 추출
└─ 색상 유사도 계산 (유클리드 거리 역수)

중앙만 추출하는 이유

정확한 상체/하체 색상 추출
배경이나 다른 객체의 간섭 최소화

4️⃣ 매칭 점수 계산

사람 객체 (일반 상황)

점수 = IoU × 0.4 + 크기유사도 × 0.1 + 색상유사도 × 0.25 + 방향점수 × 0.25

사람 객체 (교차 상황)

점수 = IoU × 0.4 + 크기유사도 × 0.1 + 색상유사도 × 0.25 + 방향점수 × 0.25

+ 속도 부스트 1.5배 적용
+ 방향 정보 가중치 증가

기타 객체 (컵, 바나나, 사과)

점수 = IoU × 0.1 + 크기유사도 × 0.2 + 거리 × 0.4 + 방향점수 × 0.3

가중치 결정: 실험적으로 최적화

5️⃣ 교차 상황 처리

감지 조건

두 사람이 겹침 (거리 < 평균 너비 × 1.2)
AND
서로 반대 방향으로 이동 (속도 내적 < 0)

처리 방법

1. 속도 벡터 1.5배 부스트
2. 방향 정보 가중치 증가
3. ID 스위칭 방지

1.5배 부스트 이유

2D 화면에서 빠른 움직임을 더 정확하게 추적
교차 시 방향 정보의 신뢰도 향상

등장/퇴장 판정

등장 판정 (10프레임 연속 감지)

새로운 ID 감지
└─ 연속 탐지 카운트 +1
   └─ 10프레임 연속 감지
      └─ 등장 확정 → 서버 전송

10프레임 기준 이유: 일시적 오탐지 방지

퇴장 판정 (10프레임 미탐지)

기존 ID 미탐지
└─ 미탐지 카운트 +1
   └─ 10프레임 동안 미탐지
      └─ 퇴장 확정 → 서버 전송

📦 상품 픽업 감지 로직

가상선 설정

// 수평 가상선 (y = 500, 640x640 좌표계 기준)
virtualLineStartX = 640;
virtualLineStartY = 500;
virtualLineEndX = 0;
virtualLineEndY = 500;

y=500 설정 이유

테이블 높이에 맞춰 설정
상품이 테이블 위에서 들어올릴 때 정확히 감지되도록 최적화

이벤트 감지 원리

┌─────────────────────────────────────┐
│          위 (선 위)                  │  ← 손에 든 상태
│  ─────────────────────────────────  │  ← y = 500 (가상선)
│          아래 (선 아래)              │  ← 테이블 위
└─────────────────────────────────────┘

이벤트 발생 조건:
1. 아래 → 위: 집기 (act = 1)
2. 위 → 아래: 내려놓기 (act = 0)

감지 알고리즘

// 1. 객체 중심점과 가상선의 거리 계산 (부호 있음)
float signedDistance = (lineEndY - lineStartY) * pointX 
                     - (lineEndX - lineStartX) * pointY 
                     + lineEndX * lineStartY 
                     - lineEndY * lineStartX;

// 2. 선 위/아래 판단
boolean isAbove = (signedDistance > 0);

// 3. 이전 프레임과 비교하여 선을 넘었는지 확인
if (wasAbove != isAbove) {
    // 선을 넘은 이벤트 발생!
    
    // 4. 가장 가까운 사람 찾기
    SimpleTracker.TrackedObject nearestPerson = findNearestPerson(...);
    
    // 5. 서버로 전송
    JSONObject actionData = new JSONObject();
    actionData.put("type", "action");
    actionData.put("personId", nearestPerson.getId());
    actionData.put("object", "컵");
    actionData.put("act", isAbove ? 1 : 0);
    
    mSocket.emit("message", actionData.toString());
}

이벤트 쿨다운

private static final long EVENT_COOLDOWN = 1000; // 1초

쿨다운 목적

같은 객체가 1초 이내에 중복 이벤트를 발생시키지 않도록 방지
예: 손이 떨려서 선을 여러 번 오가는 경우

키오스크 영역 설정

// 키오스크 고정 영역 (640x640 좌표계 기준)
kioskLeft = 30;
kioskTop = 370;
kioskRight = 100;
kioskBottom = 420;

설정 이유

서버에서 "키오스크에서 가장 가까운 사람 찾기" 요청 시 사용
CCTV 화면 내 키오스크 위치를 미리 지정하여 정확한 거리 계산

🔌 서버 통신 프로토콜

Socket.IO란?

Socket.IO vs 일반 Socket (TCP/UDP)

구분	일반 Socket (TCP/UDP)	Socket.IO
레벨	저수준 네트워크 통신	고수준 실시간 통신 라이브러리
프로토콜	원시 바이트 스트림	WebSocket 기반 + HTTP 폴백
구현	프로토콜 직접 구현 필요	이벤트 기반 시스템 제공
재연결	수동으로 구현	자동 재연결
데이터 형식	바이트 배열	JSON 자동 직렬화/역직렬화
방(Room)	직접 구현 필요	내장 기능
사용 예시	`socket.write(bytes)`	`socket.emit("event", data)`

Socket.IO 구조

Socket.IO
  ├─ WebSocket (주 전송 방식)
  ├─ HTTP Long Polling (폴백)
  ├─ 자동 재연결
  ├─ 이벤트 시스템 (emit/on)
  ├─ 네임스페이스 관리
  └─ 방(Room) 기능

일반 Socket vs Socket.IO 코드 비교

// ❌ 일반 TCP Socket (저수준)
Socket socket = new Socket("server.com", 5000);
OutputStream out = socket.getOutputStream();
out.write("Hello".getBytes());  // 직접 바이트 전송
byte[] response = new byte[1024];
socket.getInputStream().read(response);  // 직접 수신

// ✅ Socket.IO (고수준)
Socket mSocket = IO.socket("https://server.com");
mSocket.emit("message", jsonData);  // 이벤트 기반 전송
mSocket.on("response", args -> {    // 이벤트 리스너
    // 자동으로 JSON 파싱됨
});

Socket.IO 연결 설정

// MainActivity.java에서 Socket.IO 클라이언트 초기화
final String connectUrl = "https://97f1-223-194-133-239.ngrok-free.app";

try {
    mSocket = IO.socket(connectUrl);
    mSocket.connect();
    
    Log.d(TAG, "Socket.IO 연결 시도: " + connectUrl);
} catch (URISyntaxException e) {
    Log.e(TAG, "Socket.IO URI 오류", e);
}

ngrok 주소 변경 방법

MainActivity.java 파일 열기
connectUrl 변수 수정
앱 재빌드 및 실행

연결 상태 이벤트 리스너

// 연결 성공
mSocket.on(Socket.EVENT_CONNECT, args -> {
    Log.d(TAG, "서버 연결 성공");
});

// 연결 실패
mSocket.on(Socket.EVENT_CONNECT_ERROR, args -> {
    Log.e(TAG, "서버 연결 실패: " + args[0]);
});

// 연결 끊김
mSocket.on(Socket.EVENT_DISCONNECT, args -> {
    Log.w(TAG, "서버 연결 끊김");
});

📤 CCTV → 서버 이벤트

1️⃣ 이미지 스트리밍

CCTV 앱에서 전송

// MainActivity.java
JSONObject imageData = new JSONObject();
imageData.put("type", "image");
imageData.put("image", base64Image);  // Base64 인코딩된 JPEG
imageData.put("timestamp", System.currentTimeMillis());

mSocket.emit("message", imageData.toString());

서버에서 수신 (Flask + Socket.IO)

from flask_socketio import SocketIO, emit
import json
import base64

@socketio.on('message')
def handle_message(message):
    data = json.loads(message)
    message_type = data.get('type')
    
    if message_type == 'image':
        # Base64 디코딩
        image_data = base64.b64decode(data['image'])
        timestamp = data['timestamp']
        
        # 이미지 저장 또는 처리
        with open(f'frame_{timestamp}.jpg', 'wb') as f:
            f.write(image_data)
        
        print(f"이미지 수신: {len(image_data)} bytes")

데이터 형식

{
  "type": "image",
  "image": "iVBORw0KGgoAAAANSUhEUgAA...",
  "timestamp": 1234567890123
}

전송 주기: 100ms마다 (10 FPS)

이미지 최적화

// 1. 비트맵 50% 리사이징
Bitmap resized = Bitmap.createScaledBitmap(
    bitmap, 
    bitmap.getWidth() / 2, 
    bitmap.getHeight() / 2, 
    true
);

// 2. JPEG 압축 (품질 70%)
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
resized.compress(Bitmap.CompressFormat.JPEG, 70, outputStream);

// 3. Base64 인코딩
byte[] byteArray = outputStream.toByteArray();
String base64Image = Base64.encodeToString(byteArray, Base64.DEFAULT);

2️⃣ 사람 등장 이벤트

CCTV 앱에서 전송

// MainActivity.java
JSONObject appearanceData = new JSONObject();
appearanceData.put("type", "personAppearance");
appearanceData.put("timestamp", System.currentTimeMillis());

JSONArray personIdsArray = new JSONArray();
for (Integer personId : newPersonIds) {
    personIdsArray.put(personId);
}
appearanceData.put("personIds", personIdsArray);

// 썸네일 이미지 추가
appearanceData.put("thumbnail", base64Thumbnail);

mSocket.emit("message", appearanceData.toString());

서버에서 수신

@socketio.on('message')
def handle_message(message):
    data = json.loads(message)
    message_type = data.get('type')
    
    if message_type == 'personAppearance':
        person_ids = data.get('personIds', [])
        thumbnail = data.get('thumbnail')
        timestamp = data.get('timestamp')
        
        print(f"새로운 고객 등장: {person_ids}")
        
        # 데이터베이스에 저장
        for person_id in person_ids:
            save_person_to_db(person_id, timestamp)
        
        # 얼굴 이미지 요청
        emit('requestPersonFaceFind', 
             {'personIds': person_ids}, 
             broadcast=True)

데이터 형식

{
  "type": "personAppearance",
  "timestamp": 1234567890123,
  "personIds": [3, 5, 8],
  "thumbnail": "iVBORw0KGgoAAAANSUhEUgAA..."
}

발생 조건: 10프레임 연속 감지

3️⃣ 사람 퇴장 이벤트

CCTV 앱에서 전송

// MainActivity.java
JSONObject disappearanceData = new JSONObject();
disappearanceData.put("type", "personDisappearance");
disappearanceData.put("timestamp", System.currentTimeMillis());

JSONArray personIdsArray = new JSONArray();
for (Integer personId : departedPersonIds) {
    personIdsArray.put(personId);
}
disappearanceData.put("personIds", personIdsArray);

mSocket.emit("message", disappearanceData.toString());

서버에서 수신

@socketio.on('message')
def handle_message(message):
    data = json.loads(message)
    message_type = data.get('type')
    
    if message_type == 'personDisappearance':
        person_ids = data.get('personIds', [])
        timestamp = data.get('timestamp')
        
        print(f"고객 퇴장: {person_ids}")
        
        # 데이터베이스 업데이트 (퇴장 시각 기록)
        for person_id in person_ids:
            update_person_departure(person_id, timestamp)

데이터 형식

{
  "type": "personDisappearance",
  "timestamp": 1234567890123,
  "personIds": [3, 5]
}

발생 조건: 10프레임 동안 미탐지

4️⃣ 상품 행동 이벤트

CCTV 앱에서 전송

// MainActivity.java
JSONObject actionData = new JSONObject();
actionData.put("type", "action");
actionData.put("personId", nearestPerson.getId());
actionData.put("object", detection.label);  // "컵", "바나나", "사과"
actionData.put("act", isAbove ? 1 : 0);     // 1=집기, 0=내려놓기

mSocket.emit("message", actionData.toString());

서버에서 수신

@socketio.on('message')
def handle_message(message):
    data = json.loads(message)
    message_type = data.get('type')
    
    if message_type == 'action':
        person_id = data.get('personId')
        object_name = data.get('object')
        action = data.get('act')  # 0 또는 1
        
        action_text = "집기" if action == 1 else "내려놓기"
        print(f"고객 {person_id}가 {object_name}을(를) {action_text}")
        
        # 장바구니 업데이트
        if action == 1:  # 집기
            add_to_cart(person_id, object_name)
        else:  # 내려놓기
            remove_from_cart(person_id, object_name)

데이터 형식

{
  "type": "action",
  "personId": 3,
  "object": "컵",
  "act": 1
}

필드 설명

personId: 행동을 한 고객 ID
object: 상품 이름 (컵/바나나/사과)
act:
- 0: 내려놓기 (선 위 → 아래)
- 1: 집기 (선 아래 → 위)

발생 조건: 가상선(y=500) 교차 시

5️⃣ 얼굴 이미지 전송

CCTV 앱에서 전송

// MainActivity.java
JSONObject facesData = new JSONObject();
JSONObject facesObject = new JSONObject();

for (Integer personId : personIds) {
    String faceImage = capturedFaces.get(personId);
    if (faceImage != null) {
        facesObject.put(String.valueOf(personId), faceImage);
    } else {
        facesObject.put(String.valueOf(personId), JSONObject.NULL);
    }
}

facesData.put("faces", facesObject);

mSocket.emit("findPersonFace", facesData.toString());

서버에서 수신

@socketio.on('findPersonFace')
def handle_find_person_face(data):
    faces_data = data.get('faces', {})
    
    for person_id, face_image in faces_data.items():
        if face_image is not None:
            # Base64 디코딩
            face_bytes = base64.b64decode(face_image)
            
            # 얼굴 이미지 저장
            with open(f'faces/person_{person_id}.jpg', 'wb') as f:
                f.write(face_bytes)
            
            print(f"고객 {person_id} 얼굴 이미지 저장 완료")
        else:
            print(f"고객 {person_id} 얼굴 없음")

데이터 형식

{
  "faces": {
    "3": "iVBORw0KGgoAAAANSUhEUgAA...",
    "5": "iVBORw0KGgoAAAANSUhEUgAA...",
    "8": null
  }
}

이벤트명 주의: findPersonFace (다른 이벤트와 달리 별도 이벤트명 사용)

처리 흐름

1. 서버에서 얼굴 요청 (requestPersonFaceFind)
2. CCTV 앱에서 Face Detection 수행
3. YOLO 사람 객체와 거리 기반 매칭
4. 얼굴 영역 크롭 → Base64 인코딩
5. findPersonFace 이벤트로 전송

매칭 알고리즘

사람 바운딩 박스 상단 20% 지점 ↔ 얼굴 중심점
└─ 유클리드 거리 계산
   └─ 최소 거리의 얼굴 선택

6️⃣ 키오스크 근접 고객 전송

CCTV 앱에서 전송

// MainActivity.java
JSONObject nearestData = new JSONObject();
nearestData.put("type", "nearest_person_found");
nearestData.put("personId", nearestPerson.getId());
nearestData.put("distance", distance);

mSocket.emit("nearest_person_found", nearestData.toString());

서버에서 수신

@socketio.on('nearest_person_found')
def handle_nearest_person(data):
    person_id = data.get('personId')
    distance = data.get('distance')
    
    print(f"키오스크 근접 고객: ID {person_id}, 거리 {distance}px")
    
    # 해당 고객의 장바구니 정보 전송
    cart_items = get_cart(person_id)
    emit('display_cart', {'personId': person_id, 'items': cart_items})

데이터 형식

{
  "type": "nearest_person_found",
  "personId": 5,
  "distance": 123.45
}

이벤트명 주의: nearest_person_found (별도 이벤트명)

처리 흐름

1. 서버에서 키오스크 요청 (find_nearest_person)
2. CCTV 앱에서 키오스크 영역 중심점 계산
3. 모든 사람 객체와 유클리드 거리 계산
4. 최소 거리의 고객 선택
5. nearest_person_found 이벤트로 전송

📥 서버 → CCTV 이벤트

1️⃣ 얼굴 이미지 요청

서버에서 전송

from flask_socketio import emit

# 특정 고객들의 얼굴 이미지 요청
person_ids = [3, 5, 8]
emit('requestPersonFaceFind', 
     {'personIds': person_ids}, 
     broadcast=True)

CCTV 앱에서 수신

// MainActivity.java
mSocket.on("requestPersonFaceFind", args -> {
    try {
        JSONObject data = new JSONObject(args[0].toString());
        JSONArray personIdsArray = data.getJSONArray("personIds");
        
        List<Integer> personIds = new ArrayList<>();
        for (int i = 0; i < personIdsArray.length(); i++) {
            personIds.add(personIdsArray.getInt(i));
        }
        
        // 얼굴 캡처 및 전송
        captureAndSendNewFaces(personIds);
        
    } catch (JSONException e) {
        Log.e(TAG, "얼굴 요청 파싱 오류", e);
    }
});

데이터 형식

{
  "personIds": [3, 5, 8]
}

응답: findPersonFace 이벤트로 얼굴 이미지 전송

2️⃣ 키오스크 근접 고객 요청

서버에서 전송

# 특정 키오스크에서 가장 가까운 고객 찾기 요청
emit('find_nearest_person', 
     {'kioskId': 'kiosk_1'}, 
     broadcast=True)

CCTV 앱에서 수신

// MainActivity.java
mSocket.on("find_nearest_person", args -> {
    try {
        JSONObject data = new JSONObject(args[0].toString());
        String kioskId = data.getString("kioskId");
        
        Log.d(TAG, "키오스크 근접 고객 요청: " + kioskId);
        
        // 키오스크 근접 고객 찾기
        findNearestPersonToKiosk();
        
    } catch (JSONException e) {
        Log.e(TAG, "키오스크 요청 파싱 오류", e);
    }
});

데이터 형식

{
  "kioskId": "kiosk_1"
}

응답: nearest_person_found 이벤트로 고객 정보 전송

📊 전체 이벤트 요약표

CCTV → 서버

이벤트명	용도	type 필드	발생 조건	서버 수신 방법	CCTV 전송 방법
message	이미지 스트리밍	`"image"`	100ms마다	`@socketio.on('message')`	`mSocket.emit("message", data)`
message	사람 등장	`"personAppearance"`	10프레임 연속 감지	`@socketio.on('message')`	`mSocket.emit("message", data)`
message	사람 퇴장	`"personDisappearance"`	10프레임 미탐지	`@socketio.on('message')`	`mSocket.emit("message", data)`
message	상품 행동	`"action"`	가상선 교차	`@socketio.on('message')`	`mSocket.emit("message", data)`
findPersonFace	얼굴 이미지	(없음)	서버 요청 시	`@socketio.on('findPersonFace')`	`mSocket.emit("findPersonFace", data)`
nearest_person_found	키오스크 근접 고객	`"nearest_person_found"`	서버 요청 시	`@socketio.on('nearest_person_found')`	`mSocket.emit("nearest_person_found", data)`

서버 → CCTV

이벤트명	용도	데이터	서버 전송 방법	CCTV 수신 방법
requestPersonFaceFind	얼굴 이미지 요청	`{personIds: [3,5,8]}`	`emit('requestPersonFaceFind', data)`	`mSocket.on("requestPersonFaceFind", handler)`
find_nearest_person	키오스크 근접 고객 요청	`{kioskId: "kiosk_1"}`	`emit('find_nearest_person', data)`	`mSocket.on("find_nearest_person", handler)`

🔄 통신 흐름도

┌─────────────────┐                          ┌─────────────────┐
│   CCTV App      │                          │  Flask Server   │
│  (Socket.IO     │                          │  (Socket.IO)    │
│   Client)       │                          │                 │
└────────┬────────┘                          └────────┬────────┘
         │                                            │
         │  1. 연결 (Socket.IO)                       │
         │  mSocket.connect()                         │
         │───────────────────────────────────────────>│
         │                                            │
         │  EVENT_CONNECT                             │
         │<───────────────────────────────────────────│
         │                                            │
         │  2. 이미지 스트리밍 (100ms마다)             │
         │  emit('message', {type:'image',...})       │
         │───────────────────────────────────────────>│
         │                                            │
         │                  @socketio.on('message')   │
         │                  if type == 'image': ...   │
         │                                            │
         │  3. 사람 등장 이벤트                        │
         │  emit('message', {type:'personAppearance'})│
         │───────────────────────────────────────────>│
         │                                            │
         │                  if type == 'personAppearance':│
         │                    emit('requestPersonFaceFind')│
         │                                            │
         │  4. 얼굴 이미지 요청                        │
         │  on('requestPersonFaceFind')               │
         │<───────────────────────────────────────────│
         │                                            │
         │                  emit('requestPersonFaceFind', ...)│
         │                                            │
         │  5. 얼굴 이미지 전송                        │
         │  emit('findPersonFace', {faces:{...}})     │
         │───────────────────────────────────────────>│
         │                                            │
         │                  @socketio.on('findPersonFace')│
         │                  save_faces(...)           │
         │                                            │
         │  6. 상품 행동 이벤트                        │
         │  emit('message', {type:'action',...})      │
         │───────────────────────────────────────────>│
         │                                            │
         │                  if type == 'action':      │
         │                    update_cart(...)        │
         │                                            │
         │  7. 키오스크 근접 고객 요청                 │
         │  on('find_nearest_person')                 │
         │<───────────────────────────────────────────│
         │                                            │
         │                  emit('find_nearest_person', ...)│
         │                                            │
         │  8. 근접 고객 정보 전송                     │
         │  emit('nearest_person_found', {...})       │
         │───────────────────────────────────────────>│
         │                                            │
         │             @socketio.on('nearest_person_found')│
         │                  display_cart(...)         │
         │                                            │
         │  9. 사람 퇴장 이벤트                        │
         │  emit('message', {type:'personDisappearance'})│
         │───────────────────────────────────────────>│
         │                                            │
         │                  if type == 'personDisappearance':│
         │                    update_departure(...)   │
         │                                            │

💡 Socket.IO 사용 이유

왜 일반 Socket이 아닌 Socket.IO를 선택했나?

1️⃣ 자동 재연결

// Socket.IO: 자동으로 재연결 시도
mSocket.connect();  // 끊어지면 자동으로 다시 연결

// 일반 Socket: 수동으로 재연결 로직 구현 필요
while (true) {
    try {
        socket = new Socket("server", 5000);
        break;
    } catch (IOException e) {
        Thread.sleep(1000);  // 직접 구현해야 함
    }
}

2️⃣ 이벤트 기반 통신

// Socket.IO: 이벤트명으로 구분
mSocket.emit("message", data);
mSocket.emit("findPersonFace", faceData);
mSocket.on("requestPersonFaceFind", handler);

// 일반 Socket: 프로토콜 직접 설계 필요
outputStream.write("MSG|" + data);  // 커스텀 프로토콜
outputStream.write("FACE|" + faceData);

3️⃣ JSON 자동 처리

// Socket.IO: JSON 자동 직렬화
JSONObject data = new JSONObject();
data.put("type", "action");
mSocket.emit("message", data.toString());  // 자동 변환

// 일반 Socket: 수동 변환
String json = data.toString();
byte[] bytes = json.getBytes("UTF-8");
outputStream.write(bytes.length);  // 길이 먼저 전송
outputStream.write(bytes);

4️⃣ HTTP 폴백

Socket.IO 연결 시도:
1. WebSocket 연결 시도
2. 실패 시 HTTP Long Polling으로 자동 전환
3. 안정적인 통신 보장

일반 Socket:
- TCP만 지원
- 방화벽/프록시 환경에서 차단될 수 있음

5️⃣ 브로드캐스트 기능

# 서버에서 모든 CCTV에 동시 전송
emit('find_nearest_person', data, broadcast=True)

# 일반 Socket: 각 클라이언트에 개별 전송 필요
for client in clients:
    client.send(data)

🛠️ 기술 스택

개발 환경

Android Studio: Latest version
Gradle: 8.0+
Compile SDK: 34
Min SDK: 24 (Android 7.0 Nougat)
Target SDK: 34
Java Version: 1.8

핵심 라이브러리

dependencies {
    // UI 및 기본 Android
    implementation 'androidx.appcompat:appcompat:1.7.0'
    implementation 'com.google.android.material:material:1.12.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.2.1'
    
    // 네트워크 통신
    implementation 'com.squareup.okhttp3:okhttp:4.9.3'
    implementation 'io.socket:socket.io-client:2.0.0'
    
    // TensorFlow Lite (AI 모델)
    implementation 'org.tensorflow:tensorflow-lite:2.12.0'
    implementation 'org.tensorflow:tensorflow-lite-support:0.4.3'
    implementation 'org.tensorflow:tensorflow-lite-metadata:0.4.3'
    implementation 'org.tensorflow:tensorflow-lite-gpu:2.12.0'
}

TFLite 최적화 설정

Interpreter.Options options = new Interpreter.Options();

// CPU 스레드 최적화 (최대 4개)
int optimalThreads = Math.min(4, Runtime.getRuntime().availableProcessors());
options.setNumThreads(optimalThreads);

// FP16 정밀도 허용 (성능 향상)
options.setAllowFp16PrecisionForFp32(true);

// NNAPI 활성화 (Android 9+)
options.setUseNNAPI(true);

📁 디렉토리 구조

yolo-nas-app/
├── app/
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/com/example/quantiztest/
│   │   │   │   ├── MainActivity.java           # 메인 액티비티 (카메라, UI, 통신 총괄)
│   │   │   │   ├── YoloImageProcessor.java     # YOLO-NAS 객체 감지
│   │   │   │   ├── FaceDetector.java           # 얼굴 감지
│   │   │   │   ├── SimpleTracker.java          # 다중 객체 추적 알고리즘
│   │   │   │   └── TFLiteLoader.java           # TFLite 모델 로딩
│   │   │   ├── assets/
│   │   │   │   ├── yolonas_quantized.tflite    # YOLO-NAS 모델 (INT8)
│   │   │   │   ├── face_det_lite_quantized.tflite  # Face Detection 모델
│   │   │   │   └── labels.txt                  # COCO 클래스 라벨
│   │   │   └── res/
│   │   │       ├── layout/
│   │   │       │   └── activity_main.xml        # UI 레이아웃
│   │   │       └── values/
│   │   │           └── strings.xml
│   │   └── test/
│   └── build.gradle.kts                         # 앱 빌드 설정
├── gradle/
└── README.md

📚 주요 클래스 설명

MainActivity.java

역할: 앱의 메인 컨트롤러

주요 기능

카메라 제어: Camera2 API를 이용한 실시간 영상 캡처
AI 모델 실행: YOLO-NAS 및 Face Detection 수행
객체 추적: SimpleTracker를 이용한 ID 관리
서버 통신: Socket.IO를 통한 실시간 데이터 전송
UI 업데이트: 오버레이에 바운딩 박스 및 정보 표시

주요 메서드

// 프레임 처리 (100ms마다 호출)
private void processFrameForOverlay(Bitmap bitmap)

// 상품 픽업 감지
private void detectLineCrossing(List<TrackedObject> objects, ...)

// 키오스크 근접 고객 찾기
private void findNearestPersonToKiosk()

// 얼굴 캡처 및 전송
private void captureAndSendNewFaces(List<Integer> personIds)

// Socket.IO 이벤트 리스너 설정
private void setupSocketListeners()

Socket.IO 이벤트 처리

private void setupSocketListeners() {
    // 서버 연결 성공
    mSocket.on(Socket.EVENT_CONNECT, args -> {
        Log.d(TAG, "서버 연결 성공");
    });
    
    // 얼굴 이미지 요청 수신
    mSocket.on("requestPersonFaceFind", args -> {
        JSONObject data = new JSONObject(args[0].toString());
        JSONArray personIds = data.getJSONArray("personIds");
        captureAndSendNewFaces(personIds);
    });
    
    // 키오스크 근접 고객 요청 수신
    mSocket.on("find_nearest_person", args -> {
        findNearestPersonToKiosk();
    });
}

YoloImageProcessor.java

역할: YOLO-NAS 모델을 이용한 객체 감지

주요 기능

비트맵 이미지를 640×640으로 리사이징
INT8 양자화 모델 입력 버퍼 생성
모델 추론 실행
Dequantization (INT8 → float)
NMS (Non-Maximum Suppression) 적용

출력 형식

public static class Detection {
    String label;        // 객체 이름
    float confidence;    // 신뢰도 (0~1)
    float left, top;     // 바운딩 박스 좌표
    float right, bottom;
}

주요 메서드

// 객체 감지 수행
public List<Detection> detect(Bitmap bitmap)

// NMS 적용
private List<Detection> applyNMS(List<Detection> detections, float iouThreshold)

FaceDetector.java

역할: Lightweight Face Detection 모델을 이용한 얼굴 감지

주요 기능

그레이스케일 이미지 전처리
Heatmap 기반 얼굴 위치 탐지
바운딩 박스 좌표 계산
NMS 적용으로 중복 제거

출력 형식

public static class Face {
    float confidence;
    float left, top;
    float right, bottom;
}

주요 메서드

// 얼굴 감지 수행
public List<Face> detectFaces(Bitmap bitmap)

// 사람 객체와 얼굴 매칭
public Map<Integer, Bitmap> matchFacesToPersons(
    List<Face> faces, 
    List<TrackedObject> persons, 
    Bitmap bitmap
)

SimpleTracker.java

역할: 커스텀 다중 객체 추적 (MOT)

주요 기능

IoU 기반 객체 매칭
속도 벡터 예측 및 위치 추정
색상 특징 추출 (사람 전용)
방향 점수 계산
교차 상황 처리
객체 나이 관리 (등장/퇴장 판정)

핵심 클래스

public static class TrackedObject {
    int id;              // 고유 ID
    String label;        // 객체 이름
    float confidence;    // 신뢰도
    float left, top;     // 현재 위치
    float right, bottom;
    float velocityX, velocityY;  // 속도 벡터
    int age;             // 프레임 나이
    float[] upperBodyColors;  // 상체 색상 (RGB)
    float[] lowerBodyColors;  // 하체 색상 (RGB)
}

주요 메서드

// 프레임 업데이트
public List<TrackedObject> update(List<Detection> detections, Bitmap bitmap)

// IoU 계산 (속도 예측 포함)
private float calculateIoUWithPrediction(TrackedObject tracked, Detection detection)

// 색상 특징 추출
private void extractColorFeatures(TrackedObject obj, Bitmap bitmap)

// 색상 유사도 계산
private float calculateColorSimilarity(TrackedObject obj, Detection det, Bitmap bitmap)

// 교차 상황 감지
private void detectCrossings()

// 등장/퇴장 판정
public List<Integer> getNewlyAppearedPersons()
public List<Integer> getRecentlyDisappearedPersons()

TFLiteLoader.java

역할: TensorFlow Lite 모델 로딩 및 최적화

주요 기능

Assets에서 모델 파일 로드
MappedByteBuffer 생성
Interpreter 옵션 설정 (스레드, NNAPI, FP16)
모델 텐서 정보 로깅

주요 메서드

// 모델 파일 로드
public static MappedByteBuffer loadModelFile(Context context, String modelPath)

// Interpreter 옵션 생성
public static Interpreter.Options createInterpreterOptions()

🔧 성능 최적화

프레임 처리 주기

backgroundHandler.postDelayed(this, 100); // 100ms = 10 FPS

설정 이유

AI 추론 시간: 100~200ms
대기 시간 최소화
배터리 소모와 성능의 균형

이미지 압축

// 1. 크기 축소 (50%)
Bitmap resized = Bitmap.createScaledBitmap(bitmap, width/2, height/2, true);

// 2. JPEG 품질 70%
resized.compress(Bitmap.CompressFormat.JPEG, 70, outputStream);

네트워크 대역폭 절감: 약 60~70%

메모리 관리

// 비트맵 즉시 해제
bitmap.recycle();

// 프레임 버퍼 정리
if (!active_persons.isEmpty()) {
    frame_buffer.clear();
}

🎯 전체 동작 흐름

1. 앱 시작
   └─ AI 모델 로드 (YOLO-NAS, Face Detection)
   └─ Socket.IO 서버 연결
      └─ mSocket = IO.socket(connectUrl)
      └─ mSocket.connect()
      └─ 이벤트 리스너 등록 (on 메서드)
   └─ 카메라 시작

2. 실시간 처리 (100ms마다)
   └─ 프레임 캡처
   └─ YOLO-NAS 객체 감지
      └─ 사람, 컵, 바나나, 사과 감지
   └─ SimpleTracker 업데이트
      ├─ IoU 매칭
      ├─ 속도 예측
      ├─ 색상 특징 비교
      └─ ID 할당/유지
   └─ 가상선 교차 감지
      └─ 상품 픽업/내려놓기 이벤트
   └─ 이미지 Base64 인코딩
   └─ Socket.IO로 서버 전송
      └─ mSocket.emit('message', jsonData)

3. 이벤트 처리
   ├─ 등장 (10프레임 연속)
   │  └─ mSocket.emit('message', {type:'personAppearance'})
   │  └─ 서버에서 얼굴 요청
   │     └─ mSocket.on('requestPersonFaceFind', handler)
   │     └─ Face Detection 수행
   │     └─ mSocket.emit('findPersonFace', {faces:{...}})
   │
   ├─ 퇴장 (10프레임 미탐지)
   │  └─ mSocket.emit('message', {type:'personDisappearance'})
   │
   ├─ 상품 행동
   │  └─ 가상선 교차 감지
   │  └─ 가장 가까운 사람 찾기
   │  └─ mSocket.emit('message', {type:'action',...})
   │
   └─ 키오스크 요청
      └─ mSocket.on('find_nearest_person', handler)
      └─ 근접 고객 찾기
      └─ mSocket.emit('nearest_person_found', {...})

4. UI 업데이트
   └─ 오버레이에 바운딩 박스 그리기
   └─ ID, 라벨, 신뢰도 표시
   └─ 가상선 표시
   └─ 키오스크 영역 표시

Store Shield CCTV App

Name		Name	Last commit message	Last commit date
.idea		.idea
app		app
gradle/wrapper		gradle/wrapper
.gitignore		.gitignore
README.md		README.md
build.gradle.kts		build.gradle.kts
gradle.properties		gradle.properties
gradlew		gradlew
gradlew.bat		gradlew.bat
settings.gradle.kts		settings.gradle.kts

Latest commit

History

Folders and files

Repository files navigation

📹 CCTV AI 영상 분석 앱

📋 목차

🎯 개요

핵심 역할

✨ 주요 기능

1️⃣ 실시간 객체 감지

2️⃣ 고객 ID 추적 시스템

3️⃣ 커스텀 다중 객체 추적 (MOT)

4️⃣ 상품 픽업/내려놓기 자동 감지

5️⃣ 키오스크 연동

🏗️ 시스템 아키텍처

🤖 AI 모델

YOLO-NAS (INT8 양자화)

Lightweight Face Detection

Qualcomm AI Hub 최적화

🎯 객체 추적 알고리즘

추적 알고리즘 개요

주요 구성 요소

1️⃣ IoU 기반 매칭

2️⃣ 속도 벡터 예측

3️⃣ 색상 특징 추출 (사람 전용)

4️⃣ 매칭 점수 계산

5️⃣ 교차 상황 처리

등장/퇴장 판정

등장 판정 (10프레임 연속 감지)

퇴장 판정 (10프레임 미탐지)

📦 상품 픽업 감지 로직

가상선 설정

이벤트 감지 원리

감지 알고리즘

이벤트 쿨다운

키오스크 영역 설정

🔌 서버 통신 프로토콜

Socket.IO란?

Socket.IO 연결 설정

📤 CCTV → 서버 이벤트

1️⃣ 이미지 스트리밍

CCTV 앱에서 전송

서버에서 수신 (Flask + Socket.IO)

2️⃣ 사람 등장 이벤트

CCTV 앱에서 전송

서버에서 수신

3️⃣ 사람 퇴장 이벤트

CCTV 앱에서 전송

서버에서 수신

4️⃣ 상품 행동 이벤트

CCTV 앱에서 전송

서버에서 수신

5️⃣ 얼굴 이미지 전송

CCTV 앱에서 전송

서버에서 수신

6️⃣ 키오스크 근접 고객 전송

CCTV 앱에서 전송

서버에서 수신

📥 서버 → CCTV 이벤트

1️⃣ 얼굴 이미지 요청

서버에서 전송

CCTV 앱에서 수신

2️⃣ 키오스크 근접 고객 요청

서버에서 전송

CCTV 앱에서 수신

📊 전체 이벤트 요약표

CCTV → 서버

서버 → CCTV

🔄 통신 흐름도

💡 Socket.IO 사용 이유

왜 일반 Socket이 아닌 Socket.IO를 선택했나?

1️⃣ 자동 재연결

2️⃣ 이벤트 기반 통신

3️⃣ JSON 자동 처리

4️⃣ HTTP 폴백

5️⃣ 브로드캐스트 기능

🛠️ 기술 스택

개발 환경

핵심 라이브러리

TFLite 최적화 설정