ExceptionHandling.cpp

ExceptionHandling.cpp shows the catching of an exception in Spinnaker. Following this, check out the Acquisition or NodeMapInfo examples if you haven't already. Acquisition demonstrates image acquisition while NodeMapInfo explores retrieving information from various node types.

This example shows three typical paths of exception handling in Spinnaker: catching the exception as a Spinnaker exception, as a standard exception, or as a standard exception which is then cast to a Spinnaker exception.

Once comfortable with Acquisition, ExceptionHandling, and NodeMapInfo, we suggest checking out AcquisitionMultipleCamera, NodeMapCallback, or SaveToAvi. AcquisitionMultipleCamera demonstrates simultaneously acquiring images from a number of cameras, NodeMapCallback serves as a good introduction to programming with callbacks and events, and SaveToAvi exhibits video creation.

//=============================================================================
// Copyright (c) 2001-2021 FLIR Systems, Inc. All Rights Reserved.
//
// This software is the confidential and proprietary information of FLIR
// Integrated Imaging Solutions, Inc. ("Confidential Information"). You
// shall not disclose such Confidential Information and shall use it only in
// accordance with the terms of the license agreement you entered into
// with FLIR Integrated Imaging Solutions, Inc. (FLIR).
//
// FLIR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
// SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE, OR NON-INFRINGEMENT. FLIR SHALL NOT BE LIABLE FOR ANY DAMAGES
// SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
// THIS SOFTWARE OR ITS DERIVATIVES.
//=============================================================================

#include "Spinnaker.h"
#include "SpinGenApi/SpinnakerGenApi.h"
#include <iostream>
#include <sstream>

using namespace Spinnaker;
using namespace Spinnaker::GenApi;
using namespace std;

// Use the following enum and global constant to select type of exception
// handling used for the example.
enum exceptionType
{
    SPINNAKER_EXCEPTION,
    STANDARD_EXCEPTION,
    STANDARD_CAST_TO_SPINNAKER
};

const exceptionType chosenException = SPINNAKER_EXCEPTION;

// This helper function causes a Spinnaker exception by still holding a camera
// reference while attempting to release the system.
void causeSpinnakerException()
{
    // Retrieve singleton reference to system object
    SystemPtr system = System::GetInstance();

    // Print out current library version
    const LibraryVersion spinnakerLibraryVersion = system->GetLibraryVersion();
    cout << "Spinnaker library version: " << spinnakerLibraryVersion.major << "." << spinnakerLibraryVersion.minor
         << "." << spinnakerLibraryVersion.type << "." << spinnakerLibraryVersion.build << endl
         << endl;

    cout << "System retrieved..." << endl;

    //
    // Retrieve list of cameras from the system
    //
    // *** NOTES ***
    // Retrieving this camera list without clearing it is the cause of the
    // -1004 RESOURCES_IN_USE exception when the example is run.
    //
    CameraList cameraList = system->GetCameras();

    cout << "Camera list retrieved..." << endl;

    // The exception will only be thrown if no cameras are connected
    if (cameraList.GetSize() == 0)
    {
        cout << endl << "Not enough cameras!" << endl << endl;

        return;
    }

    //
    // Release system
    //
    // *** NOTES ***
    // One of the requirements of cleanly releasing a system object is that
    // all references to resources are released first. In this example, the
    // cameras referenced by the camera list are still present.
    //
    system->ReleaseInstance();

    cout << "System released; this part of the code should not be reached..." << endl << endl;
}

// This helper function causes a standard exception by attempting to access an
// member of a vector that is out of range.
void causeStandardException()
{
    const int k_maxNum = 10;
    vector<int> numbers;

    // The vector is initialized with 10 members, from indexes 0 to 9.
    for (int i = 0; i < k_maxNum; i++)
    {
        numbers.push_back(i);
    }

    cout << "Vector initialized..." << endl << endl;

    // The number attempting to be called here is index 10, or the 11th member,
    // which throws an out-of-range exception.
    cout << "The highest number in the vector is " << numbers.at(k_maxNum) << ".";
}

