Error Handling

ErrorCode

enum LuxFlux.fluxEngineNET.ErrorCode

fluxEngine Error Code

This enumeration describes the possible error codes that are returned by fluxEngine. Since the .NET API wraps the underlying C API, this list contains the error codes returned by the C API itself.

Any exception thrown by fluxEngine that is a subclass of the Error class will contain one of these codes.

Not all of these codes will be thrown in the form of a Error class, as some of them are mapped onto the standard .NET exception classes.

Values:

Success

Success

This error code will never be returned, but exists in this enumeration for the sake of completeness.

Unknown

Unknown error

If an error occurred that has not yet been categorized with a specific error code, this code will be returned.

AllocationFailure

Allocation failure

This code exists for compatibility with the underlying C API, it will never be returned. (Allocation failures will be reported as OutOfMemoryException.)

InvalidArgument

Invalid argument

If an underlying C API function returns this error code, the error will be thrown as a .NET ArgumentException.

HandleNoLongerValid

Handle no longer valid

If an operation is performed on a handle that has been destroyed, but where the metadata is still kept in memory because one or more models and/or processing contexts have not yet been freed, this error will be returned.

If this error occurs this indicates undefined behavior, as this essentially amounts to a use-after-free of the handle structure.

This error code will always be set in a subclass of Error, ObjectNoLongerValidError, to allow the user to polymorphically catch this kind of error.

See also

ObjectNoLongerValidError

ModelNoLongerValid

The model is no longer valid

If an operation is performed on a model whose handle has already been destroyed, this error will be returned.

In contrast to ErrorCode.HandleNoLongerValid occurring, this is not an indication of undefined behavior.

This error code will always be set in a subclass of Error, ObjectNoLongerValidError, to allow the user to polymorphically catch this kind of error.

See also

ObjectNoLongerValidError

ProcessingContextNoLongerValid

The processing context is no longer valid

If an operation is performed on a model whose handle has already been destroyed, this error will be returned.

It is also possible that this error is returned if the number of processing threads of a given handle was changed after creating the processing context.

In contrast to ErrorCode.HandleNoLongerValid occurring, this is not an indication of undefined behavior.

This error code will always be set in a subclass of Error, ObjectNoLongerValidError, to allow the user to polymorphically catch this kind of error.

See also

ObjectNoLongerValidError

IndexOutOfRange

Index out of range

If an underlying C API function returns this error code, the error will be thrown as a .NET ArgumentOutOfRangeException.

NotImplemented

Not implemented

A specific functionality is not implemented in fluxEngine’s public API (yet).

If an underlying C API function returns this error code, the error will be thrown as a .NET System.NotImplementedException.

InvalidWrapper

Invalid wrapper

The user is attempting to access an object that was already disposed.

If an underlying C API function returns this error code, the error will be thrown as a .NET System.ObjectDisposedException.

FileAccessError

File access error

If an underlying C API function returns this error code, the error will be thrown as a .NET System.IO.IOException.

FileNotFoundError

File not found error

If an underlying C API function returns this error code, the error will be thrown as a .NET System.IO.FileNotFoundException.

FileAccessDeniedError

File access denied error

If an underlying C API function returns this error code, the error will be thrown as a .NET System.IO.IOException.

FileTypeError

File type error

If an underlying C API function returns this error code, the error will be thrown as a .NET System.IO.IOException.

FileInUseError

File in use error

If an underlying C API function returns this error code, the error will be thrown as a .NET System.IO.IOException.

ReadOnlyFilesystem

Read-only filesystem error

If an underlying C API function returns this error code, the error will be thrown as a .NET System.IO.IOException.

IOError

Generic I/O error

If an underlying C API function returns this error code, the error will be thrown as a .NET System.IO.IOException.

HandleAlreadyCreated

A handle has already been created

Current limitations of the fluxEngine library allow only for the creation of a single handle. If the user attempts to create a second handle, this error code will be returned.

InvalidLicense

Invalid license

The supplied license is invalid, and could either not be parsed, or the parsed data did not make any sense. This is typically the case if something other than the correct license file is passed to the constructor of fluxEngineNET.Handle.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

LicenseWrongProduct

License is for wrong product

The supplied license is for the wrong product (for example, fluxTrainer), but not for fluxEngine.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

LicenseExpired

License has expired

If the license was issued only up to a certain date, and that date has passed, the license is expired and this error will be returned.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

LicenseUpdateExpired

License is for previous versions of the software

The supplied license is only valid for versions of fluxEngine that were built before a specific date, and the current version of fluxEngine has passed that date.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

