ContinuousCapture.java

The ContinuousCapture program is a simple example for a continuous acquisition.

Program location

The source file ContinuousCapture.java can be found under:

%INSTALLDIR%\apps\Java\ContinuousCapture\

Note

If you have installed the package without example applications, this file will not be available. On Windows® the sample application can be installed or removed from the target system at any time by simply restarting the installation package.

ContinuousCapture example:

1. Opens a Balluff device.
2. Snaps images continuously (without display using Linux).

Console Output

[0]: BF000306 (mvBlueFOX-202C, Family: mvBlueFOX, interface layout: DeviceSpecific)

Please enter the number in front of the listed device followed by [ENTER] to open it: 0
Using device number 0.
Press [ENTER] to end the application
Initialising the device. This might take some time...
Info from BF000306: FramesPerSecond: 28.655660, ErrorCount: 0, CaptureTime_s: 0.104195
Info from BF000306: FramesPerSecond: 28.655636, ErrorCount: 0, CaptureTime_s: 0.104017
Info from BF000306: FramesPerSecond: 28.655659, ErrorCount: 0, CaptureTime_s: 0.104153
Info from BF000306: FramesPerSecond: 28.655636, ErrorCount: 0, CaptureTime_s: 0.104072
Info from BF000306: FramesPerSecond: 28.655660, ErrorCount: 0, CaptureTime_s: 0.104234

How it works

The continuous acquisition starts a separate thread (CaptureThread.java) that continuously requests images from the device.

First of all the user is prompted to select the device he wants to use for this sample:

DeviceManager devMgr = new DeviceManager();
Device pDev = mvIMPACT.acquire.examples.helper.DeviceAccess.getDeviceFromUserInput( devMgr );

Then after the device has been initialized successfully a continuous acquisition is started in CaptureThread.java.

Accessing the pRequest object can be done after it has been checked using the mvIMPACT.acquire.Request.isOK() function. The image attached to the request can then be processed and/or displayed if the request does not report an error.

