Skip to content
The Chat Archive
mistral-medium-2505· Mistral AI LMArena Human Preference 140K

I need to build this in groovy. Give me coding examples of how to do this: vision system…

  1. User

    I need to build this in groovy. Give me coding examples of how to do this: vision system to detect items moving into and out of view on a camera

  2. Assistant

    Groovy Vision System for Object Detection

    Here's a comprehensive example of how to build a vision system in Groovy to detect items moving into and out of view on a camera. This example uses OpenCV (via JavaCV) for computer vision tasks.

    Prerequisites

    First, you'll need to add these dependencies to your project (Maven or Gradle):

    // For Gradle
    dependencies {
        implementation 'org.bytedeco:javacv-platform:1.5.7'
        implementation 'org.bytedeco:opencv:4.5.5-1.5.7'
    }
    

    Basic Camera Capture Example

    import org.bytedeco.javacpp.*
    import org.bytedeco.javacv.*
    import org.bytedeco.opencv.opencv_core.*
    import static org.bytedeco.opencv.global.opencv_imgproc.*
    import static org.bytedeco.opencv.global.opencv_imgcodecs.*
    
    // Basic camera capture example
    def captureCamera() {
        // Initialize frame grabber
        def grabber = FrameGrabber.createDefault(0) // 0 is typically the default camera
        grabber.start()
    
        // Create a window to display the camera feed
        def canvas = new CanvasFrame("Camera Feed")
        canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE)
    
        while (canvas.isVisible()) {
            // Grab a frame
            def frame = grabber.grab()
    
            // Convert to OpenCV Mat for processing
            def image = new Java2DFrameConverter().convert(frame)
            def mat = new Java2DFrameConverter().convertToMat(frame)
    
            // Display the frame
            canvas.showImage(frame)
        }
    
        grabber.stop()
        canvas.dispose()
    }
    
    // Run the example
    captureCamera()
    

    Motion Detection System

    Here's a more advanced example that detects motion:

    import org.bytedeco.javacpp.*
    import org.bytedeco.javacv.*
    import org.bytedeco.opencv.opencv_core.*
    import static org.bytedeco.opencv.global.opencv_imgproc.*
    import static org.bytedeco.opencv.global.opencv_imgcodecs.*
    import static org.bytedeco.opencv.global.opencv_videoio.*
    import static org.bytedeco.opencv.global.opencv_core.*
    
    class MotionDetector {
        private FrameGrabber grabber
        private CanvasFrame canvas
        private Mat previousFrame
        private Mat currentFrame
        private Mat differenceFrame
        private boolean running = false
        private int motionThreshold = 5000 // Adjust based on your needs
        private int minContourArea = 1000   // Minimum area to consider as motion
    
        void startDetection() {
            try {
                grabber = FrameGrabber.createDefault(0)
                grabber.start()
    
                canvas = new CanvasFrame("Motion Detection")
                canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE)
    
                running = true
    
                // Initialize matrices
                previousFrame = new Mat()
                currentFrame = new Mat()
                differenceFrame = new Mat()
    
                while (running && canvas.isVisible()) {
                    def frame = grabber.grab()
    
                    if (frame == null) {
                        continue
                    }
    
                    // Convert frame to Mat
                    def converter = new Java2DFrameConverter()
                    converter.convertToMat(frame, currentFrame)
    
                    // Convert to grayscale
                    def grayCurrent = new Mat()
                    cvtColor(currentFrame, grayCurrent, COLOR_BGR2GRAY)
                    GaussianBlur(grayCurrent, grayCurrent, new Size(21, 21), 0)
    
                    if (!previousFrame.empty()) {
                        // Calculate absolute difference between frames
                        def grayPrevious = new Mat()
                        cvtColor(previousFrame, grayPrevious, COLOR_BGR2GRAY)
                        GaussianBlur(grayPrevious, grayPrevious, new Size(21, 21), 0)
    
                        absdiff(grayPrevious, grayCurrent, differenceFrame)
    
                        // Threshold the difference
                        threshold(differenceFrame, differenceFrame, 25, 255, THRESH_BINARY)
    
                        // Find contours
                        def contours = new ArrayList<Mat>()
                        def hierarchy = new Mat()
                        findContours(differenceFrame, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE)
    
                        // Draw contours and detect motion
                        def motionDetected = false
                        for (Mat contour in contours) {
                            def area = contourArea(contour)
                            if (area > minContourArea) {
                                motionDetected = true
                                def rect = boundingRect(contour)
                                rectangle(currentFrame,
                                        new Point(rect.x(), rect.y()),
                                        new Point(rect.x() + rect.width(), rect.y() + rect.height()),
                                        new Scalar(0, 255, 0, 0), 2)
                            }
                        }
    
                        if (motionDetected) {
                            putText(currentFrame, "Motion Detected",
                                    new Point(10, 30),
                                    FONT_HERSHEY_SIMPLEX, 0.8,
                                    new Scalar(0, 0, 255, 0), 2)
                            println("Motion detected at ${new Date()}")
                        }
                    }
    
                    // Update previous frame
                    currentFrame.copyTo(previousFrame)
    
                    // Display the frame
                    canvas.showImage(converter.convert(currentFrame))
                }
            } catch (Exception e) {
                e.printStackTrace()
            } finally {
                stopDetection()
            }
        }
    
        void stopDetection() {
            running = false
            if (grabber != null) {
                try {
                    grabber.stop()
                } catch (Exception e) {
                    e.printStackTrace()
                }
            }
            if (canvas != null) {
                canvas.dispose()
            }
        }
    }
    
    // Usage
    def detector = new MotionDetector()
    detector.startDetection()
    

    Object Tracking with Background Subtraction

    For more robust detection, you can use background subtraction:

    import org.bytedeco.javacpp.*
    import org.bytedeco.javacv.*
    import org.bytedeco.opencv.opencv_core.*
    import org.bytedeco.opencv.opencv_video.*
    import static org.bytedeco.opencv.global.opencv_imgproc.*
    import static org.bytedeco.opencv.global.opencv_video.*
    import static org.bytedeco.opencv.global.opencv_core.*
    
    class ObjectTracker {
        private FrameGrabber grabber
        private CanvasFrame canvas
        private BackgroundSubtractorMOG2 bgSubtractor
        private boolean running = false
        private int minArea = 1000
    
        void startTracking() {
            try {
                grabber = FrameGrabber.createDefault(0)
                grabber.start()
    
                canvas = new CanvasFrame("Object Tracking")
                canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE)
    
                bgSubtractor = createBackgroundSubtractorMOG2()
                running = true
    
                while (running && canvas.isVisible()) {
                    def frame = grabber.grab()
                    if (frame == null) continue
    
                    def converter = new Java2DFrameConverter()
                    def mat = converter.convertToMat(frame)
    
                    // Apply background subtraction
                    def fgMask = new Mat()
                    bgSubtractor.apply(mat, fgMask)
    
                    // Find contours
                    def contours = new ArrayList<Mat>()
                    def hierarchy = new Mat()
                    findContours(fgMask, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE)
    
                    // Draw bounding boxes around detected objects
                    for (Mat contour in contours) {
                        def area = contourArea(contour)
                        if (area > minArea) {
                            def rect = boundingRect(contour)
                            rectangle(mat,
                                    new Point(rect.x(), rect.y()),
                                    new Point(rect.x() + rect.width(), rect.y() + rect.height()),
                                    new Scalar(0, 255, 0, 0), 2)
    
                            // Track object movement
                            println("Object detected at (${rect.x()}, ${rect.y()}) with size ${rect.width()}x${rect.height()}")
                        }
                    }
    
                    // Display the frame
                    canvas.showImage(converter.convert(mat))
                }
            } catch (Exception e) {
                e.printStackTrace()
            } finally {
                stopTracking()
            }
        }
    
        void stopTracking() {
            running = false
            if (grabber != null) {
                try {
                    grabber.stop()
                } catch (Exception e) {
                    e.printStackTrace()
                }
            }
            if (canvas != null) {
                canvas.dispose()
            }
        }
    }
    
    // Usage
    def tracker = new ObjectTracker()
    tracker.startTracking()
    

    Event Handling for Object Entry/Exit

    To specifically detect when objects enter or leave the view:

    class ObjectEntryExitDetector {
        private FrameGrabber grabber
        private CanvasFrame canvas
        private BackgroundSubtractorMOG2 bgSubtractor
        private boolean running = false
        private int minArea = 1000
        private Map<Integer, Point> trackedObjects = [:]
        private int nextId = 1
    
        void startDetection() {
            try {
                grabber = FrameGrabber.createDefault(0)
                grabber.start()
    
                canvas = new CanvasFrame("Object Entry/Exit Detection")
                canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE)
    
                bgSubtractor = createBackgroundSubtractorMOG2()
                running = true
    
                while (running && canvas.isVisible()) {
                    def frame = grabber.grab()
                    if (frame == null) continue
    
                    def converter = new Java2DFrameConverter()
                    def mat = converter.convertToMat(frame)
    
                    // Apply background subtraction
                    def fgMask = new Mat()
                    bgSubtractor.apply(mat, fgMask)
    
                    // Find contours
                    def contours = new ArrayList<Mat>()
                    def hierarchy = new Mat()
                    findContours(fgMask, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE)
    
                    // Process detected objects
                    def currentObjects = [:]
                    for (Mat contour in contours) {
                        def area = contourArea(contour)
                        if (area > minArea) {
                            def rect = boundingRect(contour)
                            def center = new Point(
                                rect.x() + rect.width() / 2,
                                rect.y() + rect.height() / 2
                            )
    
                            // Find closest existing object or create new
                            def closestId = findClosestObject(center)
                            if (closestId) {
                                currentObjects[closestId] = center
                            } else {
                                def newId = nextId++
                                currentObjects[newId] = center
                                println("New object entered: ID $newId at ($center.x(), $center.y())")
                            }
    
                            // Draw tracking info
                            rectangle(mat, rect.tl(), rect.br(), new Scalar(0, 255, 0, 0), 2)
                            putText(mat, "ID: $closestId", rect.tl(),
                                    FONT_HERSHEY_SIMPLEX, 0.5, new Scalar(0, 0, 255, 0), 1)
                        }
                    }
    
                    // Detect objects that have left
                    trackedObjects.each { id, point ->
                        if (!currentObjects.containsKey(id)) {
                            println("Object exited: ID $id")
                        }
                    }
    
                    trackedObjects = currentObjects
    
                    // Display the frame
                    canvas.showImage(converter.convert(mat))
                }
            } catch (Exception e) {
                e.printStackTrace()
            } finally {
                stopDetection()
            }
        }
    
        private Integer findClosestObject(Point newPoint) {
            def closestId = null
            def minDistance = Double.MAX_VALUE
    
            trackedObjects.each { id, point ->
                def distance = Math.sqrt(
                    Math.pow(newPoint.x() - point.x(), 2) +
                    Math.pow(newPoint.y() - point.y(), 2)
                )
                if (distance < minDistance && distance < 50) { // 50 pixel threshold
                    minDistance = distance
                    closestId = id
                }
            }
    
            return closestId
        }
    
        void stopDetection() {
            running = false
            if (grabber != null) {
                try {
                    grabber.stop()
                } catch (Exception e) {
                    e.printStackTrace()
                }
            }
            if (canvas != null) {
                canvas.dispose()
            }
        }
    }
    
    // Usage
    def detector = new ObjectEntryExitDetector()
    detector.startDetection()
    

    Tips for Implementation

    1. Performance Considerations:

      • Adjust the frame size if processing is too slow
      • Tune the background subtractor parameters for your environment
      • Consider using a separate thread for processing
    2. Environment Setup:

      • Ensure proper lighting conditions
      • Minimize background movement
      • Calibrate the system for your specific use case
    3. Advanced Features:

      • Add object classification using machine learning
      • Implement tracking algorithms like Kalman filters
      • Add logging or database storage for detected events
    4. Error Handling:

      • Add proper exception handling for camera access
      • Implement graceful shutdown procedures
      • Add validation for camera input

    These examples provide a foundation for building a vision system in Groovy to detect items moving into and out of view. You can extend them with additional features as needed for your specific application.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.