void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[])
{
// CHECK ARGS
if (nrhs != 3) {
mexErrMsgIdAndTxt( "Mscope:initialiseCamera:invalidNumInputs",
"No Input arguments accepted.");
}
if (nlhs > 2) {
mexErrMsgIdAndTxt( "Mscope:initialiseCamera:maxlhs",
"Too many output arguments.");
}
if (!isScalarArray(prhs[0])) {
mexErrMsgIdAndTxt( "Mscope:setAcqMode:invalidArg",
"Camera handle is an integer");
}
if (!isScalarArray(prhs[1])) {
mexErrMsgIdAndTxt( "Mscope:setAcqMode:invalidArg",
"Exposure is a double (in Hz)");
}
if (!isScalarArray(prhs[1])) {
mexErrMsgIdAndTxt( "Mscope:setAcqMode:invalidArg",
"Frame rate rate is a double (in ms)");
}
int hCam = (int) mxGetScalar(prhs[0]);
double frameRate = (double) mxGetScalar(prhs[2]);
double expTime = (double) mxGetScalar(prhs[1]);
// FRAME RATE
double actualFrameRate;
int rv = is_SetFrameRate(hCam, frameRate, &actualFrameRate);
// EXPOSURE TIME
rv = is_Exposure(hCam, IS_EXPOSURE_CMD_SET_EXPOSURE, &expTime, 8);
double actualExposure;
rv = is_Exposure(hCam, IS_EXPOSURE_CMD_GET_EXPOSURE, &actualExposure, 8);
// RETURN THE ACTUAL VALUES
mwSignedIndex scalarDims[2] = {1,1}; // elements in image
plhs[0] = mxCreateNumericArray(2, scalarDims, mxDOUBLE_CLASS, mxREAL);
double * exposurePtr = mxGetPr(plhs[0]);
memcpy(exposurePtr, &actualExposure, sizeof(actualExposure));
plhs[1] = mxCreateNumericArray(2, scalarDims, mxDOUBLE_CLASS, mxREAL);
double * frameratePtr = mxGetPr(plhs[1]);
memcpy(frameratePtr, &actualFrameRate, sizeof(actualFrameRate));
return;
}
INT UEyeCamDriver::setExposure(bool& auto_exposure, double& exposure_ms) {
if (!isConnected())
return IS_INVALID_CAMERA_HANDLE;
INT is_err = IS_SUCCESS;
double minExposure, maxExposure;
// Set auto exposure
double pval1 = auto_exposure, pval2 = 0;
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SENSOR_SHUTTER,
&pval1, &pval2))
!= IS_SUCCESS) {
if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SHUTTER,
&pval1, &pval2))
!= IS_SUCCESS) {
std::cerr << "Auto exposure mode is not supported for UEye camera '"
<< cam_name_ << "' (" << err2str(is_err) << ")" << std::endl;
auto_exposure = false;
}
}
// Set manual exposure timing
if (!auto_exposure) {
// Make sure that user-requested exposure rate is achievable
if (((is_err = is_Exposure(cam_handle_, IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN,
(void*) &minExposure, sizeof(minExposure)))
!= IS_SUCCESS) ||
((is_err = is_Exposure(cam_handle_, IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX,
(void*) &maxExposure, sizeof(maxExposure)))
!= IS_SUCCESS)) {
std::cerr << "Failed to query valid exposure range from UEye camera '"
<< cam_name_ << "'" << std::endl;
return is_err;
}
CAP(exposure_ms, minExposure, maxExposure);
// Update exposure
if ((is_err = is_Exposure(cam_handle_, IS_EXPOSURE_CMD_SET_EXPOSURE,
(void*) &(exposure_ms), sizeof(exposure_ms)))
!= IS_SUCCESS) {
std::cerr << "Failed to set exposure to " << exposure_ms
<< " ms for UEye camera '" << cam_name_ << "'" << std::endl;
return is_err;
}
}
std::cout << "Updated exposure: "
<< ((auto_exposure) ? "auto" : to_string(exposure_ms))
<< " ms" << std::endl;
return is_err;
}
static int ids_core_Camera_setexposure(ids_core_Camera *self, PyObject *value, void *closure) {
int ret;
double exposure;
PyObject *exception;
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "Cannot delete attribute 'exposure'");
return -1;
}
exposure = PyFloat_AsDouble(value);
exception = PyErr_Occurred();
if (exception) {
PyErr_SetString(exception, "Exposure must be a number");
return -1;
}
ret = is_Exposure(self->handle, IS_EXPOSURE_CMD_SET_EXPOSURE, (void*) &exposure, sizeof(exposure));
switch (ret) {
case IS_SUCCESS:
return 0;
break;
case IS_INVALID_PARAMETER:
PyErr_SetString(PyExc_ValueError, "Exposure out of range");
break;
default:
raise_general_error(self, ret);
}
return -1;
}
ImageCaptureInterface::CapErrorCode UEyeCaptureInterface::getCaptureProperty(int id, int *value)
{
// printf("Getting the values of capture properties is not supported for uEye interface yet.\n");
switch (id)
{
case (CameraParameters::EXPOSURE):
{
double ms = 0.0;
ueyeTrace(is_Exposure (leftCamera.mCamera , IS_EXPOSURE_CMD_GET_EXPOSURE, (void*)&ms, sizeof(double)));
*value = ms * EXPOSURE_SCALER;
return SUCCESS;
}
case (CameraParameters::FPS):
{
double newFps;
ueyeTrace(is_SetFrameRate (leftCamera.mCamera , IS_GET_FRAMERATE, &newFps));
*value = newFps * FPS_SCALER;
return SUCCESS;
}
case (CameraParameters::MASTER_FLASH_DELAY):
{
IO_FLASH_PARAMS flashParams;
flashParams.s32Delay = 0;
flashParams.u32Duration = 0;
ueyeTrace(is_IO(leftCamera.mCamera, IS_IO_CMD_FLASH_GET_PARAMS, (void*)&flashParams, sizeof(flashParams)));
*value = flashParams.s32Delay;
return SUCCESS;
}
case (CameraParameters::MASTER_FLASH_DURATION):
{
IO_FLASH_PARAMS flashParams;
flashParams.s32Delay = 0;
flashParams.u32Duration = 0;
ueyeTrace(is_IO(leftCamera.mCamera, IS_IO_CMD_FLASH_GET_PARAMS, (void*)&flashParams, sizeof(flashParams)));
*value = flashParams.u32Duration;
return SUCCESS;
}
case (CameraParameters::SLAVE_TRIGGER_DELAY):
{
*value = is_SetTriggerDelay (rightCamera.mCamera, IS_GET_TRIGGER_DELAY);
return SUCCESS;
}
default:
{
printf("Set request for unknown parameter (%d)\n", id);
return ImageCaptureInterface::FAILURE;
}
}
return FAILURE;
}
bool IdsSourceSink::SetShutter(int shutTime)
{
double dEnable=0.0;
is_SetAutoParameter(hCam, IS_SET_ENABLE_AUTO_SHUTTER, &dEnable, NULL); // switch off any autoexposure
double texp=shutTime/1000.0; // IDS works in msecs
// get values
double dblRange[3]; // min, max and increment
is_Exposure(hCam, IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE, (void*)&dblRange, sizeof(dblRange));
if (texp<dblRange[0]) texp=dblRange[0];
is_Exposure(hCam,IS_EXPOSURE_CMD_SET_EXPOSURE,(void*)&texp,sizeof(texp));
//is_SetExposureTime (hCam, IS_GET_EXPOSURE_TIME, &texp);
return true;
}
static PyObject *ids_core_Camera_getexposure(ids_core_Camera *self, void *closure) {
double exposure;
int ret;
ret = is_Exposure(self->handle, IS_EXPOSURE_CMD_GET_EXPOSURE, &exposure, sizeof(exposure));
switch (ret) {
case IS_SUCCESS:
return PyFloat_FromDouble(exposure);
break;
default:
raise_general_error(self, ret);
}
return NULL;
}
UEyeCaptureInterface::CapErrorCode UEyeCaptureInterface::setCaptureProperty(int id, int value)
{
int retL = 0;
int retR = 0;
switch (id)
{
case (CameraParameters::EXPOSURE):
{
double ms = 0.0;
ms = (double)value / EXPOSURE_SCALER;
ueyeTrace(is_Exposure (leftCamera.mCamera , IS_EXPOSURE_CMD_SET_EXPOSURE, (void*)&ms, sizeof(double)));
ms = (double)value / EXPOSURE_SCALER;
ueyeTrace(is_Exposure (rightCamera.mCamera, IS_EXPOSURE_CMD_SET_EXPOSURE, (void*)&ms, sizeof(double)));
return SUCCESS;
}
case (CameraParameters::FPS):
{
double fps = (double)value / FPS_SCALER;
double newFps;
ueyeTrace(is_SetFrameRate (leftCamera.mCamera , fps, &newFps));
ueyeTrace(is_SetFrameRate (rightCamera.mCamera, fps, &newFps));
return SUCCESS;
}
case (CameraParameters::MASTER_FLASH_DELAY):
{
IO_FLASH_PARAMS flashParams;
flashParams.s32Delay = 0;
flashParams.u32Duration = 0;
ueyeTrace(is_IO(leftCamera.mCamera, IS_IO_CMD_FLASH_GET_PARAMS, (void*)&flashParams, sizeof(flashParams)));
flashParams.s32Delay = value;
ueyeTrace(is_IO(leftCamera.mCamera, IS_IO_CMD_FLASH_SET_PARAMS, (void*)&flashParams, sizeof(flashParams)));
return SUCCESS;
}
case (CameraParameters::MASTER_FLASH_DURATION):
{
IO_FLASH_PARAMS flashParams;
flashParams.s32Delay = 0;
flashParams.u32Duration = 0;
ueyeTrace(is_IO(leftCamera.mCamera, IS_IO_CMD_FLASH_GET_PARAMS, (void*)&flashParams, sizeof(flashParams)));
flashParams.u32Duration = value;
ueyeTrace(is_IO(leftCamera.mCamera, IS_IO_CMD_FLASH_SET_PARAMS, (void*)&flashParams, sizeof(flashParams)));
return SUCCESS;
}
case (CameraParameters::SLAVE_TRIGGER_DELAY):
{
is_SetTriggerDelay (rightCamera.mCamera, value);
return SUCCESS;
}
case (CameraParameters::EXPOSURE_AUTO) :
{
double enable = value;
ueyeTrace(is_SetAutoParameter(leftCamera.mCamera, IS_SET_ENABLE_AUTO_SHUTTER, &enable, 0));
return SUCCESS;
}
default:
{
printf("Set request for unknown parameter (%d)\n", id);
return ImageCaptureInterface::FAILURE;
}
}
return (ImageCaptureInterface::CapErrorCode) ((bool) retL + (bool) retR);
}
ImageCaptureInterface::CapErrorCode UEyeCaptureInterface::queryCameraParameters(CameraParameters ¶ms)
{
/* Exposure */
double defaultExp;
double minExp;
double maxExp;
double stepExp;
ueyeTrace(is_Exposure (leftCamera.mCamera , IS_EXPOSURE_CMD_GET_EXPOSURE_DEFAULT, (void*)&defaultExp, sizeof(double)));
ueyeTrace(is_Exposure (leftCamera.mCamera , IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN, (void*)&minExp, sizeof(double)));
ueyeTrace(is_Exposure (leftCamera.mCamera , IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX, (void*)&maxExp, sizeof(double)));
ueyeTrace(is_Exposure (leftCamera.mCamera , IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_INC, (void*)&stepExp, sizeof(double)));
CaptureParameter *param = &(params.mCameraControls[CameraParameters::EXPOSURE]);
param->setActive(true);
param->setDefaultValue(defaultExp * EXPOSURE_SCALER);
param->setMinimum (minExp * EXPOSURE_SCALER);
param->setMaximum (maxExp * EXPOSURE_SCALER);
param->setStep (stepExp * EXPOSURE_SCALER);
/* Exposure auto*/
param = &(params.mCameraControls[CameraParameters::EXPOSURE_AUTO]);
*param = CaptureParameter();
param->setActive(true);
param->setDefaultValue(0);
param->setMinimum(0);
param->setMaximum(1);
param->setStep(1);
param->setIsMenu(true);
param->pushMenuItem(QString("False"), 0);
param->pushMenuItem(QString("True") , 1);
/* Gain */
/* Frame rate */
param = &(params.mCameraControls[CameraParameters::FPS]);
param->setActive(true);
param->setDefaultValue(25 * FPS_SCALER);
param->setMinimum (0 * FPS_SCALER);
param->setMaximum (50 * FPS_SCALER);
param->setStep (1);
param = &(params.mCameraControls[CameraParameters::MASTER_FLASH_DELAY]);
param->setActive (true);
param->setDefaultValue(0);
param->setMinimum (-500000);
param->setMaximum (500000);
param->setStep (1);
param = &(params.mCameraControls[CameraParameters::MASTER_FLASH_DURATION]);
param->setActive (true);
param->setDefaultValue(0);
param->setMinimum (0);
param->setMaximum (500000);
param->setStep (1);
param = &(params.mCameraControls[CameraParameters::SLAVE_TRIGGER_DELAY]);
param->setActive (true);
param->setDefaultValue(0);
param->setMinimum (is_SetTriggerDelay (rightCamera.mCamera, IS_GET_MIN_TRIGGER_DELAY));
param->setMaximum (is_SetTriggerDelay (rightCamera.mCamera, IS_GET_MAX_TRIGGER_DELAY));
param->setStep (is_SetTriggerDelay (rightCamera.mCamera, IS_GET_TRIGGER_DELAY_GRANULARITY));
return ImageCaptureInterface::SUCCESS;
}
void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[])
{
// CHECK ARGS
if (nrhs != 0) {
mexErrMsgIdAndTxt( "Mscope:initialiseCamera:invalidNumInputs",
"No Input arguments accepted.");
}
if (nlhs > 2) {
mexErrMsgIdAndTxt( "Mscope:initialiseCamera:maxlhs",
"Too many output arguments.");
}
HCAM hCam = 0;
// CONNECT TO CAMERA AND GET THE HANDLE
int rv = is_InitCamera(&hCam, NULL);
// SET THE PIXEL CLOCK
UINT pixelClock = DFT_PX_CLOCK;
rv = is_PixelClock(hCam, IS_PIXELCLOCK_CMD_SET, (void*) &pixelClock, sizeof(pixelClock));
// FRAME RATE
double frameRate = DFT_FRAME_RATE;
double actualFrameRate;
rv = is_SetFrameRate(hCam, frameRate, &actualFrameRate);
// EXPOSURE TIME
double expTime = 10; // exposure time in ms
rv = is_Exposure(hCam, IS_EXPOSURE_CMD_SET_EXPOSURE, &expTime, 8);
// TRIGGER MODE
rv = is_SetExternalTrigger(hCam, IS_SET_TRIGGER_SOFTWARE);
// COLOR MODE
rv = is_SetColorMode(hCam, IS_CM_MONO8); // 8-bit monochrome
// SET THE SUBSAMPLING
rv = is_SetSubSampling(hCam, IS_SUBSAMPLING_4X_VERTICAL | IS_SUBSAMPLING_4X_HORIZONTAL);
// ALLOCATE MEMORY
int bitDepth = 8;
char* pcImgMem;
int id;
rv = is_AllocImageMem(hCam, H_PIX, V_PIX, bitDepth, &pcImgMem, &id);
// CALCULATE THE LINE PITCH
int linePitch;
rv = is_GetImageMemPitch(hCam, &linePitch);
std::printf("\nLine Pitch = %i\n",linePitch);
// SET MEMORY
rv = is_SetImageMem(hCam, pcImgMem, id);
// START CAPTURING
rv = is_CaptureVideo(hCam, IS_DONT_WAIT);
// RETURN CAMERA HANDLE
UINT8_T hCam8 = (UINT8_T) hCam;
mwSignedIndex scalarDims[2] = {1,1}; // elements in image
plhs[0] = mxCreateNumericArray(1, scalarDims, mxUINT8_CLASS, mxREAL);
double * hCamPtr = mxGetPr(plhs[0]);
memcpy(hCamPtr, &hCam8, sizeof(hCam8));
// RETURN MEMORY ID
UINT32_T id32 = (UINT32_T) id;
plhs[1] = mxCreateNumericArray(1, scalarDims, mxUINT32_CLASS, mxREAL);
double * mIdPtr = mxGetPr(plhs[1]);
memcpy(mIdPtr, &id32, sizeof(id32));
return;
}
