//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
//-----------------------------------------------------------------------------
{
    DeviceManager devMgr;
    cout << "This sample is meant for mvBlueLYNX-M7 devices only. Other devices might be installed" << endl
         << "but won't be recognized by the application." << endl
         << endl;

    int exposureTime_us = 20000;
    int frameRate_Hz = 5;
    int width = -1;
    int height = -1;
    int interPacketDelay = 25;

    // scan command line
    if( argc > 1 )
    {
        for( int i = 1; i < argc; i++ )
        {
            string param( argv[i] ), key, value;
            string::size_type keyEnd = param.find_first_of( "=" );
            if( ( keyEnd == string::npos ) || ( keyEnd == param.length() - 1 ) )
            {
                cout << "Invalid command line parameter: '" << param << "' (ignored)." << endl;
            }
            else
            {
                key = param.substr( 0, keyEnd );
                value = param.substr( keyEnd + 1 );
                if( ( key == "exposureTime" ) || ( key == "et" ) )
                {
                    exposureTime_us = static_cast<int>( atoi( value.c_str() ) );
                }
                else if( ( key == "frameRate" ) || ( key == "fr" ) )
                {
                    frameRate_Hz = static_cast<int>( atoi( value.c_str() ) );
                }
                else if( ( key == "width" ) || ( key == "w" ) )
                {
                    width = static_cast<int>( atoi( value.c_str() ) );
                }
                else if( ( key == "height" ) || ( key == "h" ) )
                {
                    height = static_cast<int>( atoi( value.c_str() ) );
                }
                else if( key == "scpd" )
                {
                    interPacketDelay = static_cast<int>( atoi( value.c_str() ) );
                }
                else
                {
                    cout << "Invalid command line parameter: '" << param << "' (ignored)." << endl;
                }
            }
        }
    }
    else
    {
        cout << "No command line parameters specified. Available parameters:" << endl
             << "  'frameRate' or 'fr' to specify the frame rate(frames per second per sensor head) of the resulting data stream" << endl
             << "  'exposureTime' or 'et' to specifiy the exposure time per frame in us" << endl
             << "  'width' or 'w' to specifiy the width of the AOI" << endl
             << "  'height' or 'h' to specifiy the height of the AOI" << endl
             << endl
             << "USAGE EXAMPLE:" << endl
             << "  SynchronousCaptureMultipleInputs et=5000 frameRate=5" << endl << endl;
    }

    Device* pDev = getDeviceFromUserInput( devMgr, isDeviceSupportedBySample );
    if( !pDev )
    {
        cout << "Unable to continue!";
        cout << "Press [ENTER] to end the application" << endl;
        cin.get();
        return 0;
    }

    try
    {
        cout << "Please note, that this sample (depending on the selected frame rate and resolution) might require a lot" << endl
             << "of network bandwidth, thus to achieve optimal results, it's crucial to have" << endl
             << "  - a good, reliable network controller (we recommed the Intel PRO/1000 series)" << endl
             << "  - the latest driver for the network controller installed" << endl
             << "  - jumbo frames enabled and the receive and transmit buffer for the network controller set to max. values" << endl
             << "  - the InterfaceMTU on the mvBlueLYNX-M7 set to its maximum value" << endl
             << endl
             << "In case of 'rrFrameIncomplete' errors the reason is most certainly to be found in one of"
             << "the requirments listed above not being met."
             << endl;

        cout << "Will try to synchronize sensor heads(" << frameRate_Hz << " fps per head with " << exposureTime_us << "us exposure time per frame) now" << endl
             << "During this operation the device will be initialised. This might take some time..." << endl;

        Connector connector( pDev );
        CameraSettingsBlueCOUGAR cs( pDev );
        try
        {
            if( width != -1 )
            {
                cs.aoiWidth.write( width );
            }
            if( height != -1 )
            {
                cs.aoiHeight.write( height );
            }
        }
        catch( const ImpactAcquireException& e )
        {
            cout << "Failed to set up AOI: " << e.getErrorString() << "(" << e.getErrorCodeAsString() << ")" << endl;
        }
        const int SENSOR_HEAD_COUNT = connector.videoChannel.read( plMaxValue ) + 1;
        setupHRTC( pDev, frameRate_Hz, exposureTime_us, SENSOR_HEAD_COUNT );

        // initialise display windows
        // IMPORTANT: It's NOT save to create multiple display windows in multiple threads!!!
        ThreadParameter threadParam( pDev, SENSOR_HEAD_COUNT );
        DeviceComponentLocator locator( pDev, dltSystemSettings );
        PropertyI64 gevStreamChannelSelector;
        locator.bindComponent( gevStreamChannelSelector, "GevStreamChannelSelector" );
        PropertyI64 gevSCPD;
        locator.bindComponent( gevSCPD, "GevSCPD" );
        for( int i = 0; i < SENSOR_HEAD_COUNT; i++ )
        {
            gevStreamChannelSelector.write( i );
            gevSCPD.write( interPacketDelay );
            MyWindow* p = createWindow( cs.aoiWidth.read(), cs.aoiHeight.read() );
            p->show();
            p->callback( windowCallback );
            threadParam.displayData.push_back( new DisplayInfo( p ) );
        }

        // start the execution of the 'live' thread.
        cout << "Close any of the display windows to end the application" << endl;
        liveLoop( &threadParam );
        vector<DisplayInfo*>::size_type displayCount = threadParam.displayData.size();
        for( vector<DisplayInfo*>::size_type i = 0; i < displayCount; i++ )
        {
            delete threadParam.displayData[i]->pDisp;
            delete threadParam.displayData[i];
            threadParam.displayData[i] = 0;
        }
    }
    catch( const ImpactAcquireException& e )
    {
        // this e.g. might happen if the same device is already opened in another process...
        cout << "An error occurred while configuring device " << pDev->serial.read()
             << "(error code: " << e.getErrorCodeAsString() << "). Press [ENTER] to end the application..." << endl;
        cin.get();
    }
    return 0;
}
Ejemplo n.º 2
0
//-----------------------------------------------------------------------------
unsigned int liveLoop( Device* pDev, bool boStoreFrames, const string& settingName, int iWidth, int iHeight, bool boSingleShotMode )
//-----------------------------------------------------------------------------
{
    cout << " == " << __FUNCTION__ << " - establish access to the statistic properties...." << endl;
    // establish access to the statistic properties
    Statistics statistics( pDev );
    cout << " == " << __FUNCTION__ << " - create an interface to the device found...." << endl;
    // create an interface to the device found
    FunctionInterface fi( pDev );

    if( !settingName.empty() )
    {
        cout << "Trying to load setting " << settingName << "..." << endl;
        int result = fi.loadSetting( settingName );
        if( result != DMR_NO_ERROR )
        {
            cout << "loadSetting( \"" << settingName << "\" ); call failed: " << ImpactAcquireException::getErrorCodeAsString( result ) << endl;
        }
    }

    // depending on the device and its sensor, we set an appropriate output format for displaying
    mvIMPACT::acquire::ImageDestination id( pDev );

    if( !std::string( "mvBlueFOX" ).compare( pDev->family.readS() ) )
    {
        mvIMPACT::acquire::InfoBlueFOX ibf( pDev );
        if( !std::string( "BayerMosaic" ).compare( ibf.sensorColorMode.readS() ) )
        {
            id.pixelFormat.writeS( "BGR888Packed" );
        }
    }
    else if( !std::string( "mvBlueCOUGAR" ).compare( pDev->family.readS() ) )
    {
        mvIMPACT::acquire::GenICam::ImageFormatControl ifc( pDev );
        if( s_boGreySensor )
        {
            ifc.pixelFormat.writeS( "Mono8" );
        }
        else
        {
            GenICamDeviceSetColorPixelFormat( pDev );
            id.pixelFormat.writeS( "BGR888Packed" );
        }
    }
    else if( !std::string( "mvBlueLYNX" ).compare( pDev->family.readS() ) )
    {
        mvIMPACT::acquire::GenICam::ImageFormatControl ifc( pDev );
        if( s_boGreySensor )
        {
            ifc.pixelFormat.writeS( "Mono8" );
        }
        else
        {
            GenICamDeviceSetColorPixelFormat( pDev );
            id.pixelFormat.writeS( "BGR888Packed" );
        }
    }

    // Pre-fill the capture queue with ALL buffers currently available. In case the acquisition engine is operated
    // manually, buffers can only be queued when they have been queued before the acquisition engine is started as well.
    // Even though there can be more than 1, for this sample we will work with the default capture queue
    int requestResult = DMR_NO_ERROR;
    int requestCount = 0;

    if( boSingleShotMode )
    {
        fi.imageRequestSingle();
        ++requestCount;
    }
    else
    {
        while( ( requestResult = fi.imageRequestSingle() ) == DMR_NO_ERROR )
        {
            ++requestCount;
        }
    }

    if( requestResult != DEV_NO_FREE_REQUEST_AVAILABLE )
    {
        cout << "Last result: " << requestResult << "(" << ImpactAcquireException::getErrorCodeAsString( requestResult ) << "), ";
    }
    cout << requestCount << " buffers requested";
    SystemSettings ss( pDev );
    if( ss.requestCount.hasMaxValue() )
    {
        cout << ", max request count: " << ss.requestCount.getMaxValue();
    }
    cout << endl;

    cout << "Press <<ENTER>> to end the application!!" << endl;

    MyWindow* pWindow = createWindow( iWidth, iHeight );
    pWindow->show();
    pWindow->callback( windowCallback );

    manuallyStartAcquisitionIfNeeded( pDev, fi );
    // run thread loop
    const Request* pRequest = 0;
    const unsigned int timeout_ms = 8000;   // USB 1.1 on an embedded system needs a large timeout for the first image
    int requestNr = -1;
    bool boLoopRunning = true;
    unsigned int cnt = 0;
    while( boLoopRunning )
    {
        // wait for results from the default capture queue
        requestNr = fi.imageRequestWaitFor( timeout_ms );
        if( fi.isRequestNrValid( requestNr ) )
        {
            pRequest = fi.getRequest( requestNr );
            if( pRequest->isOK() )
            {
                ++cnt;
                // here we can display some statistical information every 20th image
                if( cnt % 20 == 0 )
                {

                    ostringstream out;
                    out << pDev->serial.read() << ": " << statistics.framesPerSecond.name() << ": " << statistics.framesPerSecond.readS();
                    pWindow->setOverlayString( out.str() );

                    cout << cnt << ": Info from " << pDev->serial.read()
                         << ": " << statistics.framesPerSecond.name() << ": " << statistics.framesPerSecond.readS()
                         << ", " << statistics.errorCount.name() << ": " << statistics.errorCount.readS()
                         << ", " << statistics.captureTime_s.name() << ": " << statistics.captureTime_s.readS()
                         << " Image count: " << cnt
                         << " (dimensions: " << pRequest->imageWidth.read() << "x" << pRequest->imageHeight.read() << ", format: " << pRequest->imagePixelFormat.readS();
                    if( pRequest->imageBayerMosaicParity.read() != bmpUndefined )
                    {
                        cout << ", " << pRequest->imageBayerMosaicParity.name() << ": " << pRequest->imageBayerMosaicParity.readS();
                    }
                    cout << ")" << endl;
                }
                // here we can store an image every 100th frame
                if( boStoreFrames && ( cnt % 100 == 0 ) )
                {
                    ostringstream oss;
                    oss << "Image" << cnt << "." << pRequest->imageWidth.read() << "x" << pRequest->imageHeight.read() << "." << pRequest->imagePixelFormat.readS();
                    if( pRequest->imageBayerMosaicParity.read() != bmpUndefined )
                    {
                        oss << "(BayerPattern=" << pRequest->imageBayerMosaicParity.readS() << ")";
                    }
                    oss << ".raw";
                    FILE* fp = fopen( oss.str().c_str(), "wb" );
                    if( fp )
                    {
                        unsigned char* pImageData = ( unsigned char* ) pRequest->imageData.read();
                        for( int h = 0; h < pRequest->imageHeight.read(); h++ )
                        {
                            // write one line
                            fwrite( pImageData, pRequest->imageWidth.read(), pRequest->imageBytesPerPixel.read(), fp );
                            // respect image line pitch
                            pImageData += pRequest->imageLinePitch.read();
                        }
                        fclose( fp );
                    }
                }

                // everything went well. Display the result
                pWindow->NewRequest( pRequest );
                pWindow->redraw();
                Fl::check();
            }
            else
            {
                cout << "*** Error: A request has been returned with the following result: " << pRequest->requestResult << endl;
            }

            // this image has been displayed thus the buffer is no longer needed...
            fi.imageRequestUnlock( requestNr );
            // send a new image request into the capture queue
            fi.imageRequestSingle();
            if( boSingleShotMode )
            {
                manuallyStartAcquisitionIfNeeded( pDev, fi );
            }
        }
        else
        {
            cout << "*** Error: Result of waiting for a finished request: " << requestNr << "("
                 << ImpactAcquireException::getErrorCodeAsString( requestNr ) << "). Timeout value too small?" << endl;
        }

        boLoopRunning = waitForInput( 0, STDOUT_FILENO ) == 0 ? true : false; // break by STDIN
        // Exit when window was cloesd
        if( s_boTerminated )
        {
            break;
        }
    }

    if( !boSingleShotMode )
    {
        manuallyStopAcquisitionIfNeeded( pDev, fi );
    }
    cout << " == " << __FUNCTION__ << " - free resources...." << endl;
    // free resources
    fi.imageRequestReset( 0, 0 );
    return 0;
}