LicenseIdentifierMismatch

License identifier mismatch

The supplied license does not match the current system. For example, when a license issued to the mainboard serial number of a given system is run on a system with a different mainboard serial number, this error will be returned.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

LicenseDongleRemoved

The license dongle has been removed

The license was tied to a dongle and that dongle has since been removed from the computer.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

LicenseDeviceNotConnected

The device the license is tied to is not connected

If the license is tied to the serial number of a device (such as a camera), it must be connected before certain operations can occur, such as the creation of a processing context or the processing of data. If the device is not currently connected this error will be returned. (Note that only the current connection state is checked.)

If the license is not tied to the serial number of a camera this type of error will not occur.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

LicenseFeatureNotPresent

A license feature required for this operation is not present in the license

For example, if model processing is not enabled, attempting to load a model will fail with this error.

When creating a device processing context, if a specific device is of a type that is not supported by the license, this may also be returned.

This error code will always be set in a subclass of Error, LicenseError, to allow the user to polymorphically catch this kind of error.

See also

LicenseError

ThreadCreationError

Unable to create a background processing thread

A background processing thread could not be created by fluxEngine, possibly due to resource exhaustion or an operating system limit.

This error code will always be set in a subclass of Error, InitializationError, to allow the user to polymorphically catch this kind of error.

See also

InitializationError

ThreadInitFunctionError

The user-supplied thread initialization function returned a non-zero return code

This error code exists for completeness sake, as the .NET wrapper code will propagate exceptions from the thread initialization function directly to the user.

InvalidModelData

Invalid Model Data

When loading a model (either from memory or from a file) this error code is returned if the model could not be loaded, for example because the data of the model was corrupt, or the file that was passed was not a LuxFlux Runtime Model (.fluxmdl).

This could also be the result of an I/O error that could not be properly caught.

This error code will always be set in a subclass of Error, ModelLoadError, to allow the user to polymorphically catch this kind of error.

ModelContainsUnsupportedFilter

Model Contains Unsupported Filter

The supplied model contains a filter that is not supported by the current version of fluxEngine. It was likely created with a newer version of fluxTrainer.

This error code will always be set in a subclass of Error, ModelLoadError, to allow the user to polymorphically catch this kind of error.

ModelContainsUnlicensedFilter

Model Contains Unlicensed Filter

The supplied model contains a filter that is not allowed by the currently loaded license, and can hence not be loaded.

This error code will always be set in a subclass of Error, ModelLoadError, to allow the user to polymorphically catch this kind of error.

ModelNotConsistent

The supplied model is not consistent

The model that was loaded is not in a consistent state. This indicates a problem during the export of the model.

This error code will always be set in a subclass of Error, ModelLoadError, to allow the user to polymorphically catch this kind of error.

ModelSourceTypeUnsupported

The supplied model is for unsupported data

The model that was loaded is for processing data of a type that is currently not supported by fluxEngine. Currently only hyperspectral data (Cubes or PushBroom frames) are supported.

This error code will always be set in a subclass of Error, ModelLoadError, to allow the user to polymorphically catch this kind of error.

ModelWrongSourceType

The loaded model is not a HSI model

When creating a processing context for HSI data, if the loaded model is not a HSI model, this error code will be returned.

At the moment, this will never happen, as only HSI models can be loaded. Future versions might return this error code though.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

FilterCreationError

Could not create required filter

When creating a processing context, several filters are automatically created and added to the model to ensure that they can properly transform the input data to the format the model expects. This error is returned if one of these filters could not be created for any reason.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

WavelengthRangeDeterminationError

Could not determine wavelength range of model

The wavelength setting of the source node in a given model could not be read during the creation of a processing context.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

InputDimensionError

The supplied dimensions of the input do not make sense

The dimensions of the input supplied while either creating a processing context or providing the next input data pointer do not make sense, for example because a negative number was provided.

This error code will always be set in a subclass of Error, InputDimensionError, to allow the user to polymorphically catch this kind of error.

InputStrideError

The supplied stride of the input does not fit

The stride of the input supplied while providing the next input data pointer does not fit the dimension structure of the input data.

For example, if an entire cube is being processed, and the dimension structure of the cube is {500, 300, 200}, then a stride structure of {60000, 200, 1} would be acceptable, but a stride structure of {50000, 200, 1} would not be, as the first stride is smaller than the second stride times the second dimension.

This error code will always be set in a subclass of Error, InputStrideError, to allow the user to polymorphically catch this kind of error.

WhiteReferenceMissingError

No white reference provided

