Распознавание объектов на Java с OpenCV и Swing

static {
    // Указываем путь к нативной библиотеке
    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
}

public class OpenCVLoader {
    public static void loadNativeLibrary() {
        try {
            // Определяем платформу
            String osName = System.getProperty("os.name").toLowerCase();
            String libName = getLibraryName(osName);
            
            // Извлекаем из ресурсов во временный файл
            InputStream in = OpenCVLoader.class.getResourceAsStream("/native/" + libName);
            File tempLib = File.createTempFile("opencv", ".tmp");
            Files.copy(in, tempLib.toPath(), StandardCopyOption.REPLACE_EXISTING);
            
            // Загружаем
            System.load(tempLib.getAbsolutePath());
        } catch (IOException e) {
            throw new RuntimeException("Не удалось загрузить OpenCV", e);
        }
    }
    
    private static String getLibraryName(String os) {
        if (os.contains("win")) return "opencv_java470.dll";
        if (os.contains("mac")) return "libopencv_java470.dylib";
        return "libopencv_java470.so";
    }
}

Mat testMat = new Mat(3, 3, CvType.CV_8UC1);
System.out.println("OpenCV версия: " + Core.VERSION);

public class OpenCVTest {
    static {
        // Загружаем нативную библиотеку
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
    
    public static void main(String[] args) {
        System.out.println("Версия OpenCV: " + Core.VERSION);
        
        // Создаем простую матрицу 5x5
        Mat matrix = Mat.eye(5, 5, CvType.CV_8UC1);
        System.out.println("Матрица создана: " + matrix.dump());
        
        // Освобождаем память
        matrix.release();
    }
}

Mat image = Imgcodecs.imread("test.jpg");
if (image.empty()) {
    System.err.println("Не удалось загрузить изображение");
    return;
}
System.out.println("Размер: " + image.width() + "x" + image.height());
System.out.println("Каналов: " + image.channels());

BufferedImage bufImage = matToBufferedImage(image);
if (bufImage != null) {
    System.out.println("Конвертация успешна: " + bufImage.getType());
}
 
// Утилита для конвертации
private static BufferedImage matToBufferedImage(Mat matrix) {
    int type = BufferedImage.TYPE_BYTE_GRAY;
    if (matrix.channels() > 1) {
        type = BufferedImage.TYPE_3BYTE_BGR;
    }
    BufferedImage image = new BufferedImage(matrix.cols(), matrix.rows(), type);
    final byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
    matrix.get(0, 0, data);
    return image;
}

CascadeClassifier faceDetector = new CascadeClassifier();
// Загружаем предобученную модель для лиц
faceDetector.load("haarcascade_frontalface_default.xml");
 
if (faceDetector.empty()) {
    throw new RuntimeException("Не удалось загрузить классификатор");
}

Mat grayImage = new Mat();
Imgproc.cvtColor(sourceImage, grayImage, Imgproc.COLOR_BGR2GRAY);
 
MatOfRect faces = new MatOfRect();
faceDetector.detectMultiScale(
    grayImage,           // входное изображение в оттенках серого
    faces,               // результаты - прямоугольники найденных объектов
    1.1,                 // scaleFactor - насколько уменьшать изображение на каждом шаге
    3,                   // minNeighbors - сколько соседних детекций подтверждают объект
    0,                   // флаги (обычно 0)
    new Size(30, 30),    // минимальный размер искомого объекта
    new Size()           // максимальный размер (пусто = без ограничений)
);
 
// Обрабатываем результаты
Rect[] facesArray = faces.toArray();
for (Rect rect : facesArray) {
    Imgproc.rectangle(sourceImage, rect.tl(), rect.br(), new Scalar(0, 255, 0), 2);
}

public static CascadeClassifier loadClassifierFromResources(String resourcePath) {
    try {
        // Читаем из ресурсов
        InputStream is = MyClass.class.getResourceAsStream(resourcePath);
        byte[] buffer = is.readAllBytes();
        
        // Создаем временный файл
        File tempFile = File.createTempFile("cascade", ".xml");
        tempFile.deleteOnExit(); // удалится при завершении JVM
        
        // Записываем содержимое
        Files.write(tempFile.toPath(), buffer);
        
        // Загружаем классификатор
        CascadeClassifier classifier = new CascadeClassifier();
        classifier.load(tempFile.getAbsolutePath());
        
        return classifier;
    } catch (IOException e) {
        throw new RuntimeException("Ошибка загрузки модели", e);
    }
}

public class DetectorCache {
    private static CascadeClassifier faceDetector;
    
    public static synchronized CascadeClassifier getFaceDetector() {
        if (faceDetector == null) {
            faceDetector = loadClassifierFromResources("/models/frontalface.xml");
        }
        return faceDetector;
    }
}

Size minFaceSize = new Size(80, 80);  // минимум 80х80 пикселей
Size maxFaceSize = new Size(200, 200); // максимум 200х200
 
faceDetector.detectMultiScale(
    grayImage,
    faces,
    1.2,              // крупный шаг, но размеры ограничены
    4,                // строгая фильтрация
    0,
    minFaceSize,
    maxFaceSize
);

// Адаптивная логика на основе среднего уровня яркости
Scalar meanBrightness = Core.mean(grayImage);
int minNeighbors = meanBrightness.val[0] > 100 ? 5 : 3;
 
// Или на основе количества детекций в предыдущем кадре
if (previousDetectionCount > 10) {
    minNeighbors = 6; // слишком много - ужесточаем
} else if (previousDetectionCount == 0) {
    minNeighbors = 2; // ничего не нашли - смягчаем
}

public class DetectionMetrics {
    private int truePositives = 0;
    private int falsePositives = 0;
    private int falseNegatives = 0;
    
