NEXPIA, Smart Parking AI Platform 주차관제·카메라 번호인식(LPR)·영상 주차유도·AI 적용 — 아키텍처와 동작 데모, 개발 로드맵

# 1) 검출기: 현장 수집 데이터(주·야간/역광/오염 포함) 파인튜닝
from ultralytics import YOLO
import torch, torch.nn as nn

det = YOLO("yolov8n.pt")
det.train(data="plate_det.yaml", epochs=120, imgsz=960, batch=32,
          hsv_v=0.5, degrees=4.0, mosaic=0.6, project="runs/plate")
det.export(format="onnx", opset=17, half=True, dynamic=True)   # → Edge 배포

# 2) 인식기: CTC 기반 CRNN (숫자 10 + 한글 용도문자 클래스)
class CRNN(nn.Module):
    def __init__(self, ncls=45):                       # 44 + CTC blank
        super().__init__()
        self.cnn = nn.Sequential(
            nn.Conv2d(1,64,3,1,1),  nn.BatchNorm2d(64),  nn.ReLU(), nn.MaxPool2d(2,2),
            nn.Conv2d(64,128,3,1,1),nn.BatchNorm2d(128), nn.ReLU(), nn.MaxPool2d((2,1),(2,1)),
            nn.Conv2d(128,256,3,1,1),nn.BatchNorm2d(256),nn.ReLU())
        self.rnn = nn.LSTM(256*8, 256, 2, bidirectional=True, batch_first=True)
        self.fc  = nn.Linear(512, ncls)
    def forward(self, x):                              # x: (B,1,32,W)
        f = self.cnn(x); B,C,H,W = f.shape
        f = f.permute(0,3,1,2).reshape(B,W,C*H)        # 시퀀스화
        y,_ = self.rnn(f)
        return self.fc(y)                              # (B,T,ncls) → CTCLoss

model = CRNN()
# ... DataLoader / CTCLoss 학습 루프 수행 후:
torch.onnx.export(model, torch.randn(1,1,32,160), "lpr_rec.onnx",
                  opset_version=17, input_names=["input"], output_names=["logits"],
                  dynamic_axes={"input": {0:"batch", 3:"width"}})

// Jetson/x86 공용. CUDA 가용 시 EP 추가로 GPU 가속.
#include <onnxruntime_cxx_api.h>
#include <opencv2/opencv.hpp>
#include <memory>
#include <string>

class LprEngine {
public:
    LprEngine(const std::string& det_path, const std::string& rec_path)
        : env_(ORT_LOGGING_LEVEL_WARNING, "lpr") {
        Ort::SessionOptions so;
        so.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);
        // OrtSessionOptionsAppendExecutionProvider_CUDA(so, 0);  // GPU 사용 시
        det_ = std::make_unique<Ort::Session>(env_, det_path.c_str(), so);
        rec_ = std::make_unique<Ort::Session>(env_, rec_path.c_str(), so);
    }

    // 반환: {번호판 문자열, 신뢰도}. 미검출 시 {"", 0}
    std::pair<std::string, float> Recognize(const cv::Mat& bgr) {
        cv::Mat blob   = Letterbox(bgr, 960);          // 종횡비 보존 리사이즈
        auto     boxes = RunDetect(blob);              // NMS 포함
        if (boxes.empty()) return {"", 0.f};
        cv::Mat plate  = WarpCrop(bgr, boxes[0]);      // 4점 원근보정 → 32xW
        return RunRecognize(plate);                    // CTC greedy decode + 문법 검증
    }

private:
    Ort::Env env_;
    std::unique_ptr<Ort::Session> det_, rec_;
    // Letterbox / RunDetect / WarpCrop / RunRecognize 구현부:
    //  - NHWC→NCHW 변환, 정규화, IoU-NMS, softmax, ^\d{2,3}[가-힣]\d{4}$ 검증
};

// 인식 성공 → gRPC로 현장서버(C#) 통지 → 차단기 OPEN (아래 C# 모듈과 연동)

using Grpc.Net.Client;
using Nexpa.Edge.V1;                        // lpr_events.proto 생성 코드

public sealed class EdgeEventListener : BackgroundService
{
    private readonly ILogger<EdgeEventListener> _log;
    private readonly GateController _gate;   // 기존 차단기 제어(시리얼/RS-485) 래퍼 — Delphi 모듈도 동일 패턴
    private readonly IUplinkQueue  _cloudQ;  // 클라우드 업링크 버퍼(망 단절 시 재전송)

    public EdgeEventListener(ILogger<EdgeEventListener> log, GateController gate, IUplinkQueue q)
        => (_log, _gate, _cloudQ) = (log, gate, q);

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        using var ch = GrpcChannel.ForAddress("https://edge-01.local:7443");
        var client   = new LprService.LprServiceClient(ch);
        using var st = client.Subscribe(new SubscribeRequest { Gate = "IN-01" }, cancellationToken: ct);

        await foreach (var ev in st.ResponseStream.ReadAllAsync(ct))
        {
            _log.LogInformation("LPR {Plate} conf={Conf:P1}", ev.Plate, ev.Confidence);

            if (ev.Confidence >= 0.90 && !await IsBlacklistedAsync(ev.Plate, ct))
                await _gate.OpenAsync(ev.Gate, ct);           // 차단기 개방
            else
                await _gate.HoldForManualAsync(ev.Gate, ct);  // 저신뢰 → 수동확인 전환

            await _cloudQ.EnqueueAsync(ev, ct);               // MQTT/Kafka 상행(비동기)
        }
    }

    private Task<bool> IsBlacklistedAsync(string plate, CancellationToken ct)
        => Task.FromResult(false);            // Local DB 조회 — 오프라인에서도 판정 가능
}

@RestController
@RequestMapping("/api/v1/events")
@RequiredArgsConstructor
public class ParkingEventController {

    private final KafkaTemplate<String, ParkingEvent> kafka;
    private final SiteAuthService auth;                 // 현장 단말 mTLS/토큰 검증

    @PostMapping("/lpr")
    public ResponseEntity<Void> ingest(@RequestHeader("X-Site-Token") String token,
                                       @Valid @RequestBody ParkingEvent ev) {
        auth.verify(token, ev.siteId());
        kafka.send("parking.lpr", ev.siteId(), ev);     // 파티션 키 = 현장ID (순서 보장)
        return ResponseEntity.accepted().build();
    }

    @KafkaListener(topics = "parking.lpr", groupId = "occupancy-svc")
    void onEvent(ParkingEvent ev) {
        // 점유율 집계(TimescaleDB) → WebSocket 브로드캐스트 → 만차예측 피처 적재
    }
}

record ParkingEvent(@NotBlank String siteId,
                    @NotBlank String gate,
                    @Pattern(regexp = "^\\d{2,3}[가-힣]\\d{4}$") String plate,
                    double confidence,
                    Instant occurredAt,
                    String direction) {}