When creating a processing context for a model that is given in reflectances or absorbances, but the data provided by the user will be in raw intensities, a white reference must exist for fluxEngine to be able to automatically reference the input data. If no white reference is provided during processing context creation in that circumstance, this error will be returned.

Note: this error will not occur if the data provided by the user is already reflectance data — or the model is set to process raw intensities and the user provides intensity data.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

WhiteReferenceDimensionError

The provided dimensions of the white reference are not acceptable

When providing a white reference while setting up a processing context, the dimension of the provided reference must be supplied. If those dimensions are not congruent to the input dimensions, this error code will be returned.

Please note that references always have an additional dimension that allows fluxEngine to average over multiple reference measurements, so the reference for processing entire HSI cubes will be a tensor of order 4, for example.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

DarkReferenceDimensionError

The provided dimensions of the dark reference are not acceptable

When providing a dark reference while setting up a processing context, the dimension of the provided reference must be supplied. If those dimensions are not congruent to the input dimensions, this error code will be returned.

Please note that references always have an additional dimension that allows fluxEngine to average over multiple reference measurements, so the reference for processing entire HSI cubes will be a tensor of order 4, for example.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

PreprocessingSetupError

An error occurred while setting up preprocessing

While performing the final actions required to initialize the preprocessing steps for the input data, an error occurred.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

ProcessingSetupError

An error occurred while setting up processing

While performing the final actions required to initialize the processing sequence, an error occurred.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

InputWavelengthValueError

Input wavelength value error

One of the wavelengths supplied as the input data did not have a finite value. This happens if the list of input wavelengths contain NaN or infinities.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

InputScalarTypeError

The supplied scalar type of the input does not match

The scalar type of the input supplied while providing the next input data pointer does not match the scalar type with which the context was created.

This error code will always be set in a subclass of Error, InputScalarTypeError, to allow the user to polymorphically catch this kind of error.

IlluminationReferenceMissingError

No illumination reference provided

When creating a processing context for a model that requires illumination corrected intensities, but the data provided by the user has not yet been illumination corrected, an illumination reference must exist for fluxEngine to be able to automatically reference the input data. If no illumination reference is provided during processing context creation in that circumstance, this error will be returned.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

IlluminationReferenceDimensionError

The provided dimensions of the illumination reference are not acceptable

When providing an illumination reference while setting up a processing context, the dimension of the provided reference must be supplied. If those dimensions are not congruent to the input dimensions, this error code will be returned.

Please note that references always have an additional dimension that allows fluxEngine to average over multiple reference measurements, so the reference for processing entire HSI cubes will be a tensor of order 4, for example.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

ValueTypeMismatchError

Input value type mismatch error

This error occurs when a model for intensity data (raw intensities, radiances, etc.) is used in conjunction with data that has already been white referenced (e.g. reflectances). In that case it is not possible to create a processing context and this error will occur.

This can also occur if a source explicitly requires relative or absolute radiances, but the input data is only provided in raw intensities.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

OutputIdNotPresent

No output sink with the given output id is present

This error will be returned by ProcessingContext.FindOutputSink() if there is no output sink in the loaded model with the requested output id.

This error code will always be set in a subclass of Error, OutputIntrospectionError, to allow the user to polymorphically catch this kind of error.

OutputIdNotUnique

Multiple outuput sinks with the given output id are present

This error will be returned by ProcessingContext.FindOutputSink() if there is more than one output sink in the loaded model with the requested output id.

This error code will always be set in a subclass of Error, OutputIntrospectionError, to allow the user to polymorphically catch this kind of error.

StorageTypeMismatch

Storage type mismatch while introspecting an output sink

When using either ProcessingContext.OutputSinkTensorStructure() or ProcessingContext.OutputSinkObjectListStructure() to obtain more detailed information about an output sink, if the output sink has a different storage type, this error will be returned.

For example, calling ProcessingContext.OutputSinkTensorStructure() for an output sink that will return a list of detected objects would result in this error.

This error code will always be set in a subclass of Error, OutputIntrospectionError, to allow the user to polymorphically catch this kind of error.

ProcessingContextTypeMismatch

The processing context is of the wrong type

When setting the next input pointer by calling ProcessingContext.SetSourceData() in the wrong variant, because the context was created for a different type of data, this error will be returned.

For example, calling ProcessingContext.SetSourceData() in the HSI cube variant on a context that was created to process PushBroom frames will result in this error.

This error code will always be set in a subclass of Error, ProcessingContextTypeMismatchError, to allow the user to polymorphically catch this kind of error.

ProcessingUnknownError

An unknown error occurred during processing