    public void evaluate(List<Rect> detections, List<Rect> groundTruth) {
        // Флаги для отслеживания найденных GT объектов
        boolean[] matched = new boolean[groundTruth.size()];
        
        for (Rect detection : detections) {
            boolean found = false;
            
            // Ищем соответствие среди GT
            for (int i = 0; i < groundTruth.size(); i++) {
                if (matched[i]) continue;
                
                double iou = calculateIoU(detection, groundTruth.get(i));
                if (iou > 0.5) { // порог перекрытия 50%
                    truePositives++;
                    matched[i] = true;
                    found = true;
                    break;
                }
            }
            
            if (!found) {
                falsePositives++; // детекция без соответствия
            }
        }
        
        // Считаем пропущенные объекты
        for (boolean m : matched) {
            if (!m) falseNegatives++;
        }
    }
    
    private double calculateIoU(Rect a, Rect b) {
        // Intersection over Union - метрика перекрытия прямоугольников
        int x1 = Math.max(a.x, b.x);
        int y1 = Math.max(a.y, b.y);
        int x2 = Math.min(a.x + a.width, b.x + b.width);
        int y2 = Math.min(a.y + a.height, b.y + b.height);
        
        if (x2 < x1 || y2 < y1) return 0.0;
        
        double intersection = (x2 - x1) * (y2 - y1);
        double union = a.area() + b.area() - intersection;
        
        return intersection / union;
    }
    
    public double getPrecision() {
        if (truePositives + falsePositives == 0) return 0.0;
        return (double) truePositives / (truePositives + falsePositives);
    }
    
    public double getRecall() {
        if (truePositives + falseNegatives == 0) return 0.0;
        return (double) truePositives / (truePositives + falseNegatives);
    }
    
    public double getF1Score() {
        double p = getPrecision();
        double r = getRecall();
        if (p + r == 0) return 0.0;
        return 2 * p * r / (p + r);
    }
}

HOGDescriptor hog = new HOGDescriptor();
hog.setSVMDetector(HOGDescriptor.getDefaultPeopleDetector());
 
MatOfRect foundLocations = new MatOfRect();
MatOfDouble foundWeights = new MatOfDouble();
 
hog.detectMultiScale(
    grayImage,
    foundLocations,
    foundWeights,
    0.0,                    // hitThreshold - порог уверенности
    new Size(8, 8),         // winStride - шаг окна
    new Size(32, 32),       // padding
    1.05,                   // scale
    2.0,                    // finalThreshold
    false                   // useMeanshiftGrouping
);

// Загружаем модель YOLO
Net net = Dnn.readNetFromDarknet(
    "yolov3.cfg",           // конфигурация сети
    "yolov3.weights"        // веса модели
);
 
// Подготавливаем изображение
Mat blob = Dnn.blobFromImage(
    image,
    1/255.0,                // масштаб пикселей
    new Size(416, 416),     // размер входа сети
    new Scalar(0, 0, 0),    // вычитаемое среднее
    true,                   // swapRB - BGR в RGB
    false                   // crop
);
 
net.setInput(blob);
List<Mat> result = new ArrayList<>();
net.forward(result, getOutputNames(net));

public class VideoPanel extends JPanel {
    private BufferedImage currentFrame;
    
    public void updateFrame(BufferedImage newFrame) {
        this.currentFrame = newFrame;
        repaint(); // запрашиваем перерисовку
    }
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        
        if (currentFrame != null) {
            // Масштабируем под размер панели
            int panelWidth = getWidth();
            int panelHeight = getHeight();
            
            g.drawImage(currentFrame, 0, 0, 
                       panelWidth, panelHeight, null);
        }
    }
}

public class OptimizedVideoPanel extends JPanel {
    private BufferedImage displayBuffer;
    private BufferedImage backBuffer;
    private final Object bufferLock = new Object();
    
    private long lastRepaintTime = 0;
    private static final long MIN_REPAINT_INTERVAL = 33; // ~30 fps
    
    public void updateFrame(BufferedImage newFrame) {
        synchronized (bufferLock) {
            backBuffer = newFrame; // обновляем задний буфер
        }
        
        // Ограничиваем частоту перерисовки
        long currentTime = System.currentTimeMillis();
        if (currentTime - lastRepaintTime > MIN_REPAINT_INTERVAL) {
            lastRepaintTime = currentTime;
            
            synchronized (bufferLock) {
                displayBuffer = backBuffer; // свапаем буферы
            }
            
            repaint();
        }
    }
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        
        synchronized (bufferLock) {
            if (displayBuffer != null) {
                g.drawImage(displayBuffer, 0, 0, 
                           getWidth(), getHeight(), null);
            }
        }
    }
}

JFrame frame = new JFrame("Детектор объектов");
frame.setLayout(new BorderLayout());
 
OptimizedVideoPanel videoPanel = new OptimizedVideoPanel();
frame.add(videoPanel, BorderLayout.CENTER);
 
// Панель управления
JPanel controlPanel = new JPanel();
JButton startBtn = new JButton("Старт");
JButton stopBtn = new JButton("Стоп");
controlPanel.add(startBtn);
controlPanel.add(stopBtn);
 
frame.add(controlPanel, BorderLayout.SOUTH);
frame.setSize(800, 600);
frame.setVisible(true);

@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2d = (Graphics2D) g;
    
    // Улучшаем качество масштабирования
    g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                        RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
                        RenderingHints.VALUE_RENDER_QUALITY);
    
    if (currentFrame != null) {
        g2d.drawImage(currentFrame, 0, 0, 
                     getWidth(), getHeight(), null);
    }
}

private void drawScaledImage(Graphics2D g2d, BufferedImage image) {
    int imgWidth = image.getWidth();
    int imgHeight = image.getHeight();
    int panelWidth = getWidth();
    int panelHeight = getHeight();
    
    double imgAspect = (double) imgWidth / imgHeight;
    double panelAspect = (double) panelWidth / panelHeight;
    
    int drawWidth, drawHeight, x, y;
    
    if (imgAspect > panelAspect) {
        // Изображение шире панели
        drawWidth = panelWidth;
        drawHeight = (int) (panelWidth / imgAspect);
        x = 0;
        y = (panelHeight - drawHeight) / 2;
    } else {
        // Изображение выше панели
        drawHeight = panelHeight;
        drawWidth = (int) (panelHeight * imgAspect);
        x = (panelWidth - drawWidth) / 2;
        y = 0;
    }
    
    g2d.drawImage(image, x, y, drawWidth, drawHeight, null);
}