requestNr = fi.imageRequestWaitFor( timeout_ms );
pRequest = fi.isRequestNrValid( requestNr ) ? fi.getRequest( requestNr ) : null;
if ( pRequest != null )
{
   if ( pRequest.isOK() 
   {
      ...
   }
}
else
{
  System.out.println( "Error: " + pRequest.getRequestResult().readS() );
}

Source code

CaptureThread.java

import mvIMPACT.acquire.*;
 
public class CaptureThread extends Thread
{
    //=============================================================================
    //=== private static member variables =========================================
    //=============================================================================
    private static final boolean isWindows_ = System.getProperty( "os.name" ).startsWith( "Windows" );
 
    //=============================================================================
    //=== private member variables ================================================
    //=============================================================================
    private Device pDev_;
    //private ImageDisplayWindow window_; // Windows only but there is no such thing as #ifdef in Java!
    private boolean terminated_ = false;
 
    //=============================================================================
    //=== public constructor ======================================================
    //=============================================================================
    //-----------------------------------------------------------------------------
    public CaptureThread( Device pDev )
    //-----------------------------------------------------------------------------
    {
        pDev_ = pDev;
        //window_ = new ImageDisplayWindow( "mvIMPACT_acquire sample, Device " + pDev.getSerial().read() );
    }
 
    //=============================================================================
    //=== public member functions =================================================
    //=============================================================================
    //-----------------------------------------------------------------------------
    public void run()
    //-----------------------------------------------------------------------------
    {
        if( isWindows_ )
        {
            System.out.println( "\n\nSince you are running on a Windows platform you could use the display module belonging to this SDK. To try this simply remove the comments wherever the 'window_' variable is used. As Java does not support something like '#ifdef' we did not come up with anything smarter. Suggestions welcome!!!\n\n" );
        }
 
        // establish access to the statistic properties
        Statistics statistics = new Statistics( pDev_ );
        // create an interface to the device found
        FunctionInterface fi = new FunctionInterface( pDev_ );
 
        // Send all requests to the capture queue. There can be more than 1 queue for some devices, but for this sample
        // we will work with the default capture queue. If a device supports more than one capture or result
        // queue, this will be stated in the manual. If nothing is mentioned about it, the device supports one
        // queue only. This loop will send all requests currently available to the driver. To modify the number of requests
        // use the property mvIMPACT.acquire.SystemSettings.requestCount at runtime or the property
        // mvIMPACT.acquire.Device.defaultRequestCount BEFORE opening the device.
        int result = TDMR_ERROR.DMR_NO_ERROR;
        while( ( result = fi.imageRequestSingle() ) == TDMR_ERROR.DMR_NO_ERROR ) { };
        if( result != TDMR_ERROR.DEV_NO_FREE_REQUEST_AVAILABLE )
        {
            System.out.println( String.format( "'FunctionInterface.imageRequestSingle' returned with an unexpected result: %d(%s)", result, ImpactAcquireException.getErrorCodeAsString( result ) ) );
        }
 
        mvIMPACT.acquire.examples.helper.DeviceAccess.manuallyStartAcquisitionIfNeeded( pDev_, fi );
        // run thread loop
        Request pRequest = null;
        // we always have to keep at least 2 images as the display module might want to repaint the image, thus we
        // cannot free it unless we have a assigned the display to a new buffer.
        Request pPreviousRequest = null;
        int timeout_ms = 500;
        int cnt = 0;
        int requestNr = acquire.getINVALID_ID();
        while( !terminated_ )
        {
            // wait for results from the default capture queue
            requestNr = fi.imageRequestWaitFor( timeout_ms );
            pRequest = fi.isRequestNrValid( requestNr ) ? fi.getRequest( requestNr ) : null;
            if( pRequest != null )
            {
                if( pRequest.isOK() )
                {
                    ++cnt;
                    // here we can display some statistical information every 100th image
                    if( cnt % 100 == 0 )
                    {
                        System.out.println( String.format( "Info from %s: %s: %s, %s: %s, %s: %s", pDev_.getSerial().read(),
                                                           statistics.getFramesPerSecond().name(), statistics.getFramesPerSecond().readS(),
                                                           statistics.getErrorCount().name(), statistics.getErrorCount().readS(),
                                                           statistics.getCaptureTime_s().name(), statistics.getCaptureTime_s().readS() ) );
                    }
                    //window_.GetImageDisplay().SetImage( pRequest );
                    //window_.GetImageDisplay().Update();
                }
                else
                {
                    System.out.println( "Error: " + pRequest.getRequestResult().readS() );
                }
                if( pPreviousRequest != null )
                {
                    // this image has been displayed thus the buffer is no longer needed...
                    pPreviousRequest.unlock();
                }
                pPreviousRequest = pRequest;
                // send a new image request into the capture queue
                fi.imageRequestSingle();
            }
            //else
            //{
            // Please note that slow systems or interface technologies in combination with high resolution sensors
            // might need more time to transmit an image than the timeout value which has been passed to imageRequestWaitFor().
            // If this is the case simply wait multiple times OR increase the timeout(not recommended as usually not necessary
            // and potentially makes the capture thread less responsive) and rebuild this application.
            // Once the device is configured for triggered image acquisition and the timeout elapsed before
            // the device has been triggered this might happen as well.
            // The return code would be -2119(DEV_WAIT_FOR_REQUEST_FAILED) in that case, the documentation will provide
            // additional information under TDMR_ERROR in the interface reference.
            // If waiting with an infinite timeout(-1) it will be necessary to call 'imageRequestReset' from another thread
            // to force 'imageRequestWaitFor' to return when no data is coming from the device/can be captured.
            // System.out.println("imageRequestWaitFor failed (%d, %s), timeout value too small?", requestNr, ImpactAcquireException.getErrorCodeAsString(requestNr));
            //}
        }
        mvIMPACT.acquire.examples.helper.DeviceAccess.manuallyStopAcquisitionIfNeeded( pDev_, fi );
 
        // stop the display from showing freed memory
        //window_.GetImageDisplay().RemoveImage();
 
        // In this sample all the next lines are redundant as the device driver will be
        // closed now, but in a real world application a thread like this might be started
        // several times an then it becomes crucial to clean up correctly.
 
        // free the last potentially locked request
        if( pRequest != null )
        {
            pRequest.unlock();
        }
        // clear all queues
        fi.imageRequestReset( 0, 0 );
    }
 
    //-----------------------------------------------------------------------------
    public void terminate()
    //-----------------------------------------------------------------------------
    {
        terminated_ = true;
    }
}

ContinuousCapture.java

import mvIMPACT.acquire.*;
 
//-----------------------------------------------------------------------------
public class ContinuousCapture
//-----------------------------------------------------------------------------
{
    //=============================================================================
    //=== Static member functions =================================================
    //=============================================================================
    static
    {
        try
        {
            System.loadLibrary( "mvIMPACT_Acquire.java" );
        }
        catch( UnsatisfiedLinkError e )
        {
            System.err.println( "Native code library failed to load. Make sure the 'mvIMPACT_Acquire.java' library can be found in the systems search path.\n" + e );
            System.exit( 1 );
        }
    }
 
    //-----------------------------------------------------------------------------
    public static void main( String[] args )
    //-----------------------------------------------------------------------------
    {
        DeviceManager devMgr = new DeviceManager();
        Device pDev = mvIMPACT.acquire.examples.helper.DeviceAccess.getDeviceFromUserInput( devMgr );
        if( pDev == null )
        {
            System.out.print( "Unable to continue! " );
            mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
            System.exit( 1 );
        }
 
        System.out.println( "Initialising the device. This might take some time..." );
        try
        {
            pDev.open();
        }
        catch( ImpactAcquireException e )
        {
            // this e.g. might happen if the same device is already opened in another process...
            System.out.println( "An error occurred while opening device " + pDev.getSerial().read() +
                                "(error code: " + e.getMessage() + ")." );
            mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
            System.exit( 1 );
        }
 
        CaptureThread captureThread = new CaptureThread( pDev );
        captureThread.start();
        mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
        captureThread.terminate();
        try
        {
            captureThread.join();
        }
        catch( Exception e )
        {
            System.out.println( e.getMessage() );
        }
    }
}