This happens when the actual processing step during a call to ProcessingContext.ProcessNext() fails in an unknown manner.

This error code will always be set in a subclass of Error, ProcessingError, to allow the user to polymorphically catch this kind of error.

ProcessingInternalError

An internal error occurred during processing

This error code will always be set in a subclass of Error, ProcessingError, to allow the user to polymorphically catch this kind of error.

ProcessingAborted

Processing was aborted by the user

This error code will always be set in a subclass of Error, ProcessingError, to allow the user to polymorphically catch this kind of error.

ProcessingSourceDataMissing

The source data for processing was not set by the user

If the user has never called ProcessingContext.SetSourceData() before a call to ProcessingContext.ProcessNext() this error will occur.

This also occurs if the user has not set the source data again after a call to ProcessingContext.ResetState().

This error code will always be set in a subclass of Error, ProcessingError, to allow the user to polymorphically catch this kind of error.

ParameterInfoNoLongerValid

The parameter info is no longer valid

If a given parameter info was obtained from a connected device the parameter information will only remain valid as long as the device is connected. If the device has since disconnected the parameter information will become invalid.

If that is the case this error will be returned by methods that return information about a parameter info.

In contrast to ErrorCode.HandleNoLongerValid occurring, this is not an indication of undefined behavior.

This error code will always be set in a subclass of Error, ObjectNoLongerValidError, to allow the user to polymorphically catch this kind of error.

ParameterIndexOutOfRange

The parameter index is out of range

If information about a parameter is queried by index and the given parameter index is out of range, this error will occur.

Note that a negativ index will result in a ErrorCode.InvalidArgument instead of this error, as a negative index is never valid.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterNameDoesNotExist

A parameter with that name does not exist

If information about a parameter is queried by name and that name does not describe a valid parameter, this error will occur.

An alias for this code exists under the name ErrorCode.DeviceParameterNotFound.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterInternalQueryError

An internal error occurred while querying a parameter

This indicates an internal error (and likely a bug) when querying information about a parameter.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterWrongType

When querying a parameter the wrong type was encountered

When querying information about a parameter that requires the parameter to be of a specific type, and the parameter in question is of a different type, this error occurs.

An alias for this code exists under the name ErrorCode.DeviceParameterTypeError.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterEnumerationIndexOutOfRange

The enumeration entry index is out of range

If information about an enumeration entry is queried by index and the given enumeration entry index is out of range, this error will occur.

Note that a negative index will result in a ErrorCode.InvalidArgument instead of this error, as a negativ index is never valid.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterEnumerationNameDoesNotExist

An enumeration entry with that name does not exist

If information about an enumeration entry is queried by name and that name does not describe a valid enumeration entry, this error will occur.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterAffectedIndexOutOfRange

The affected parameter index is out of range

If information about an affected parameter is queried by index and the given affected parameter index is out of range, this error will occur.

Note that a negative index will result in a ErrorCode.InvalidArgument instead of this error, as a negativ index is never valid.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterNoDefaults

No defaults are available for the given parameter info

Parameter infos of connected devices do not contain information about default values. When querying default values of these parameter infos this error will occur.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

ParameterQueryError

Error querying parameter information

An error occurred while querying parameter information. For example, when attempting to query the minimum value of a parameter that is currently not accessible, this error might occur.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

DeviceEnumerationInvalidIndex

An invalid index was supplied while querying an enumeration result

While retrieving an enumeration result object (driver, device, warning, error) by its index, an invalid index was supplied by the user.

For example, if there were 2 devices found, but the user wants to query the device with index 15, this erorr will occur.

This error code will always be set in a subclass of Error, DeviceEnumerationError, to allow the user to polymorphically catch this kind of error.

DriverNotFound

The specified driver could not be found

When attempting to connect to a device group the specified driver (identified by driver type and name) could not be found.

This error code will always be set in a subclass of Error, DeviceConnectionError, to allow the user to polymorphically catch this kind of error.

DeviceConnectionEnumerationTimeout

Device connection: enumeration timeout

When connecting to a device the device is searched for internally before connecting to it. If the device cannot be found again (assuming the device id stems from a previous enumeration attempt) this error will occur.

Typically this happens when the device disappears between initial enumeration and the connection attempt. This could be due to a loose connection, sudden power loss, or the device crashing after the initial enumeration attempt.

This error code will always be set in a subclass of Error, DeviceConnectionError, to allow the user to polymorphically catch this kind of error.

DeviceConnectionDriverError

Device connection: driver error

During device connection a driver error occurred, most likely indicating that the driver itself crashed for some reason.