private VolatileImage volatileBuffer;
 
public void updateFrame(BufferedImage newFrame) {
    if (volatileBuffer == null || 
        volatileBuffer.validate(getGraphicsConfiguration()) == 
        VolatileImage.IMAGE_INCOMPATIBLE) {
        // Создаем или пересоздаем буфер
        volatileBuffer = createVolatileImage(
            newFrame.getWidth(), newFrame.getHeight()
        );
    }
    
    Graphics2D g = volatileBuffer.createGraphics();
    g.drawImage(newFrame, 0, 0, null);
    g.dispose();
    
    repaint();
}

startButton.addActionListener(e -> {
    // ПЛОХО: блокируем EDT
    while (isRunning) {
        Mat frame = videoCapture.read();
        detector.detectObjects(frame);
        videoPanel.updateFrame(convertToBufferedImage(frame));
    }
});

public class VideoProcessor extends SwingWorker<Void, BufferedImage> {
    private volatile boolean running = true;
    private VideoCapture capture;
    private CascadeClassifier detector;
    
    @Override
    protected Void doInBackground() throws Exception {
        // Выполняется в фоновом потоке
        capture = new VideoCapture(0);
        Mat frame = new Mat();
        
        while (running && !isCancelled()) {
            if (capture.read(frame)) {
                // Детекция объектов
                MatOfRect objects = new MatOfRect();
                detector.detectMultiScale(frame, objects);
                
                // Рисуем прямоугольники
                for (Rect rect : objects.toArray()) {
                    Imgproc.rectangle(frame, rect.tl(), rect.br(), 
                                     new Scalar(0, 255, 0), 2);
                }
                
                // Отправляем результат в EDT
                publish(matToBufferedImage(frame));
            }
            
            Thread.sleep(33); // ~30 fps
        }
        
        return null;
    }
    
    @Override
    protected void process(List<BufferedImage> chunks) {
        // Выполняется в EDT - безопасно обновлять UI
        if (!chunks.isEmpty()) {
            BufferedImage lastFrame = chunks.get(chunks.size() - 1);
            videoPanel.updateFrame(lastFrame);
        }
    }
    
    public void stopProcessing() {
        running = false;
    }
}

ExecutorService executor = Executors.newFixedThreadPool(4);
 
for (int camId = 0; camId < 4; camId++) {
    final int id = camId;
    executor.submit(() -> {
        VideoCapture cap = new VideoCapture(id);
        Mat frame = new Mat();
        
        while (isRunning) {
            cap.read(frame);
            processFrame(frame, id);
            
            // Обновление UI через SwingUtilities
            SwingUtilities.invokeLater(() -> 
                updateCameraPanel(id, frame)
            );
        }
    });
}

public class VideoArchitecture {
    private final BlockingQueue<Mat> frameQueue = 
        new ArrayBlockingQueue<>(10);
    private final ExecutorService captureThread = 
        Executors.newSingleThreadExecutor();
    private final ExecutorService processingPool = 
        Executors.newFixedThreadPool(2);
    
