【人脸识别】 新增多种人脸识别模型

【底层优化】 支持自由选择 OpenCV 或 BufferedImage 作为图像引擎

【通用图像】 全部模型启用 Image 输入，支持各类图片格式与 Image 的互转

【模型管理】 优化模型生命周期，关闭后可重新创建

【人脸识别】 支持在人脸查询结果中绘制姓名标注

【人脸检测】 新增人脸裁剪功能

【修复】 修复若干已知问题，提升系统稳定性

Author: geekwenjie

README.md

@@ -426,6 +426,7 @@ SmartJavaAI是专为JAVA 开发者打造的一个功能丰富、开箱即用的
 ### 2、Maven
 
 在项目的 `pom.xml` 的 `dependencies` 中可以一次性引入全部功能（如下所示）。
+ 
 ⚠️ **注意：不推荐直接引入全部依赖**，更推荐根据实际需求，按功能模块单独引入，避免引入不必要的包。
 
 详细引入方式请查看 [文档](http://doc.smartjavaai.cn/install.html)、或查看[示例代码](https://gitee.com/dengwenjie/SmartJavaAI/tree/master/examples)
@@ -434,7 +435,7 @@ SmartJavaAI是专为JAVA 开发者打造的一个功能丰富、开箱即用的
 <dependency>
     <groupId>cn.smartjavaai</groupId>
     <artifactId>smartjavaai-all</artifactId>
-    <version>1.0.24</version>
+    <version>1.0.25</version>
 </dependency>
 ```
 
@@ -577,6 +578,7 @@ SmartJavaAI是专为JAVA 开发者打造的一个功能丰富、开箱即用的
 | YOLOV8-SEG  | OnnxRuntime | Ultralytics在COCO 数据集 上训练的模型        | [Github](https://docs.ultralytics.com/zh/tasks/segment/) |
 | YOLOV11-SEG | OnnxRuntime | Ultralytics在COCO 数据集 上训练的模型 |  [Github](https://docs.ultralytics.com/zh/tasks/segment/)        |
 | Mask R-CNN | MXNet | Mask R-CNN 是一种在目标检测基础上，同时为每个物体生成像素级分割区域的深度学习模型 | 无          |
+
 ---
 
 #### OBB旋转框目标检测模型
@@ -733,6 +735,18 @@ SmartJavaAI是专为JAVA 开发者打造的一个功能丰富、开箱即用的
 
 ## 近期更新日志
 
+## [v1.0.25] - 2025-10-02
+- 【人脸检测】新增6个模型(MTCNN、YOLOV5、RetinaFace小尺寸版)，大幅提升性能
+- 【人脸识别】新增Seetaface6轻量模型
+- 【目标检测】支持视频流目标检测（rtsp、视频文件等）
+- 【目标检测】支持tensorflow2目标检测模型
+- 【目标检测】新增行人检测模型(yolo-person)
+- 【通用视觉】新增4个动作识别模型
+- 【通用视觉】新增语义分割模型
+- 【通用视觉】新增5个实例分割模型(含yolov8-seg、yolov11-seg)
+- 【通用视觉】新增yolo-obb11旋转框检测(含yolov11-obb)
+- 【通用视觉】新增5个姿态估计模型(含yolov8-pose、yolov11-pose)
+
 ## [v1.0.24] - 2025-09-07
 - 【人脸检测】新增6个模型(MTCNN、YOLOV5、RetinaFace小尺寸版)，大幅提升性能
 - 【人脸识别】新增Seetaface6轻量模型

all/pom.xml

@@ -6,11 +6,11 @@
     <parent>
         <groupId>cn.smartjavaai</groupId>
         <artifactId>smartjavaai-parent</artifactId>
-        <version>1.0.24</version>
+        <version>1.0.25</version>
     </parent>
 
     <artifactId>all</artifactId>
-    <version>1.0.24</version>
+    <version>1.0.25</version>
     <name>${project.artifactId}</name>
     <description>SmartJavaAI</description>
     <url>https://github.com/geekwenjie/SmartJavaAI</url>

bom/pom.xml

@@ -6,12 +6,12 @@
     <parent>
         <groupId>cn.smartjavaai</groupId>
         <artifactId>smartjavaai-parent</artifactId>
-        <version>1.0.24</version>
+        <version>1.0.25</version>
     </parent>
 
-    <version>1.0.24</version>
+    <version>1.0.25</version>
     <artifactId>bom</artifactId>
-    <name>sbom</name>
+    <name>bom</name>
     <description>统一版本管理的 BOM 包，同时支持 import 和全量依赖</description>
 
     <properties>

common/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>cn.smartjavaai</groupId>
         <artifactId>smartjavaai-parent</artifactId>
-        <version>1.0.24</version>
+        <version>1.0.25</version>
     </parent>
 
     <name>common</name>

common/src/main/java/cn/smartjavaai/common/cv/SmartImageFactory.java

@@ -21,45 +21,132 @@
 
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayInputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.ByteBuffer;
 import java.nio.IntBuffer;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 
 /**
  * 图片处理工厂类
  * @author dwj
  */
-public class SmartImageFactory extends BufferedImageFactory {
+public class SmartImageFactory {
 
+    public enum Engine {
+        BUFFEREDIMAGE,
+        OPENCV
+    }
+
+    private static volatile Engine currentEngine = Engine.BUFFEREDIMAGE;
     private static volatile SmartImageFactory instance;
 
-    public static SmartImageFactory newInstance() {
+    public static synchronized void setEngine(Engine engine) {
+        if (engine == null || engine == currentEngine) {
+            return;
+        }
+        currentEngine = engine;
+        // 只在切换时注册全局
+        switch (currentEngine) {
+            case OPENCV:
+                ImageFactory.setImageFactory(new OpenCVImageFactory());
+                break;
+            case BUFFEREDIMAGE:
+            default:
+                ImageFactory.setImageFactory(new BufferedImageFactory());
+        }
+    }
+
+    public static synchronized SmartImageFactory getInstance() {
         if (instance == null) {
-            synchronized (SmartImageFactory.class) {
-                if (instance == null) {
-                    instance = new SmartImageFactory();
-                }
+            instance = new SmartImageFactory();
+            // 初始化全局 Engine
+            switch (currentEngine) {
+                case OPENCV:
+                    ImageFactory.setImageFactory(new OpenCVImageFactory());
+                    break;
+                case BUFFEREDIMAGE:
+                default:
+                    ImageFactory.setImageFactory(new BufferedImageFactory());
             }
         }
         return instance;
     }
 
-    public static SmartImageFactory getInstance(){
-        return newInstance();
-    }
 
     public Image fromBufferedImage(BufferedImage sourceImage){
-        return fromImage(OpenCVUtils.image2Mat(sourceImage));
+        if (sourceImage == null) {
+            throw new IllegalArgumentException("BufferedImage 不能为空");
+        }
+        Image image = null;
+        switch (currentEngine) {
+            case BUFFEREDIMAGE:
+                image = ImageFactory.getInstance().fromImage(sourceImage);
+                break;
+            case OPENCV:
+                // 先转 Mat
+                Mat mat = OpenCVUtils.image2Mat(sourceImage);
+                image = ImageFactory.getInstance().fromImage(mat);
+                break;
+            default:
+                throw new IllegalStateException("未知 Engine: " + currentEngine);
+        }
+        return image;
+    }
+
+    public Image fromMat(Mat mat){
+        if (mat == null) {
+            throw new IllegalArgumentException("mat 不能为空");
+        }
+        Image image = null;
+        switch (currentEngine) {
+            case OPENCV:
+                image = ImageFactory.getInstance().fromImage(mat);
+                break;
+            case BUFFEREDIMAGE:
+                // 先转 Mat
+                BufferedImage sourceImage = OpenCVUtils.mat2Image(mat);
+                image = ImageFactory.getInstance().fromImage(sourceImage);
+                break;
+            default:
+                throw new IllegalStateException("未知 Engine: " + currentEngine);
+        }
+        return image;
     }
 
     public Image fromBase64(String base64Image) throws IOException {
-        return fromUrl(base64Image);
+        return ImageFactory.getInstance().fromUrl(base64Image);
     }
 
-    public Image fromBytes(byte[] imageData){
-        return fromImage(new ByteArrayInputStream(imageData));
+    public Image fromBytes(byte[] imageData) throws IOException {
+        return ImageFactory.getInstance().fromInputStream(new ByteArrayInputStream(imageData));
     }
 
+    public Image fromFile(File file) throws IOException {
+        return ImageFactory.getInstance().fromFile(file.toPath());
+    }
+
+    public Image fromFile(Path path) throws IOException {
+        return ImageFactory.getInstance().fromFile(path);
+    }
+
+    public Image fromFile(String filePath) throws IOException {
+        if (filePath == null || filePath.trim().isEmpty()) {
+            throw new IllegalArgumentException("filePath 不能为空");
+        }
+        return fromFile(Paths.get(filePath));
+    }
+
+    public Image fromPixels(int[] pixels, int width, int height){
+        return ImageFactory.getInstance().fromPixels(pixels, width, height);
+    }
+
+    public Image fromInputStream(InputStream inputStream) throws IOException {
+        return ImageFactory.getInstance().fromInputStream(inputStream);
+    }
+
+
+
 }

common/src/main/java/cn/smartjavaai/common/entity/PolygonLabel.java

@@ -0,0 +1,28 @@
+package cn.smartjavaai.common.entity;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 多边形
+ * @author dwj
+ */
+@Data
+public class PolygonLabel {
+
+    private List<Point> points;
+    private String text;
+
+    public PolygonLabel(List<Point> points, String text) {
+        this.points = points;
+        this.text = text;
+    }
+
+    public PolygonLabel() {
+    }
+
+    public PolygonLabel(List<Point> points) {
+        this.points = points;
+    }
+}

common/src/main/java/cn/smartjavaai/common/preprocess/BufferedImagePreprocessor.java

@@ -10,7 +10,7 @@
  * @author dwj
  * @date 2025/6/27
  */
-public class BufferedImagePreprocessor {
+public class BufferedImagePreprocessor implements ImagePreprocessor<BufferedImage>{
 
     private BufferedImage image;
     private DetectionRectangle rect;

common/src/main/java/cn/smartjavaai/common/preprocess/DJLImagePreprocessor.java

@@ -0,0 +1,84 @@
+package cn.smartjavaai.common.preprocess;
+
+import ai.djl.modality.cv.Image;
+import cn.smartjavaai.common.cv.SmartImageFactory;
+import cn.smartjavaai.common.entity.DetectionRectangle;
+import org.opencv.core.Mat;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+/**
+ * @author dwj
+ */
+public class DJLImagePreprocessor implements ImagePreprocessor<Image>{
+
+
+    private final ImagePreprocessor<?> delegate;
+    private Image input = null;
+
+    public DJLImagePreprocessor(Image image, DetectionRectangle rect) {
+        this.input = image;
+        if (input.getWrappedImage() instanceof BufferedImage) {
+            this.delegate = new BufferedImagePreprocessor((BufferedImage) input.getWrappedImage(), rect);
+        } else if (input.getWrappedImage() instanceof Mat) {
+            this.delegate = new OpenCVPreprocessor((Mat) input.getWrappedImage(), rect);
+        } else {
+            throw new IllegalArgumentException("Unsupported input type");
+        }
+    }
+
+    @Override
+    public DJLImagePreprocessor setExtendRatio(float ratio) {
+        delegate.setExtendRatio(ratio);
+        return this;
+    }
+
+    @Override
+    public DJLImagePreprocessor setTargetSize(int size) {
+        delegate.setTargetSize(size);
+        return this;
+    }
+
+    @Override
+    public DJLImagePreprocessor setCenterCropSize(int size) {
+        delegate.setCenterCropSize(size);
+        return this;
+    }
+
+    @Override
+    public DJLImagePreprocessor enableSquarePadding(boolean enable) {
+        delegate.enableSquarePadding(enable);
+        return this;
+    }
+
+    @Override
+    public DJLImagePreprocessor enableScaling(boolean enable) {
+        delegate.enableScaling(enable);
+        return this;
+    }
+
+    @Override
+    public DJLImagePreprocessor enableCenterCrop(boolean enable) {
+        delegate.enableCenterCrop(enable);
+        return this;
+    }
+
+    @Override
+    public ImagePreprocessor setPaddingColor(Color color) {
+        return delegate.setPaddingColor(color);
+    }
+
+
+    @Override
+    public Image process() {
+        Object result = delegate.process();
+        if (result instanceof BufferedImage) {
+            return SmartImageFactory.getInstance().fromBufferedImage((BufferedImage) result);
+        } else if (result instanceof Mat) {
+            return SmartImageFactory.getInstance().fromMat((Mat) result);
+        }
+        throw new IllegalStateException("Unsupported process result: " + result.getClass());
+    }
+
+}

common/src/main/java/cn/smartjavaai/common/preprocess/ImagePreprocessor.java

@@ -0,0 +1,28 @@
+package cn.smartjavaai.common.preprocess;
+
+import java.awt.*;
+
+/**
+ * 图片预处理
+ * @author dwj
+ */
+public interface ImagePreprocessor<T> {
+
+
+    ImagePreprocessor<T> setExtendRatio(float ratio);
+
+    ImagePreprocessor<T> setTargetSize(int size);
+
+    ImagePreprocessor<T> setCenterCropSize(int size);
+
+    ImagePreprocessor<T> enableSquarePadding(boolean enable);
+
+    ImagePreprocessor<T> enableScaling(boolean enable);
+
+    ImagePreprocessor<T> enableCenterCrop(boolean enable);
+
+    ImagePreprocessor<T> setPaddingColor(Color color);
+
+    T process();
+
+}