This error code will always be set in a subclass of Error, DeviceConnectionError, to allow the user to polymorphically catch this kind of error.

DeviceConnectionParametrizationError

Device connection: internal parametrization error

The driver returned invalid connection parameter information during the connection attempt. This is likely a bug in the driver or fluxEngine.

This error code will always be set in a subclass of Error, DeviceConnectionError, to allow the user to polymorphically catch this kind of error.

DeviceConnectionFailed

Device connection: connection failed

Could not connect to the specified device. The error message will be the message generated by the driver and give a better indication about the actual issue when not being able to connect to the device.

The most common possible causes are:

  • For devices that must be probed: the device is not connected

  • The user doesn’t have permissions to access the device

  • For network devices: the device is in the wrong subnet and is hence not accessible

  • For network devices: the system firewall blocks fluxDriverIsolation.exe from receiving packets from the network

  • The device is not supported by the driver (and that could only be determined during a connection attempt)

  • An invalid connection setting (such as an invalid calibration file) was specified during the connection attempt

This error code will always be set in a subclass of Error, DeviceConnectionError, to allow the user to polymorphically catch this kind of error.

DeviceNoLongerValid

The device is no longer valid

This error occurs when the user attempts to access a device when the corresponding fluxEngine handle has been closed and the device has been force-disconnected and is no longer in a valid state. The user must unload the device group when this error occurs.

In contrast to ErrorCode.HandleNoLongerValid occurring, this is not an indication of undefined behavior.

This error code will always be set in a subclass of Error, ObjectNoLongerValidError, to allow the user to polymorphically catch this kind of error.

DeviceParameterListNotFound

Parameter list not found

The specified parameter list has not been exposed by the connected driver.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

DeviceParameterNotFound

Parameter not found (alias)

A parameter with the specific name does not exist.

This error may also occur during device connection and when writing unrelated parameters, as some parameters are re-read after connection and after each parameter change to keep meta data for the device up to date. If one of these internal parameters (that the driver uses to give fluxEngine additional information) is somehow missing, this error could occur in those cases (i.e. writing to a different parameter or connecting the device group).

This name is an alias for ErrorCode.ParameterNameDoesNotExist, as they have the same code.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

DeviceParameterAccessError

Parameter access error

The parameter in question could not be accessed

This occurs when a parameter is not accessible (in the case of read or write operation) or read-only (in the case of a write operation).

For example, some camera devices have the ability to set a frame rate independent of the exposure time — and a boolean parameter must be enabled for this before the actual frame rate parameter may be written to (or even read from).

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

DeviceParameterTypeError

Parameter type error (alias)

The parameter in question has the wrong type. For example, attempting to read an integer value from a string parameter will result in this error.

This error may also occur during device connection and when writing unrelated parameters, as some parameters are re-read after connection and after each parameter change to keep meta data for the device up to date. If one of these internal parameters (that the driver uses to give fluxEngine additional information) has the wrong type (due to a bug in the driver), this error could occur in those cases (i.e. writing to a different parameter or connecting the device group).

This name is an alias for ErrorCode.ParameterWrongType, as they have the same code.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

DeviceParameterReadError

Parameter read error

The parameter in question could not be read, even though the access mode is OK.

This can have multiple reasons, for example if the device has been unplugged in the mean time.

This error may also occur during device connection and when writing unrelated parameters, as some parameters are re-read after connection and after each parameter change to keep meta data for the device up to date. If one of these internal parameters (that the driver uses to give fluxEngine additional information) cannot be read, this error could occur in those cases (i.e. writing to a different parameter or connecting the device group).

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

DeviceParameterWriteError

Parameter write error

The parameter in question could not be written to.

This may occur if an invalid value is given to a parameter. For example, if an integer parameter only accepts values between 2 and 5, and the value 17 is supplied, this error may occur.

This error code will always be set in a subclass of Error, ParameterError, to allow the user to polymorphically catch this kind of error.

DeviceTypeError

Device type error

When attempting to use a type-specific device function (such as functions for instrument devices or light control devices), if the type of the device does not match the function that is being called, this error will occur.

This error code will always be set in a subclass of Error, DeviceError, to allow the user to polymorphically catch this kind of error.

DeviceStatusQueryError

Device status query error

Typically it should always be possible to query the status of a connected device, even if the device is in an irrecoverable error state. But if that does fail for some unknown reason this error will occur.

This error code will always be set in a subclass of Error, DeviceError, to allow the user to polymorphically catch this kind of error.

DeviceResetError

Device recoverable error reset failed

