Trial 04022025

src/main/java/id/co/gtc/erhacam/Detectors.java

@@ -1,23 +1,43 @@
 package id.co.gtc.erhacam;
 
 import Config.SomeCodes;
+import lombok.NonNull;
+import org.bytedeco.opencv.opencv_core.Rect;
 import org.bytedeco.opencv.opencv_core.RectVector;
 import org.bytedeco.opencv.opencv_core.Size;
 import org.bytedeco.opencv.opencv_core.UMat;
 import org.bytedeco.opencv.opencv_objdetect.CascadeClassifier;
 import org.tinylog.Logger;
 
-public class Detectors {
-    public static CascadeClassifier faceDetector;
-    public static CascadeClassifier eyeDetector;
+import java.util.ArrayList;
+import java.util.List;
 
-    public static void LoadFaceDetector(){
-        String filename = SomeCodes.ExtractResource("/haarcascade_profileface.xml");
+public class Detectors {
+    public static CascadeClassifier frontalfaceDetector;
+    public static CascadeClassifier eyeDetector;
+    public static CascadeClassifier leftEyeDetector;
+    public static CascadeClassifier rightEyeDetector;
+    public static CascadeClassifier leftEarDetector;
+    public static CascadeClassifier rightEarDetector;
+    public static CascadeClassifier profilefaceDetector;
+
+    public static void LoadAllDetectors(){
+        LoadFrontalFaceDetector();
+        LoadProfileFaceDetector();
+        LoadEyeDetector();
+        LoadLeftEarDetector();
+        LoadRightEarDetector();
+        LoadLeftEyeDetector();
+        LoadRightEyeDetector();
+    }
+
+    private static void LoadFrontalFaceDetector(){
+        String filename = SomeCodes.ExtractResource("/haarcascade_frontalface_default.xml");
         if (filename!=null) {
             System.out.println("Face Detector file : " + filename);
-            if (faceDetector==null) {
+            if (frontalfaceDetector==null) {
                 try{
-                    faceDetector = new CascadeClassifier(filename);
+                    frontalfaceDetector = new CascadeClassifier(filename);
                     Logger.info("FaceDetector loaded");
                 } catch (Exception e){
                     Logger.error("Exception on loading FaceDetector : " + e.getMessage());
@@ -27,28 +47,23 @@ public class Detectors {
         } else Logger.error("Unable to extract face detector file");
     }
 
-    static double scaleFactor = 1.1;
-    static int minNeighbors = 3;
-    static int flags = 0;
-    static Size minSize = new Size(30, 30);
-    static Size maxSize = new Size(300, 300);
+    private static void LoadProfileFaceDetector(){
+        String filename = SomeCodes.ExtractResource("/haarcascade_profileface.xml");
+        if (filename!=null) {
+            System.out.println("Profile Face Detector file : " + filename);
+            if (profilefaceDetector==null) {
+                try{
+                    profilefaceDetector = new CascadeClassifier(filename);
+                    Logger.info("ProfileFaceDetector loaded");
+                } catch (Exception e){
+                    Logger.error("Exception on loading ProfileFaceDetector : " + e.getMessage());
+                }
 
-    /**
-     * Detect Face from Mat
-     * @param graymat Mat in Gray Scale
-     * @return RectVector if face detected, otherwise false
-     */
-    public static RectVector DetectFace(UMat graymat){
-        if (faceDetector!=null){
-            RectVector face = new RectVector();
-            //faceDetector.detectMultiScale(graymat, face);
-            faceDetector.detectMultiScale(graymat, face, scaleFactor, minNeighbors,flags, minSize, maxSize);
-            return face;
-        }
-        return null;
+            } else Logger.info("ProfileFaceDetector already loaded");
+        } else Logger.error("Unable to extract profile face detector file");
     }
 
-    public static void LoadEyeDetector(){
+    private static void LoadEyeDetector(){
         String filename = SomeCodes.ExtractResource("/haarcascade_eye_tree_eyeglasses.xml");
         if (filename!=null) {
             System.out.println("Eye Detector file : " + filename);
@@ -65,13 +80,272 @@ public class Detectors {
         } else Logger.error("Unable to extract eye detector file");
     }
 
+    private static void LoadLeftEyeDetector(){
+        String filename = SomeCodes.ExtractResource("/haarcascade_lefteye_2splits.xml");
+        if (filename!=null) {
+            System.out.println("Left Eye Detector file : " + filename);
+            if (leftEyeDetector==null) {
+                try{
+
+                    leftEyeDetector = new CascadeClassifier(filename);
+                    Logger.info("LeftEyeDetector loaded");
+                } catch (Exception e){
+                    Logger.error("Exception on loading LeftEyeDetector : " + e.getMessage());
+                }
+
+            } else Logger.info("LeftEyeDetector already loaded");
+        } else Logger.error("Unable to extract left eye detector file");
+    }
+
+    private static void LoadRightEyeDetector(){
+        String filename = SomeCodes.ExtractResource("/haarcascade_righteye_2splits.xml");
+        if (filename!=null) {
+            System.out.println("Right Eye Detector file : " + filename);
+            if (rightEyeDetector==null) {
+                try{
+
+                    rightEyeDetector = new CascadeClassifier(filename);
+                    Logger.info("RightEyeDetector loaded");
+                } catch (Exception e){
+                    Logger.error("Exception on loading RightEyeDetector : " + e.getMessage());
+                }
+
+            } else Logger.info("RightEyeDetector already loaded");
+        } else Logger.error("Unable to extract right eye detector file");
+    }
+
+    private static void LoadLeftEarDetector(){
+        String filename = SomeCodes.ExtractResource("/haarcascade_mcs_leftear.xml");
+        if (filename!=null) {
+            System.out.println("Left Ear Detector file : " + filename);
+            if (leftEarDetector==null) {
+                try{
+
+                    leftEarDetector = new CascadeClassifier(filename);
+                    Logger.info("LeftEarDetector loaded");
+                } catch (Exception e){
+                    Logger.error("Exception on loading LeftEarDetector : " + e.getMessage());
+                }
+
+            } else Logger.info("LeftEarDetector already loaded");
+        } else Logger.error("Unable to extract left ear detector file");
+    }
+
+    private static void LoadRightEarDetector(){
+        String filename = SomeCodes.ExtractResource("/haarcascade_mcs_rightear.xml");
+        if (filename!=null) {
+            System.out.println("Right Ear Detector file : " + filename);
+            if (rightEarDetector==null) {
+                try{
+
+                    rightEarDetector = new CascadeClassifier(filename);
+                    Logger.info("RightEarDetector loaded");
+                } catch (Exception e){
+                    Logger.error("Exception on loading RightEarDetector : " + e.getMessage());
+                }
+
+            } else Logger.info("RightEarDetector already loaded");
+        } else Logger.error("Unable to extract right ear detector file");
+    }
+
+
+    //TODO buat kalkulasi range minSize dan maxSize kalau pakai BestMat (3840x2160) dan LiveMat (1280x720)
+
+    /**
+     * Detect if there is a frontal face, containing 2 eyes
+     * @param graymat Mat in Gray Scale
+     * @return List of Rect if face detected, otherwise empty list
+     */
+    public static @NonNull List<Rect> HaveFrontalFace(UMat graymat){
+        List<Rect> result = new ArrayList<>();
+        RectVector faces = DetectFrontalFace(graymat);
+        if (faces!=null && faces.size()>0){
+
+            for(Rect face : faces.get()){
+                UMat faceMat = new UMat(graymat, face);
+                RectVector eyes = DetectEye(faceMat);
+                if (eyes!=null && eyes.size()>=2){
+                    result.add(face);
+                }
+            }
+        }
+        return result;
+    }
+
+    public static @NonNull List<Rect> HaveLeft45Face(UMat graymat){
+        List<Rect> result = new ArrayList<>();
+        RectVector faces = DetectProfileFace(graymat);
+        if (faces!=null && faces.size()>0){
+
+            for(Rect face : faces.get()){
+                UMat faceMat = new UMat(graymat, face);
+                RectVector eyes = DetectLeftEye(faceMat);
+                if (eyes!=null && eyes.size()>0){
+                    result.add(face);
+                }
+            }
+        }
+        return result;
+    }
+
+    public static @NonNull List<Rect> HaveRight45Face(UMat graymat){
+        List<Rect> result = new ArrayList<>();
+        RectVector faces = DetectProfileFace(graymat);
+        if (faces!=null && faces.size()>0){
+
+            for(Rect face : faces.get()){
+                UMat faceMat = new UMat(graymat, face);
+                RectVector eyes = DetectRightEye(faceMat);
+                if (eyes!=null && eyes.size()>0){
+                    result.add(face);
+                }
+            }
+        }
+        return result;
+    }
+
+    public static @NonNull List<Rect> HaveLeft90Face(UMat graymat){
+        List<Rect> result = new ArrayList<>();
+        RectVector leftears = DetectLeftEar(graymat);
+        RectVector lefteyes = DetectLeftEye(graymat);
+        if (leftears!=null && leftears.size()>0 && lefteyes!=null && lefteyes.size()>0){
+            for(Rect ear : leftears.get()){
+                result.add(ear);
+            }
+        }
+        return result;
+    }
+
+    public static @NonNull List<Rect> HaveRight90Face(UMat graymat){
+        List<Rect> result = new ArrayList<>();
+        RectVector rightears = DetectRightEar(graymat);
+        RectVector righteyes = DetectRightEye(graymat);
+        if (rightears!=null && rightears.size()>0 && righteyes!=null && righteyes.size()>0){
+            for(Rect ear : rightears.get()){
+                result.add(ear);
+            }
+        }
+        return result;
+    }
+
+
+
+
+
+    private static double scaleFactor = 1.1;
+    private final static int minNeighbors = 3;
+    private final  static int flags = 0;
+    private static Size minSize = new Size(200,200);
+    private static Size maxSize = new Size(400,400);
+
+    public static void setScaleFactor(double value){
+        if (scaleFactor!=value) scaleFactor = value;
+    }
+
+    public static void setMinSize(int value){
+        if (minSize.width()!=value || minSize.height()!=value) minSize = new Size(value, value);
+    }
+
+    public static void setMaxSize(int value){
+        if (maxSize.width()!=value || maxSize.height()!=value) maxSize = new Size(value, value);
+    }
+
+
+    public static RectVector DetectProfileFace(UMat graymat){
+        return Detect(graymat, profilefaceDetector, scaleFactor, minNeighbors, flags, minSize, maxSize);
+    }
+
+
+
+    /**
+     * Detect Face from Mat
+     * @param graymat Mat in Gray Scale
+     * @return RectVector if face detected, otherwise null
+     */
+    public static RectVector DetectFrontalFace(UMat graymat){
+        return Detect(graymat, frontalfaceDetector, scaleFactor, minNeighbors, flags, minSize, maxSize);
+    }
+
+
+    /**
+     * Detect Eye from Mat
+     * If Eye detected, it will return RectVector with size is number of eyes detected
+     * @param graymat Mat in Gray Scale
+     * @return RectVector if eye detected, otherwise null
+     */
     public static RectVector DetectEye(UMat graymat){
-        if (eyeDetector!=null){
-            RectVector eye = new RectVector();
-            eyeDetector.detectMultiScale(graymat, eye);
-            return eye;
+        return Detect(graymat, eyeDetector);
+    }
+
+
+    /**
+     * Detect Left Eye from Mat
+     * @param graymat Mat in Gray Scale
+     * @return RectVector if left eye detected, otherwise null
+     */
+    public static RectVector DetectLeftEye(UMat graymat){
+        return Detect(graymat, leftEyeDetector);
+    }
+
+
+    /**
+     * Detect Right Eye from Mat
+     * @param graymat Mat in Gray Scale
+     * @return RectVector if right eye detected, otherwise null
+     */
+    public static RectVector DetectRightEye(UMat graymat){
+        return Detect(graymat, rightEyeDetector);
+    }
+
+
+    /**
+     * Detect Left Ear from Mat
+     * @param graymat Mat in Gray Scale
+     * @return RectVector if left ear detected, otherwise null
+     */
+    public static RectVector DetectLeftEar(UMat graymat){
+        return Detect(graymat, leftEarDetector);
+    }
+
+
+    /**
+     * Detect Right Ear from Mat
+     * @param graymat Mat in Gray Scale
+     * @return RectVector if right ear detected, otherwise null
+     */
+    public static RectVector DetectRightEar(UMat graymat){
+        return Detect(graymat, rightEarDetector);
+    }
+
+    private static RectVector Detect(UMat graymat, CascadeClassifier detector){
+        if (detector!=null){
+            if (graymat!=null){
+                if (!graymat.empty()){
+                    RectVector detected = new RectVector();
+                    detector.detectMultiScale(graymat, detected);
+                    return detected;
+                }
+            }
+
         }
         return null;
     }
 
+    @SuppressWarnings("SameParameterValue")
+    private static RectVector Detect(UMat graymat, CascadeClassifier detector, double scaleFactor, int minNeighbors, int flags, Size minSize, Size maxSize){
+        if (detector!=null){
+            if (graymat!=null){
+                if (!graymat.empty()){
+                    RectVector detected = new RectVector();
+                    detector.detectMultiScale(graymat, detected, scaleFactor, minNeighbors, flags, minSize, maxSize);
+                    return detected;
+                }
+            }
+
+        }
+        return null;
+    }
+
+
+
 }