    public void start() {
        // Producer - захват кадров
        captureThread.submit(() -> {
            VideoCapture capture = new VideoCapture(0);
            Mat frame = new Mat();
            
            while (isRunning) {
                if (capture.read(frame)) {
                    try {
                        // Если очередь полна - блокируется
                        frameQueue.put(frame.clone());
                    } catch (InterruptedException e) {
                        break;
                    }
                }
            }
        });
        
        // Consumer - обработка
        processingPool.submit(() -> {
            while (isRunning) {
                try {
                    Mat frame = frameQueue.take();
                    processFrame(frame);
                    frame.release(); // освобождаем память
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
    }
}

public class PipelineProcessor {
    private final BlockingQueue<Mat> rawFrames = 
        new LinkedBlockingQueue<>(5);
    private final BlockingQueue<Mat> preprocessed = 
        new LinkedBlockingQueue<>(5);
    private final BlockingQueue<DetectionResult> detected = 
        new LinkedBlockingQueue<>(5);
    
    // Этап 1: захват
    private void captureStage() {
        VideoCapture cap = new VideoCapture(0);
        Mat frame = new Mat();
        
        while (isRunning) {
            cap.read(frame);
            rawFrames.offer(frame.clone());
        }
    }
    
    // Этап 2: препроцессинг
    private void preprocessStage() {
        while (isRunning) {
            Mat raw = rawFrames.poll(100, TimeUnit.MILLISECONDS);
            if (raw != null) {
                Mat gray = new Mat();
                Imgproc.cvtColor(raw, gray, Imgproc.COLOR_BGR2GRAY);
                Imgproc.equalizeHist(gray, gray);
                
                preprocessed.offer(gray);
                raw.release();
            }
        }
    }
    
    // Этап 3: детекция
    private void detectionStage() {
        CascadeClassifier detector = loadDetector();
        
        while (isRunning) {
            Mat frame = preprocessed.poll(100, TimeUnit.MILLISECONDS);
            if (frame != null) {
                MatOfRect objects = new MatOfRect();
                detector.detectMultiScale(frame, objects);
                
                detected.offer(new DetectionResult(frame, objects));
            }
        }
    }
}

public class EventBus {
    private final Map<Class<?>, List<Consumer<?>>> subscribers = 
        new ConcurrentHashMap<>();
    
    public <T> void subscribe(Class<T> eventType, Consumer<T> handler) {
        subscribers.computeIfAbsent(eventType, 
            k -> new CopyOnWriteArrayList<>()).add(handler);
    }
    
    public <T> void publish(T event) {
        List<Consumer<?>> handlers = subscribers.get(event.getClass());
        if (handlers != null) {
            for (Consumer handler : handlers) {
                ((Consumer<T>) handler).accept(event);
            }
        }
    }
}
 
// Использование
eventBus.subscribe(FrameCapturedEvent.class, event -> {
    processFrame(event.getFrame());
});
 
eventBus.subscribe(DetectionCompleteEvent.class, event -> {
    SwingUtilities.invokeLater(() -> 
        updateUI(event.getResults())
    );
});

private volatile boolean isRunning = true;
 
stopButton.addActionListener(e -> {
    isRunning = false; // видно всем потокам немедленно
});
 
// В рабочем потоке
while (isRunning) {
    processFrame();
}

class MatResource implements AutoCloseable {
    private final Mat mat;
    
    MatResource(Mat mat) { this.mat = mat; }
    Mat get() { return mat; }
    
    @Override
    public void close() {
        if (mat != null) mat.release();
    }
}
 
// Использование
try (MatResource res = new MatResource(new Mat())) {
    Mat frame = res.get();
    detector.detectMultiScale(frame, results);
} // автоматический release

VideoCapture capture = new VideoCapture(0);
 
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    System.out.println("Освобождаем ресурсы...");
    if (capture.isOpened()) {
        capture.release();
    }
}));

Mat frame = new Mat();
if (!capture.read(frame) || frame.empty()) {
    System.err.println("Не удалось захватить кадр");
    
    // Пытаемся переподключиться
    capture.release();
    Thread.sleep(1000);
    capture.open(cameraId);
}

public void cleanup() {
    isRunning = false; // сигнал всем циклам
    
    executor.shutdown();
    try {
        if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
            executor.shutdownNow(); // таймаут - насильно
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
    }
    
    capture.release();
}

// Открываем веб-камеру
VideoCapture camera = new VideoCapture(0);
 
// Или видеофайл
VideoCapture video = new VideoCapture("/path/to/video.mp4");
 
// Проверяем успешность открытия
if (!camera.isOpened()) {
    System.err.println("Не удалось открыть камеру");
    return;
}

Mat frame = new Mat();
while (true) {
    boolean success = camera.read(frame);
    
    if (!success || frame.empty()) {
        System.out.println("Конец потока или ошибка чтения");
        break;
    }
    
    // Обрабатываем кадр
    processFrame(frame);
}

long lastProcessTime = System.currentTimeMillis();
int targetInterval = 1000 / 25; // 25 fps = 40 мс между кадрами
 
while (camera.read(frame)) {
    long currentTime = System.currentTimeMillis();
    
    // Пропускаем кадр, если еще не прошло нужное время
    if (currentTime - lastProcessTime < targetInterval) {
        continue;
    }
    
    lastProcessTime = currentTime;
    detectObjects(frame);
}

// Устанавливаем разрешение 1280x720
camera.set(Videoio.CAP_PROP_FRAME_WIDTH, 1280);
camera.set(Videoio.CAP_PROP_FRAME_HEIGHT, 720);
 
// Проверяем, что применилось
double actualWidth = camera.get(Videoio.CAP_PROP_FRAME_WIDTH);
System.out.println("Фактическая ширина: " + actualWidth);

public static List<Integer> findAvailableCameras() {
    List<Integer> cameras = new ArrayList<>();
    
    for (int i = 0; i < 10; i++) {
        VideoCapture cap = new VideoCapture(i);
        if (cap.isOpened()) {
            cameras.add(i);
            cap.release();
        }
    }
    
    return cameras;
}

// Явно указываем backend для Windows
VideoCapture camera = new VideoCapture(0, Videoio.CAP_DSHOW);
 
// Для Linux
VideoCapture linuxCam = new VideoCapture(0, Videoio.CAP_V4L2);

VideoCapture camera = new VideoCapture(0);
Mat dummy = new Mat();
 
// Сбрасываем первые кадры
for (int i = 0; i < 15; i++) {
    camera.read(dummy);
}
dummy.release();
 
// Теперь можно начинать реальную обработку

public static BufferedImage matToBufferedImage(Mat mat) {
    int type = BufferedImage.TYPE_BYTE_GRAY;
    
    if (mat.channels() == 3) {
        type = BufferedImage.TYPE_3BYTE_BGR;
    }
    
    BufferedImage image = new BufferedImage(
        mat.cols(), mat.rows(), type
    );
    
    byte[] data = ((DataBufferByte) image.getRaster()
                   .getDataBuffer()).getData();
    mat.get(0, 0, data);
    
    return image;
}

Mat rgb = new Mat();
Imgproc.cvtColor(mat, rgb, Imgproc.COLOR_BGR2RGB);
// теперь конвертируем в BufferedImage

public static Mat bufferedImageToMat(BufferedImage image) {
    Mat mat = new Mat(image.getHeight(), image.getWidth(), 
                     CvType.CV_8UC3);
    
    byte[] pixels = ((DataBufferByte) image.getRaster()
                     .getDataBuffer()).getData();
    mat.put(0, 0, pixels);
    
    return mat;
}

public class BatchProcessor {
    private final List<Mat> batchBuffer = new ArrayList<>();
    private final int batchSize = 4;
    private final CascadeClassifier detector;
    
    public void processFrame(Mat frame) {
        batchBuffer.add(frame.clone());
        
        if (batchBuffer.size() >= batchSize) {
            processBatch(new ArrayList<>(batchBuffer));
            batchBuffer.clear();
        }
    }
    
    private void processBatch(List<Mat> frames) {
        List<MatOfRect> allResults = new ArrayList<>();
        
        // Обрабатываем всю пачку за раз
        for (Mat frame : frames) {
            MatOfRect results = new MatOfRect();
            detector.detectMultiScale(frame, results);
            allResults.add(results);
        }
        
        // Отправляем результаты дальше
        publishResults(frames, allResults);
    }
}

public class AsyncBatchProcessor {
    private final ExecutorService captureExecutor = 
        Executors.newSingleThreadExecutor();
    private final ExecutorService processingExecutor = 
        Executors.newFixedThreadPool(2);
    private final BlockingQueue<CompletableFuture<Mat>> frameQueue = 
        new LinkedBlockingQueue<>(10);
    