While attempting to reset from a recoverable error the reset failed. This can typically occur in three situations:

  • The recoverable error has not yet been cleared — for example a temperature sensor might still indicate that a temperature is too far out of bounds for the device to function at all.

  • The original recoverable error has cleared, but in the mean time a different recoverable error has occurred.

  • The device has encountered an irrecoverable error in the mean time.

This error code will always be set in a subclass of Error, DeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceIncompatibleError

The instrument device is not compatible with fluxEngine

The instrument device is currently not compatible with the public fluxEngine API. This may occur if a newer driver is used in conjunction with an older version of fluxEngine.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceShmAlreadySetup

The shared memory buffers have already been set up

InstrumentDevice.SetupInternalBuffers() may only be called once for an instrument device; any call to that method afterwards will trigger this error.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceShmSetupError

Error setting up shared memory buffers

InstrumentDevice.SetupInternalBuffers() could not set up the shared memory segment for receiving buffers from the instrument device.

If not enough memory is available for the amount (and size) of the buffers this could occur on a normal system, but otherwise is an indication of a more serious problem.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceShmNotSetupError

Shared memory has not yet been set up

This occurs when attempting to start acquisition while the shared memory has not yet been set up.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceInvalidReferenceName

The specified reference name is invalid

While starting acquisition, if the specified reference name is not supported by the device, this error will occur. (See the documentation of the InstrumentDevice.AcquisitionParameters structure for further details.)

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceAcquisitionStartError

Acquisition start error

Device acquisition could not be started. This typically indicates a misconfiguration of the device, or a bug in the driver.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceAcquisitionStopError

Acquisition stop error

Device acquisition could not be stopped. This typically indicates a bug in the driver or fluxEngine, as stopping acquisition should always work.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

InstrumentDeviceInternalBufferError

Internal buffer error

This is an indication of a bug in the driver or fluxEngine because the driver returned a buffer that fluxEngine doesn’t know about.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

BufferAlreadyReturned

Buffer already returned

Cannot perform an operation on a buffer that has been returned back to the driver.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

BufferContainerFull

Buffer container full

Cannot add a buffer to a container because the container is full.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

BufferStructureMismatch

Buffer structure mismatch

When copying data into a persistent buffer, or copying data out of a buffer, there is a mismatch between the structure of the buffer and the source or target of the copy operation.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

BufferTargetMemoryTooSmallError

Buffer target memory too small

When extracting raw data from a buffer container this indicates the memory area the user has provided is too small.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

BufferContainerPastRingBufferSize

Buffer container: the entry is no longer available

When extracting data from a buffer container: the buffer container in question is a ring buffer, and the specific entry is not available anymore due to the ring buffer’s capacity.

This error code will always be set in a subclass of Error, InstrumentDeviceError, to allow the user to polymorphically catch this kind of error.

LightControlDeviceForceStateError

Cannot force state of light control device

This is coupled with a driver-generated error message that explains the reason for the failure.

This error code will always be set in a subclass of Error, LightControlDeviceError, to allow the user to polymorphically catch this kind of error.

LightControlDeviceRampError

Cannot wait for the ramp of the light control device

This is coupled with a driver-generated error message that explains the reason for the failure.

This error code will always be set in a subclass of Error, LightControlDeviceError, to allow the user to polymorphically catch this kind of error.

DeviceProcessingInvalidReferenceError

Device processing setup: invalid reference

The user has specified a reference during the processing setup that the driver does not support in the current mode. For example, a device that provides pre-referenced data (for example a virtual camera) will not support white or dark references when setting up a processing context.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

DeviceProcessingInformationMissing

Device processing setup: internal inforamtion missing

The driver has not provided the appropriate amount of information for fluxEngine to be able to set up a processing context for the device. This is likely a bug in the driver.

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

DeviceProcessingPreprocessingSetupError

Device processing setup: preprocessing setup error

Could not set up the preprocessing steps for a processing context. The following lists the situations that could lead to this error (though the list is not exhaustive):

  • A missing white reference in some cases

  • The user wants to record HSI data interpolated onto a wavelength grid that has no overlap with the actual wavelengths of the device

  • The user’s license for fluxEngine does not support the specific preprocessing steps required

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

DeviceProcessingReferenceSetupError

Reference setup error

An error occurred while setting up the supplied reference measurements that didn’t fall into one of the existing categories, such as:

This error code will always be set in a subclass of Error, ProcessingContextCreationError, to allow the user to polymorphically catch this kind of error.

DeviceProcessingBufferIncompatible

The suppled processing buffer is incompatible