// Example entry point; this function demonstrates the handling of a variety
// of exception use-cases.
int main(int /*argc*/, char** /*argv*/)
{
    // Print application build information
    cout << "Application build date: " << __DATE__ << " " << __TIME__ << endl << endl;

    // Cause and catch an exception.
    switch (chosenException)
    {
        //
        // Catch a Spinnaker exception
        //
        // *** NOTES ***
        // The Spinnaker library has a number of built-in exceptions that
        // provide more information than standard exceptions.
        //
    case SPINNAKER_EXCEPTION:
        try
        {
            causeSpinnakerException();
        }
        catch (Spinnaker::Exception& ex)
        {
            cout << endl << "Spinnaker exception caught." << endl << endl;

            //
            // Print Spinnaker exception
            //
            // *** NOTES ***
            // Spinnaker exceptions are still able to access information using
            // the standard what() method.
            //
            cout << "Error: " << ex.what() << endl;

            //
            // Print additional information available to Spinnaker exceptions
            //
            // *** NOTES ***
            // However, Spinnaker exceptions have additional information. The
            // message below prints out the error code, function name, and line
            // number of the exception; this functionality is not available for
            // standard exceptions.
            //
            cout << "Error code " << ex.GetError() << " raised in function " << ex.GetFunctionName() << " at line "
                 << ex.GetLineNumber() << "." << endl;
        }
        break;

        //
        // Catch a standard exception
        //
        // *** NOTES ***
        // Standard try-catch blocks can catch Spinnaker exceptions, but they
        // provide no access to the additional information available. Spinnaker
        // exceptions, on the other hand, provide
        //
    case STANDARD_EXCEPTION:
        try
        {
            causeStandardException();
        }
        catch (std::exception& ex)
        {
            cout << endl << "Standard exception caught." << endl << endl;

            //
            // Print more information
            //
            // *** NOTES ***
            // The simplest way to catch exceptions in Spinnaker is with
            // standard try-catch blocks. This will catch all exceptions, but
            // sacrifice extra functionality.
            //
            cout << "Error: " << ex.what() << endl;
        }
        break;

        //
        // Catch a standard exception; cast it to a Spinnaker exception.
        //
        // *** NOTES ***
        // Regular exceptions can be cast to Spinnaker exceptions by using a
        // dynamic_cast<>.
        //
    case STANDARD_CAST_TO_SPINNAKER:
        try
        {
            causeSpinnakerException();
        }
        catch (std::exception& ex)
        {
            cout << endl << "Standard exception caught; will be cast as Spinnaker exception." << endl << endl;

            //
            // Wrap the cast in a further try-catch
            //
            // *** NOTES ***
            // The cast needs to be wrapped in a further try-catch block
            // because standard exceptions will fail the cast.
            //
            try
            {
                //
                // Attempt to cast exception as Spinnaker exception
                //
                // *** NOTES ***
                // A successful cast means that the exception is particular to
                // Spinnaker and will keep the flow of control in the try block
                // while a failed cast means that the exception is standard and
                // will push the flow of control into the catch block.
                //
                Spinnaker::Exception& spinEx = dynamic_cast<Spinnaker::Exception&>(ex);

                // Print additional information if Spinnaker exception
                cout << "Error: " << spinEx.GetErrorMessage() << endl;
                cout << "Error code " << spinEx.GetError() << " raised in function " << spinEx.GetFunctionName()
                     << " at line " << spinEx.GetLineNumber() << "." << endl;
            }
            catch (std::exception& stdEx)
            {
                cout << "Cannot cast; not a Spinnaker exception: " << stdEx.what() << endl;

                // Print standard information if standard exception
                cout << "Standard error: " << ex.what() << endl;
            }
        }
    }

    cout << endl << "Done! Press Enter to exit..." << endl;
    getchar();

    return 0;
}