    public void start() {
        // Асинхронный захват
        captureExecutor.submit(() -> {
            VideoCapture cap = new VideoCapture(0);
            
            while (isRunning) {
                CompletableFuture<Mat> frameFuture = 
                    CompletableFuture.supplyAsync(() -> {
                        Mat frame = new Mat();
                        cap.read(frame);
                        return frame;
                    }, processingExecutor);
                
                frameQueue.offer(frameFuture);
            }
        });
        
        // Асинхронная обработка батчей
        processingExecutor.submit(() -> {
            List<CompletableFuture<Mat>> batch = new ArrayList<>();
            
            while (isRunning) {
                // Собираем батч из фьючерсов
                for (int i = 0; i < batchSize; i++) {
                    CompletableFuture<Mat> future = 
                        frameQueue.poll(100, TimeUnit.MILLISECONDS);
                    if (future != null) {
                        batch.add(future);
                    }
                }
                
                if (!batch.isEmpty()) {
                    // Ждем готовности всех кадров
                    CompletableFuture.allOf(
                        batch.toArray(new CompletableFuture[0])
                    ).thenAccept(v -> {
                        List<Mat> frames = batch.stream()
                            .map(CompletableFuture::join)
                            .collect(Collectors.toList());
                        
                        processBatch(frames);
                    });
                    
                    batch.clear();
                }
            }
        });
    }
}

// Запуск с оптимизированными флагами
java -XX:+UseZGC \
     -XX:+UnlockExperimentalVMOptions \
     -XX:ZCollectionInterval=5 \
     -Xms2G -Xmx4G \
     -jar detector.jar

public class MatPool {
    private final BlockingQueue<Mat> pool;
    
    public MatPool(int size, int rows, int cols, int type) {
        pool = new LinkedBlockingQueue<>(size);
        for (int i = 0; i < size; i++) {
            pool.offer(new Mat(rows, cols, type));
        }
    }
    
    public Mat acquire() throws InterruptedException {
        return pool.take();
    }
    
    public void release(Mat mat) {
        pool.offer(mat);
    }
}

// Создаем ROI - центральные 60% кадра
Rect roi = new Rect(
    frame.width() / 5, frame.height() / 5,
    (int)(frame.width() * 0.6), (int)(frame.height() * 0.6)
);
Mat roiMat = frame.submat(roi);
 
// Детекция только внутри ROI
detector.detectMultiScale(roiMat, results);
 
// Координаты результатов нужно скорректировать
for (Rect r : results.toArray()) {
    r.x += roi.x;
    r.y += roi.y;
}

Mat small = new Mat();
Imgproc.resize(frame, small, new Size(), 0.5, 0.5, 
               Imgproc.INTER_LINEAR);
detector.detectMultiScale(small, results);
 
// Масштабируем результаты обратно
for (Rect r : results.toArray()) {
    r.x *= 2; r.y *= 2;
    r.width *= 2; r.height *= 2;
}

VideoCapture video = new VideoCapture("traffic.mp4");
 
if (!video.isOpened()) {
    System.err.println("Не могу открыть файл");
    return;
}
 
// Получаем параметры видео
double fps = video.get(Videoio.CAP_PROP_FPS);
int frameCount = (int) video.get(Videoio.CAP_PROP_FRAME_COUNT);
System.out.println("FPS: " + fps + ", кадров: " + frameCount);

// Подключение к IP-камере по HTTP
VideoCapture ipCam = new VideoCapture("http://192.168.1.100:8080/video");
 
// Некоторые камеры требуют аутентификацию
String urlWithAuth = "http://admin:password@192.168.1.100:8080/video";
VideoCapture authCam = new VideoCapture(urlWithAuth);

String rtspUrl = "rtsp://admin:12345@192.168.1.50:554/stream1";
VideoCapture rtspCam = new VideoCapture(rtspUrl);
 
// Принудительно указываем TCP вместо UDP
rtspCam.set(Videoio.CAP_PROP_OPEN_TIMEOUT_MSEC, 5000);
rtspCam.set(Videoio.CAP_PROP_READ_TIMEOUT_MSEC, 5000);

rtspCam.set(Videoio.CAP_PROP_BUFFERSIZE, 1);
 
// Или сбрасываем буфер вручную каждые N кадров
int frameCounter = 0;
while (rtspCam.read(frame)) {
    if (++frameCounter % 10 == 0) {
        // Пропускаем несколько кадров для синхронизации
        for (int i = 0; i < 3; i++) {
            rtspCam.grab();
        }
    }
    
    processFrame(frame);
}

// Грубая фильтрация Haar
MatOfRect coarseFaces = new MatOfRect();
haarDetector.detectMultiScale(grayFrame, coarseFaces, 1.2, 3);
 
// Точная детекция только на найденных областях
for (Rect faceRegion : coarseFaces.toArray()) {
    Mat faceROI = frame.submat(faceRegion);
    List<Detection> detailedResults = dnnDetector.detect(faceROI);
    // Обрабатываем точные результаты
}

// Инициализация трекера после детекции
Tracker tracker = TrackerKCF.create();
tracker.init(frame, detectedBoundingBox);
 
// На последующих кадрах просто обновляем позицию
Rect2d newPosition = new Rect2d();
boolean trackingSuccess = tracker.update(nextFrame, newPosition);
 
if (!trackingSuccess) {
    // Трекер потерял объект - запускаем детекцию заново
    redetect(nextFrame);
}

// Простое экспоненциальное сглаживание
private Rect smoothedRect;
private final double alpha = 0.7;
 
public Rect smoothBoundingBox(Rect newRect) {
    if (smoothedRect == null) {
        smoothedRect = newRect;
        return newRect;
    }
    
    smoothedRect.x = (int)(alpha * newRect.x + (1-alpha) * smoothedRect.x);
    smoothedRect.y = (int)(alpha * newRect.y + (1-alpha) * smoothedRect.y);
    smoothedRect.width = (int)(alpha * newRect.width + (1-alpha) * smoothedRect.width);
    smoothedRect.height = (int)(alpha * newRect.height + (1-alpha) * smoothedRect.height);
    
    return smoothedRect;
}

// Вычисляем среднюю яркость кадра
Scalar meanBrightness = Core.mean(grayFrame);
double brightness = meanBrightness.val[0];
 
// Адаптируем параметры под условия освещения
int minNeighbors;
double scaleFactor;
 
if (brightness < 80) {
    // Темно - смягчаем критерии
    minNeighbors = 2;
    scaleFactor = 1.05;
} else if (brightness > 150) {
    // Ярко - можем быть строже
    minNeighbors = 6;
    scaleFactor = 1.2;
} else {
    // Средние условия
    minNeighbors = 4;
    scaleFactor = 1.1;
}
 
faceDetector.detectMultiScale(grayFrame, faces, 
    scaleFactor, minNeighbors);

// Камера на высоте 3 метра, минимальное лицо 60x60
Size minSize = new Size(60, 60);
Size maxSize = new Size(300, 300);
 
faceDetector.detectMultiScale(
    grayFrame, faces, 1.1, 4, 0, minSize, maxSize
);

List<Rect> filteredFaces = new ArrayList<>();
 
for (Rect face : faces.toArray()) {
    double aspectRatio = (double) face.width / face.height;
    
    // Лица имеют соотношение близкое к 1:1
    if (aspectRatio > 0.75 && aspectRatio < 1.3) {
        filteredFaces.add(face);
    }
}

public List<Rect> applyNMS(List<Rect> boxes, double overlapThreshold) {
    List<Rect> result = new ArrayList<>();
    boolean[] suppressed = new boolean[boxes.size()];
    
    for (int i = 0; i < boxes.size(); i++) {
        if (suppressed[i]) continue;
        
        result.add(boxes.get(i));
        
        // Подавляем все перекрывающиеся
        for (int j = i + 1; j < boxes.size(); j++) {
            if (calculateIoU(boxes.get(i), boxes.get(j)) > overlapThreshold) {
                suppressed[j] = true;
            }
        }
    }
    
    return result;
}

// Сначала ищем лица
MatOfRect faces = new MatOfRect();
faceDetector.detectMultiScale(grayFrame, faces);
 
List<Rect> validatedFaces = new ArrayList<>();
 
for (Rect face : faces.toArray()) {
    // Проверяем наличие глаз внутри найденного лица
    Mat faceROI = grayFrame.submat(face);
    MatOfRect eyes = new MatOfRect();
    eyeDetector.detectMultiScale(faceROI, eyes);
    
    // Валидное лицо содержит минимум одну пару глаз
    if (eyes.toArray().length >= 2) {
        validatedFaces.add(face);
    }
}

ForkJoinPool forkJoinPool = new ForkJoinPool(4);
 
List<CompletableFuture<MatOfRect>> tasks = Arrays.asList(
    CompletableFuture.supplyAsync(() -> {
        MatOfRect faces = new MatOfRect();
        faceDetector.detectMultiScale(frame, faces);
        return faces;
    }, forkJoinPool),
    
    CompletableFuture.supplyAsync(() -> {
        MatOfRect pedestrians = new MatOfRect();
        hogDetector.detectMultiScale(frame, pedestrians);
        return pedestrians;
    }, forkJoinPool)
);
 
// Ждём завершения всех детекций
CompletableFuture.allOf(tasks.toArray(new CompletableFuture[0])).join();

Mat frame = new Mat();
try {
    capture.read(frame);
    detector.detectMultiScale(frame, results);
    // обработка результатов
} finally {
    frame.release(); // гарантированное освобождение
}

try {
    Mat result = new Mat();
    // Попытка умножить матрицы несовместимых размеров
    Core.gemm(mat1, mat2, 1.0, new Mat(), 0.0, result);
} catch (CvException e) {
    // Это поймаем - OpenCV бросит исключение
    System.err.println("Ошибка OpenCV: " + e.getMessage());
} catch (Exception e) {
    // Segfault сюда не попадет
    System.err.println("Общая ошибка: " + e.getMessage());
}

// Оборонительное программирование во всей красе
if (frame == null || frame.empty()) {
    logger.error("Пустой кадр на входе");
    return Collections.emptyList();
}
 
if (roi.x < 0 || roi.y < 0 || 
    roi.x + roi.width > frame.cols() ||
    roi.y + roi.height > frame.rows()) {
    logger.error("ROI выходит за границы кадра");
    return Collections.emptyList();
}

@Test
public void testFaceDetectionOnValidatedDataset() {
    List<TestCase> dataset = loadTestDataset("faces_dataset");
    DetectionMetrics metrics = new DetectionMetrics();
    
    for (TestCase testCase : dataset) {
        Mat image = Imgcodecs.imread(testCase.getImagePath());
        MatOfRect detections = new MatOfRect();
        
        faceDetector.detectMultiScale(image, detections);
        
        // Сравниваем с ground truth разметкой
        metrics.evaluate(
            Arrays.asList(detections.toArray()),
            testCase.getGroundTruth()
        );
        
        image.release();
    }
    
    // Проверяем метрики качества
    double precision = metrics.getPrecision();
    double recall = metrics.getRecall();
    double f1 = metrics.getF1Score();
    
    assertTrue("Precision слишком низкий: " + precision, 
               precision > 0.85);
    assertTrue("Recall слишком низкий: " + recall, 
               recall > 0.80);
    
    System.out.println(String.format(
        "Precision: %.3f, Recall: %.3f, F1: %.3f",
        precision, recall, f1
    ));
}

src/main/java/com/detector/
├── capture/
│   ├── VideoCapture.java
│   ├── ImageSource.java
│   └── CameraManager.java
├── detection/
│   ├── ObjectDetector.java
│   ├── HaarDetector.java
│   ├── YoloDetector.java
│   └── DetectionResult.java
├── processing/
│   ├── FrameProcessor.java
│   ├── DetectionPipeline.java
│   └── ResultAggregator.java
└── ui/
    ├── MainWindow.java
    ├── VideoPanel.java
    └── ControlPanel.java

public interface DetectionListener {
    void onObjectDetected(DetectionEvent event);
}
 
public class ObjectDetector {
    private final List<DetectionListener> listeners = 
        new CopyOnWriteArrayList<>();
    
    public void addListener(DetectionListener listener) {
        listeners.add(listener);
    }
    
    protected void notifyListeners(DetectionEvent event) {
        // Оповещаем всех подписчиков
        for (DetectionListener listener : listeners) {
            listener.onObjectDetected(event);
        }
    }
}

public interface DetectionStrategy {
    List<Rect> detect(Mat frame);
}
 
public class HaarStrategy implements DetectionStrategy {
    public List<Rect> detect(Mat frame) {
        // Реализация через Haar Cascades
    }
}
 
// Использование
DetectionStrategy strategy = new HaarStrategy();
context.setStrategy(strategy); // меняем на лету

public class DetectorFactory {
    public static ObjectDetector createFaceDetector(String type) {
        switch (type) {
            case "HAAR":
                HaarDetector haar = new HaarDetector();
                haar.loadModel("haarcascade_frontalface.xml");
                haar.setMinNeighbors(4);
                return haar;
            case "DNN":
                DnnDetector dnn = new DnnDetector();
                dnn.loadModel("face_model.pb");
                return dnn;
            default:
                throw new IllegalArgumentException("Неизвестный тип");
        }
    }
}

import org.opencv.core.*;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.videoio.VideoCapture;
import org.opencv.videoio.Videoio;
 
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
 
/**
 * Главный класс приложения детекции объектов
 */
public class ObjectDetectorApp extends JFrame {
    
    static {
        // Загружаем нативную библиотеку OpenCV при инициализации класса
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
    
    private final VideoPanel videoPanel;
    private final JButton startButton;
    private final JButton stopButton;
    private final JSlider sensitivitySlider;
    private final JLabel statusLabel;
    
    private DetectionWorker worker;
    private final AtomicBoolean isRunning = new AtomicBoolean(false);
    
    public ObjectDetectorApp() {
        super("OpenCV Object Detector");
        
        // Настройка главного окна
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout(10, 10));
        
        // Панель для отображения видео
        videoPanel = new VideoPanel();
        videoPanel.setPreferredSize(new Dimension(640, 480));
        add(videoPanel, BorderLayout.CENTER);
        
        // Панель управления
        JPanel controlPanel = new JPanel(new FlowLayout());
        
        startButton = new JButton("Запустить детекцию");
        startButton.addActionListener(e -> startDetection());
        
        stopButton = new JButton("Остановить");
        stopButton.setEnabled(false);
        stopButton.addActionListener(e -> stopDetection());
        
        // Слайдер чувствительности (minNeighbors)
        sensitivitySlider = new JSlider(2, 8, 4);
        sensitivitySlider.setMajorTickSpacing(2);
        sensitivitySlider.setPaintTicks(true);
        sensitivitySlider.setPaintLabels(true);
        
        controlPanel.add(new JLabel("Чувствительность:"));
        controlPanel.add(sensitivitySlider);
        controlPanel.add(startButton);
        controlPanel.add(stopButton);
        
        add(controlPanel, BorderLayout.SOUTH);
        
        // Строка состояния
        statusLabel = new JLabel("Готов к работе");
        add(statusLabel, BorderLayout.NORTH);
        
        // Завершение при закрытии окна
        addWindowListener(new java.awt.event.WindowAdapter() {
            @Override
            public void windowClosing(java.awt.event.WindowEvent e) {
                cleanup();
            }
        });
        
        pack();
        setLocationRelativeTo(null);
    }
    
    private void startDetection() {
        if (isRunning.get()) return;
        
        isRunning.set(true);
        startButton.setEnabled(false);
        stopButton.setEnabled(true);
        statusLabel.setText("Инициализация камеры...");
        
        // Запускаем обработку в фоновом потоке
        worker = new DetectionWorker();
        worker.execute();
    }
    
    private void stopDetection() {
        if (!isRunning.get()) return;
        
        isRunning.set(false);
        
        if (worker != null && !worker.isDone()) {
            worker.cancel(true);
        }
        
        startButton.setEnabled(true);
        stopButton.setEnabled(false);
        statusLabel.setText("Остановлено");
    }
    
    private void cleanup() {
        stopDetection();
        System.out.println("Освобождение ресурсов...");
    }
    
    /**
     * SwingWorker для детекции в фоновом потоке
     */
    private class DetectionWorker extends SwingWorker<Void, BufferedImage> {
        
        private VideoCapture camera;
        private CascadeClassifier faceDetector;
        
        @Override
        protected Void doInBackground() throws Exception {
            // Инициализация камеры
            camera = new VideoCapture(0);
            if (!camera.isOpened()) {
                throw new RuntimeException("Не удалось открыть камеру");
            }
            
            // Устанавливаем разрешение
            camera.set(Videoio.CAP_PROP_FRAME_WIDTH, 640);
            camera.set(Videoio.CAP_PROP_FRAME_HEIGHT, 480);
            
            // Загружаем детектор лиц
            faceDetector = new CascadeClassifier();
            String cascadePath = ObjectDetectorApp.class
                .getResource("/haarcascade_frontalface_default.xml")
                .getPath();
            
            if (!faceDetector.load(cascadePath)) {
                throw new RuntimeException("Не удалось загрузить модель детектора");
            }
            
            publish((BufferedImage) null); // триггер обновления статуса
            
            Mat frame = new Mat();
            Mat grayFrame = new Mat();
            
            // Основной цикл захвата и обработки
            while (isRunning.get() && !isCancelled()) {
                try {
                    // Захват кадра
                    if (!camera.read(frame) || frame.empty()) {
                        Thread.sleep(10);
                        continue;
                    }
                    
                    // Конвертация в grayscale для детекции
                    Imgproc.cvtColor(frame, grayFrame, Imgproc.COLOR_BGR2GRAY);
                    Imgproc.equalizeHist(grayFrame, grayFrame);
                    
                    // Детекция лиц с текущими параметрами чувствительности
                    MatOfRect faces = new MatOfRect();
                    int minNeighbors = sensitivitySlider.getValue();
                    
                    faceDetector.detectMultiScale(
                        grayFrame,
                        faces,
                        1.1,
                        minNeighbors,
                        0,
                        new Size(30, 30),
                        new Size()
                    );
                    
                    // Отрисовка прямоугольников на кадре
                    for (Rect rect : faces.toArray()) {
                        Imgproc.rectangle(
                            frame,
                            new Point(rect.x, rect.y),
                            new Point(rect.x + rect.width, rect.y + rect.height),
                            new Scalar(0, 255, 0),
                            2
                        );
                        
                        // Добавляем текст с уверенностью
                        Imgproc.putText(
                            frame,
                            "Face",
                            new Point(rect.x, rect.y - 5),
                            Imgproc.FONT_HERSHEY_SIMPLEX,
                            0.5,
                            new Scalar(0, 255, 0),
                            1
                        );
                    }
                    
                    // Конвертируем Mat в BufferedImage и отправляем на отрисовку
                    BufferedImage bufferedImage = matToBufferedImage(frame);
                    publish(bufferedImage);
                    
                    // Ограничение FPS до ~30
                    Thread.sleep(33);
                    
                } catch (Exception e) {
                    System.err.println("Ошибка обработки кадра: " + e.getMessage());
                }
            }
            
            // Освобождаем ресурсы
            frame.release();
            grayFrame.release();
            camera.release();
            
            return null;
        }
        
        @Override
        protected void process(List<BufferedImage> chunks) {
            // Обновление UI в EDT потоке
            if (chunks.isEmpty()) {
                statusLabel.setText("Камера запущена, детекция активна");
                return;
            }
            
            BufferedImage lastFrame = chunks.get(chunks.size() - 1);
            if (lastFrame != null) {
                videoPanel.updateFrame(lastFrame);
            }
        }
        
        @Override
        protected void done() {
            statusLabel.setText("Детекция остановлена");
        }
        
        /**
         * Конвертирует Mat в BufferedImage
         */
        private BufferedImage matToBufferedImage(Mat matrix) {
            int type = BufferedImage.TYPE_BYTE_GRAY;
            if (matrix.channels() > 1) {
                type = BufferedImage.TYPE_3BYTE_BGR;
            }
            
            int bufferSize = matrix.channels() * matrix.cols() * matrix.rows();
            byte[] buffer = new byte[bufferSize];
            matrix.get(0, 0, buffer);
            
            BufferedImage image = new BufferedImage(
                matrix.cols(),
                matrix.rows(),
                type
            );
            
            final byte[] targetPixels = 
                ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
            System.arraycopy(buffer, 0, targetPixels, 0, buffer.length);
            
            return image;
        }
    }
    
    /**
     * Панель для отображения видеопотока
     */
    private static class VideoPanel extends JPanel {
        
        private BufferedImage currentImage;
        
        public void updateFrame(BufferedImage newImage) {
            this.currentImage = newImage;
            repaint();
        }
        
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            
            if (currentImage != null) {
                Graphics2D g2d = (Graphics2D) g;
                g2d.setRenderingHint(
                    RenderingHints.KEY_INTERPOLATION,
                    RenderingHints.VALUE_INTERPOLATION_BILINEAR
                );
                
                // Сохраняем aspect ratio
                int panelWidth = getWidth();
                int panelHeight = getHeight();
                int imgWidth = currentImage.getWidth();
                int imgHeight = currentImage.getHeight();
                
                double imgAspect = (double) imgWidth / imgHeight;
                double panelAspect = (double) panelWidth / panelHeight;
                
                int drawWidth, drawHeight, x, y;
                
                if (imgAspect > panelAspect) {
                    drawWidth = panelWidth;
                    drawHeight = (int) (panelWidth / imgAspect);
                    x = 0;
                    y = (panelHeight - drawHeight) / 2;
                } else {
                    drawHeight = panelHeight;
                    drawWidth = (int) (panelHeight * imgAspect);
                    x = (panelWidth - drawWidth) / 2;
                    y = 0;
                }
                
                g2d.drawImage(currentImage, x, y, drawWidth, drawHeight, null);
            }
        }
    }
    
    /**
     * Точка входа в приложение
     */
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            ObjectDetectorApp app = new ObjectDetectorApp();
            app.setVisible(true);
        });
    }
}

# Конфигурация детектора
camera.device.id=0
camera.resolution.width=640
camera.resolution.height=480
detector.model.path=/models/haarcascade_frontalface_default.xml
detector.min.neighbors=4
detector.scale.factor=1.1
detection.fps.limit=30

public class ConfigManager {
   private static Properties properties;
   
   static {
       properties = new Properties();
       try (InputStream input = ConfigManager.class
           .getResourceAsStream("/detector.properties")) {
           properties.load(input);
       } catch (IOException e) {
           System.err.println("Не удалось загрузить конфигурацию: " + e.getMessage());
       }
   }
   
   public static int getCameraId() {
       return Integer.parseInt(properties.getProperty("camera.device.id", "0"));
   }
   
   public static int getMinNeighbors() {
       return Integer.parseInt(properties.getProperty("detector.min.neighbors", "4"));
   }
}

private static final Logger logger = LoggerFactory.getLogger(DetectionWorker.class);
 
// В цикле обработки
logger.debug("Захвачен кадр {}x{}", frame.cols(), frame.rows());
logger.info("Обнаружено объектов: {}", faces.toArray().length);