When using a device buffer or persistent buffer as the input to a processing context (via ther overload of ProcessingContext.SetSourceData() that accepts a Buffer or a PersistentBuffer), if the structure of the buffer is not compatible with the processing context, this error will occur.

For example, if the user creates a processing context for a camera device, changes the ROI of the camera, and then uses buffers obtained after the ROI change with the processing context before the ROI change, this error may occur.

This error code will always be set in a subclass of Error, InputBufferIncompatibleError, to allow the user to polymorphically catch this kind of error.

MeasurementProcessingTypeError

The measurement type is incompatible with the model

When creating a processing context for a specific measurement, if the type of the measurement is incompatible with the given model, this error will occur.

MeasurementProcessingMutuallyIncompatible

Multiple measurements are mutually incompatible

When creating a processing context for a list of measurements, and the measurements in the list are mutually incompatible (for example due to a different scalar type, but could also be if they have different white/dark references), this error will occur.

MeasurementProcessingIncompatibleWithFixedSize

Cannot create a processing context for fixed sizes

When creating a processing context for a list of measurements, and the measurements in the list are compatible, but have varying spatial sizes, and the user has not specified the MeasurementProcessingContextFlag_VariableSpatialSize flag, this error will occur.

Error

class LuxFlux.fluxEngineNET.Error : Exception

Base exception class for fluxEngine errors

When fluxEngine throws an exception, it will always throw one of the following exceptions:

  • This class or a subclass of it to describe an error that is

  • OutOfMemoryException to describe allocation failures

  • ArgumentException if an invalid argument was passed to any fluxEngine method

  • ArgumentOutOfRangeException to indicate an index was out of range (for example, when introspecting groups of a model, if the group id is invalid, this will be thrown)

  • During thread creation any exception in the thread initialization callback the user supplies will be forwarded to the user

Subclassed by LuxFlux.fluxEngineNET.DeviceError, LuxFlux.fluxEngineNET.InitializationError, LuxFlux.fluxEngineNET.InputBufferIncompatibleError, LuxFlux.fluxEngineNET.InputDimensionError, LuxFlux.fluxEngineNET.InputScalarTypeError, LuxFlux.fluxEngineNET.InputStrideError, LuxFlux.fluxEngineNET.LicenseError, LuxFlux.fluxEngineNET.ModelLoadError, LuxFlux.fluxEngineNET.ObjectNoLongerValidError, LuxFlux.fluxEngineNET.OutputIntrospectionError, LuxFlux.fluxEngineNET.ParameterError, LuxFlux.fluxEngineNET.ProcessingContextCreationError, LuxFlux.fluxEngineNET.ProcessingContextTypeMismatchError, LuxFlux.fluxEngineNET.ProcessingError

Public Functions

Error (string message, ErrorCode code, int osErrorCode = 0)

Constructor

The error message may be retrieved by the Message property of the Exception base class, the code parameter will be accessible via the Code class member, the osErrorCode parameter via the OSErrorCode class member.

Param message:

The error message

Param code:

The fluxEngine error code

Param osErrorCode:

The underlying operating system error code

Public Members

ErrorCode Code = 0

The error code associated with this exception

int OSErrorCode = 0

The operating system error code associated with this exception, if any

This will contain the operating system error code associated with this exception. Some errors may not involve calls to the operating system, in which case this will be 0.

Public Static Functions

void ThrowFromArguments (string message, ErrorCode errorCode, int osErrorCode)

Throw an error from a set of arguments

This will automatically throw the correct subclass of the error class depending on the specified error code. The arguments will be passed to the constructor of that class.

Param message:

The error message

Param errorCode:

The error code

Param osErrorCode:

The underlying operating system error code if an OS function was responsible for the specific error

ObjectNoLongerValidError

class LuxFlux.fluxEngineNET.ObjectNoLongerValidError : LuxFlux.fluxEngineNET.Error

Object no longer valid error

The object in question is no longer valid. For example because it has already been disposed.

LicenseError

class LuxFlux.fluxEngineNET.LicenseError : LuxFlux.fluxEngineNET.Error

License Error

This error class exists to allow the user to polymorphically catch all exceptions that relate to the license being rejected by fluxEngine. This includes the following error codes:

InitializationError

class LuxFlux.fluxEngineNET.InitializationError : LuxFlux.fluxEngineNET.Error

Initialization Error

This error class exists to allow the user to polymorphically catch all exceptions that relate to initialization issues in fluxEngine. This includes the following error codes:

ModelLoadError

class LuxFlux.fluxEngineNET.ModelLoadError : LuxFlux.fluxEngineNET.Error

Model Load Error

This error class exists to allow the user to polymorphically catch all exceptions that relate to loading and parsing models in fluxEngine. This includes the following error codes:

ProcessingContextCreationError

class LuxFlux.fluxEngineNET.ProcessingContextCreationError : LuxFlux.fluxEngineNET.Error

Processing Context Creation Error

This error class exists to allow the user to polymorphically catch most exceptions that relate to the creation of processing contexts in fluxEngine. This includes the following error codes:

InputDimensionError

class LuxFlux.fluxEngineNET.InputDimensionError : LuxFlux.fluxEngineNET.Error

Input Dimension Error

This error class exists to allow the user to polymorphically catch all exceptions that relate to the input dimensions not being specified correctly, either while creating a processing context, or while setting the source data before execution. This always corresponds to the error code ErrorCode.InputDimensionError.

InputStrideError

class LuxFlux.fluxEngineNET.InputStrideError : LuxFlux.fluxEngineNET.Error

Input Stride Error

This error class exists to allow the user to polymorphically catch all exceptions that relate to the input strides not being specified correctly while setting the source data before execution. This always corresponds to the error code ErrorCode.InputStrideError.

InputBufferIncompatibleError

class LuxFlux.fluxEngineNET.InputBufferIncompatibleError : LuxFlux.fluxEngineNET.Error

Input Buffer Incompatible Error

This error class exists to allow the user to polymorphically catch all exceptions that relate to the input buffer not being compatible with the processing context while setting the source data before execution. This always corresponds to the error code ErrorCode.DeviceProcessingBufferIncompatible.

OutputIntrospectionError

class LuxFlux.fluxEngineNET.OutputIntrospectionError : LuxFlux.fluxEngineNET.Error

Output Introspection Error

This error class exists to allow the user to polymorphically catch most exceptions that relate to the introspection of output sinks in a given processing context. This includes the following error codes:

ProcessingContextTypeMismatchError

class LuxFlux.fluxEngineNET.ProcessingContextTypeMismatchError : LuxFlux.fluxEngineNET.Error

Processing Context Type Error

This error class exists to allow the user to polymorphically catch if they accidentally try to set the wrong type of input data for a given processing context, or attempt to create a processing context for measurements that are of the wrong type for a specific model. This includes the following error codes:

ProcessingError

class LuxFlux.fluxEngineNET.ProcessingError : LuxFlux.fluxEngineNET.Error

Processing Error

This error class exists to allow the user to polymorphically catch most exceptions that relate to the actual processing of data. This includes the following error codes:

ParameterError

class LuxFlux.fluxEngineNET.ParameterError : LuxFlux.fluxEngineNET.Error

ParameterError

This error class exists to allow the user to polymorphically catch most exceptions that relate to parametrization of devices. This includes the following error codes:

DeviceError

class LuxFlux.fluxEngineNET.DeviceError : LuxFlux.fluxEngineNET.Error

DeviceError

This error class exists to allow the user to polymorphically catch most exceptions that relate to devices themselves. This includes the following error codes:

Additionally there are the following subclasses:

Subclassed by LuxFlux.fluxEngineNET.DeviceConnectionError, LuxFlux.fluxEngineNET.DeviceEnumerationError, LuxFlux.fluxEngineNET.InstrumentDeviceError, LuxFlux.fluxEngineNET.LightControlDeviceError

DeviceEnumerationError

class LuxFlux.fluxEngineNET.DeviceEnumerationError : LuxFlux.fluxEngineNET.DeviceError

Device Enumeration Error

This error class exists to allow the user to polymorphically catch most exceptions that relate to the enumeration of devices. This includes the following error codes:

DeviceConnectionError

class LuxFlux.fluxEngineNET.DeviceConnectionError : LuxFlux.fluxEngineNET.DeviceError

Device Connection Error

This error class exists to allow the user to polymorphically catch most exceptions that relate to the connection of device groups. This includes the following error codes:

InstrumentDeviceError

class LuxFlux.fluxEngineNET.InstrumentDeviceError : LuxFlux.fluxEngineNET.DeviceError

Instrument Device Error

This error class exists to allow the user to polymorphically catch most exceptions that relate to operations specific to instrument devices. This includes the following error codes:

LightControlDeviceError

class LuxFlux.fluxEngineNET.LightControlDeviceError : LuxFlux.fluxEngineNET.DeviceError

Light Control Device Error

This error class exists to allow the user to polymorphically catch most exceptions that relate to operations specific to light control devices. This includes the following error codes: