int PvUniversalParam::initialize() { plGetParam( ATTR_CURRENT, mValue ); if ( mType == TYPE_ENUM ) { mEnumStrings.clear(); uns32 count; char enumStr[MAX_ENUM_STR_LEN]; int32 enumValue; if (pl_get_param( mCamera->Handle(), mId, ATTR_COUNT, (void_ptr)&count) != PV_OK) { mCamera->LogCamError(__LINE__, "PvUniversalParam::initialize() pl_get_param ATTR_COUNT"); return DEVICE_ERR; } for ( uns32 i = 0; i < count; i++ ) { if (pl_get_enum_param( mCamera->Handle(), mId, i, &enumValue, enumStr, MAX_ENUM_STR_LEN) != PV_OK ) { mCamera->LogCamError(__LINE__, "PvUniversalParam::initialize() pl_get_enum_param"); return DEVICE_ERR; } mEnumStrings.push_back(std::string( enumStr )); } } else { plGetParam( ATTR_MIN, mValueMin ); plGetParam( ATTR_MAX, mValueMax ); } return DEVICE_OK; }
int PvUniversalParam::plGetParam( int16 aAttr, PvUniversalParamValue& aValueOut ) { rs_bool pvRet; switch (mType) { case TYPE_INT8: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.int8_val ); break; case TYPE_UNS8: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.uns8_val ); break; case TYPE_INT16: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.int16_val ); break; case TYPE_UNS16: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.uns16_val ); break; case TYPE_INT32: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.int32_val ); break; case TYPE_ENUM: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.enum_val ); break; case TYPE_BOOLEAN: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.rs_bool_val ); break; case TYPE_UNS32: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.uns32_val ); break; case TYPE_FLT64: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.flt64_val ); break; #ifdef TYPE_INT64 case TYPE_INT64: pvRet = pl_get_param( mCamera->Handle(), mId, aAttr, &aValueOut.long64_val ); break; #endif default: mCamera->LogCamError(__LINE__, "PvUniversalParam::plGetParam() type not supported"); pvRet = PV_FAIL; break; } if (pvRet != PV_OK) return DEVICE_ERR; return DEVICE_OK; }
double QuantixCamera::getFrameRefreshTime(EventMetadatum &eventMetadatum) { uns16 pixelWriteTimeNS; double parallelShiftTimeNS = 80000; // 80 microseconds double serialDiscardRateNS = 100; // 0.1 microseconds double serialRecordRateNS; int16 pixTime; if (!pl_get_param (cameraHandle, PARAM_PIX_TIME, ATTR_CURRENT, &pixTime)) throw CameraException("Can't access pixel time for frame refresh"); serialRecordRateNS = (double) pixTime; if(!pl_get_param(cameraHandle, PARAM_PIX_TIME, ATTR_CURRENT, (void *) &pixelWriteTimeNS)) { char msg[ERROR_MSG_LEN]; // for error handling pl_error_message(pl_error_code(), msg); std::cerr << "Pixel readout time error: " << msg << std::endl; throw CameraException("Error getting pixel readout time."); } int parallelRows = (cameraState->imageWidth.getSize()); int totalPixels = (cameraState->imageHeight.getSize())*(cameraState->imageWidth.getSize()); int recordedRows = eventMetadatum.cropVector.at(2) + 1; int recordedPixels = recordedRows*(eventMetadatum.cropVector.at(3) + 1); int binSize; if (!STI::Utils::stringToValue(cameraState->binSize.get(), binSize)) throw CameraException("Error transforming string to value"); //Based off the 6303 data sheet double refreshTime = 0; refreshTime += recordedRows*parallelShiftTimeNS; //Time to shift relevant rows. refreshTime += recordedPixels*serialRecordRateNS / binSize / binSize; //Time to record (and discard?) relevent pixels refreshTime += (totalPixels - recordedPixels)*serialDiscardRateNS; //Time to discard non-relevant pixels std::cerr << "Frame Rate (s): " << refreshTime/1000000000 << std::endl; return refreshTime; }
double QuantixCamera::getMinExposureTime() { //Best Case Scenario: get minimum exposure time from Camera flt64 minExpTimeS; char enumStr[100]; int32 enumValue; uns32 currentMode = 0; //experimentally-determined min exposure time: 0.3*ms, but keep 1 ms to be safe if(!pl_get_param(cameraHandle, PARAM_EXP_MIN_TIME, ATTR_CURRENT, (void *)&minExpTimeS)) { pl_get_param(cameraHandle, PARAM_EXP_RES, ATTR_CURRENT, (void *) ¤tMode); pl_get_enum_param (cameraHandle, PARAM_EXP_RES, currentMode, &enumValue, enumStr, 100); if (enumValue == EXP_RES_ONE_MICROSEC) minExpTimeS = 0.000001; else if (enumValue == EXP_RES_ONE_MILLISEC) minExpTimeS = 0.001; else minExpTimeS = 0; } return (double) (1000000000 * minExpTimeS); }
int PvUniversalParam::initialize() { plGetParam( ATTR_CURRENT, mValue ); if ( mType == TYPE_ENUM ) { mEnumStrings.clear(); mEnumValues.clear(); uns32 count; int32 enumValue; if (pl_get_param( mCamera->Handle(), mId, ATTR_COUNT, (void_ptr)&count) != PV_OK) { mCamera->LogCamError(__LINE__, "PvUniversalParam::initialize() pl_get_param ATTR_COUNT"); return DEVICE_ERR; } for ( uns32 i = 0; i < count; i++ ) { uns32 enumStrLen; if ( pl_enum_str_length( mCamera->Handle(), mId, i, &enumStrLen ) != PV_OK ) { mCamera->LogCamError(__LINE__, "PvUniversalParam::initialize() pl_enum_str_length"); return DEVICE_ERR; } char* enumStrBuf = new char[enumStrLen+1]; enumStrBuf[enumStrLen] = '\0'; if (pl_get_enum_param( mCamera->Handle(), mId, i, &enumValue, enumStrBuf, enumStrLen) != PV_OK ) { mCamera->LogCamError(__LINE__, "PvUniversalParam::initialize() pl_get_enum_param"); return DEVICE_ERR; } mEnumStrings.push_back(std::string( enumStrBuf )); mEnumValues.push_back(enumValue); delete[] enumStrBuf; } } else { plGetParam( ATTR_MIN, mValueMin ); plGetParam( ATTR_MAX, mValueMax ); } return DEVICE_OK; }
// gateway routine void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // declarations rs_bool success = 0; // flag for successful execution char *param_name; // parameter name pointer double *param_value; // parameter value pointer int param_len; // parameter name length int16 hcam; // camera handle uns32 param_id; // parameter ID // validate arguments if ((nrhs != 3) || (nlhs > 1)) { mexErrMsgTxt("type 'help pvcamset' for syntax"); } // obtain camera handle if (!mxIsNumeric(prhs[0])) { mexErrMsgTxt("HCAM must be numeric"); } else if (mxGetNumberOfElements(prhs[0]) != 1) { mexErrMsgTxt("HCAM must be a scalar"); } else { hcam = (int16) mxGetScalar(prhs[0]); } // obtain parameter name if (!mxIsChar(prhs[1])) { mexErrMsgTxt("PARAM must be a string"); } else if ((param_len = mxGetNumberOfElements(prhs[1])) < 1) { mexErrMsgTxt("PARAM cannot be empty"); } else { param_name = (char *) mxCalloc(param_len + 1, sizeof(char)); if (mxGetString(prhs[1], param_name, param_len + 1)) { mexErrMsgTxt("Could not retrieve PARAM from input arguments"); } } // obtain parameter value if (!mxIsDouble(prhs[2])) { mexErrMsgTxt("VALUE must be numeric"); } else if (mxGetNumberOfElements(prhs[2]) != 1) { mexErrMsgTxt("VALUE must be a scalar"); } else if ((param_value = mxGetPr(prhs[2])) == NULL) { mexErrMsgTxt("Could not retrieve VALUE from input arguments"); } // check for open camera if (!pl_cam_check(hcam)) { pvcam_error(hcam, "HCAM is not a handle to an open camera"); } // obtain parameter ID else if (!pvcam_param_id(hcam, param_name, ¶m_id)) { } // obtain parameter availability else if (!pl_get_param(hcam, param_id, ATTR_AVAIL, (void *) &attr_avail)) { pvcam_error(hcam, "Cannot obtain parameter availability"); } // do not proceed if parameter is not available else if (!attr_avail) { pvcam_error(hcam, "Parameter not available on this camera"); } // obtain parameter accessibility else if (!pl_get_param(hcam, param_id, ATTR_ACCESS, (void *) &attr_access)) { pvcam_error(hcam, "Cannot obtain parameter accessibility"); } // do not proceed if parameter is not write only or read/write else if ((attr_access != ACC_WRITE_ONLY) && (attr_access != ACC_READ_WRITE)) { pvcam_error(hcam, "Parameter cannot be set"); } // obtain parameter type else if (!pl_get_param(hcam, param_id, ATTR_TYPE, (void *) &attr_type)) { pvcam_error(hcam, "Cannot obtain parameter type"); } // obtain parameter count else if (!pl_get_param(hcam, param_id, ATTR_COUNT, (void *) &attr_count)) { pvcam_error(hcam, "Cannot obtain parameter count"); } // set success flag to return value of pvcam_set_numeric() else { success = pvcam_set_numeric(hcam, param_id, *param_value); } // set output to return value of success flag plhs[0] = mxCreateDoubleScalar((double) success); // free allocated space mxFree((void *) param_name); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // Testing of external linking of classes defined in other dll-s // don't forget to copy the current version of the externally linked dll into the same directory where // the this file is located OBuffer oCircularBuffer; char sTest[MAX_STRING_BUFFER_LENGTH]; oCircularBuffer.Test(sTest, MAX_STRING_BUFFER_LENGTH); mexPrintf("Start continous exposure"); // init stuff // prepare variables bool bVerbose = false; unsigned int expTime, lNonexposureTime, lNumOfFrames; double *ptrImageArray=NULL; char cam_name[CAM_NAME_LEN]; int16 hCam = 0; rs_bool avFlag; rs_bool retCode = FALSE; uns16* poImageBuffer = 0; uns16** poImagesBuffer[2]; OCircularBuffer oImageBuffer1, oImageBuffer2; // Usage: // read command-line arguments // correct number of parameters? if (nrhs != 11 ) { mexPrintf("\nUsage: >> nmssCAMGetImage(hCam, x,y,w,h,bx,by,expTime)"); mexPrintf("\nwhere: "); mexPrintf("\n - hCam: the camera handle (integer number)"); mexPrintf("\n - x,y: upper left corner of used rectangle on the CCD-chip"); mexPrintf("\n - w,h: width and height of that rectangle"); mexPrintf("\n - bx,by: binning factors in x- and y-direction"); mexPrintf("\n - expTime: exposure time in milliseconds"); mexPrintf("\n - lNonexposureTime: time in milliseconds until a new exposure is being taken"); mexPrintf("\n - lNumOfFrames: the number of frames to be taken"); mexPrintf("\n - verbose: if 0, no output, if 1 output generated and printed"); mexPrintf("\n"); return; } hCam = (uns16) mxGetScalar(prhs[0]); uns16 x1=(uns16) mxGetScalar(prhs[1]); uns16 y1=(uns16) mxGetScalar(prhs[2]); uns16 x2=(uns16) mxGetScalar(prhs[3]); uns16 y2=(uns16) mxGetScalar(prhs[4]); uns16 by=(uns16) mxGetScalar(prhs[5]); uns16 bx=(uns16) mxGetScalar(prhs[6]); // exposure time in the unit given by PARAM_EXP_RES (usually ms) expTime=(unsigned int) mxGetScalar(prhs[7]); lNonexposureTime = (unsigned int) mxGetScalar(prhs[8]); lNumOfFrames = (unsigned int) mxGetScalar(prhs[9]); // exit, if number of frames is smaller than 1 - no frame - no image if (lNumOfFrames < 1) throw "Number of frames should be >= 1!"; if (lNumOfFrames > 1) throw "Acquisition of more than 1 frames is not implemented fully yet! :-("; bVerbose = ((unsigned int) mxGetScalar(prhs[10]) == 1); // greeting to user if (bVerbose) mexPrintf("\n nmssCAMGetImage();\n"); try { // take picture // region of interest try { nmssCAM_CheckROIRange(hCam, x2, y2, x1, y1); } catch (...) { throw; }; rgn_type reg[1]; reg[0].s1 = x1-1; reg[0].s2 = x2-1; reg[0].sbin = bx; reg[0].p1 = y1-1; reg[0].p2 = y2-1; reg[0].pbin = by; if (bVerbose) mexPrintf("\nROI: (%d; %d) .. (%d; %d)", reg[0].s1,reg[0].s2, reg[0].p1, reg[0].p2); // Experimental: Display time resolution setting //nmssCAM_disp_time_resolution_setting(hCam); // number of images to take uns16 expTotal = 1; // total number of region definitions uns16 regTotal = 1; // exposure mode int16 mode = TIMED_MODE; // number of bytes in the "pixel stream" uns32 nNumberOfBytes = 1; // status of exposure int16 status; // uns32 na = 0; if (bVerbose) mexPrintf("\nInitializing exposure controller..."); retCode = pl_exp_init_seq(); if (retCode == 0) throw retCode; if (bVerbose) mexPrintf("\nPreparing camera for readout..."); retCode = pl_exp_setup_cont( hCam, regTotal, reg, mode , expTime, &nNumberOfBytes, CIRC_OVERWRITE); if (retCode == 0) throw retCode; // allocate memory if (bVerbose) { mexPrintf("\nReceived %d bytes", nNumberOfBytes); mexPrintf("\nsizeof(uns16)=%d", sizeof(uns16)); } poImagesBuffer = oImageBuffer.CreateFrameBuffer(lNumOfFrames, nNumberOfBytes); // ------------------------------------------------------------------------------ // start image acquisition // ------------------------------------------------------------------------------ if (bVerbose) mexPrintf("\nStarting readout..."); // start continous acquisition of frames into the circular buffer pl_exp_start_cont(hCam, poImagesBuffer, oImageBuffer.GetSize()); unsigned int k = 0; while (k < lNumOfFrames) { retCode = pl_exp_start_seq(hCam, (void*)poImagesBuffer[k]); if (retCode>0) { k++; clock_t oStartTime = clock(); clock_t oTimeOut = (expTime / 1000.0 + 60) * CLOCKS_PER_SEC; // timeout 60s if (bVerbose) mexPrintf("\nWait until camera is ready..."); // wait for exposure to finish while( pl_exp_check_status(hCam, &status, &na) && (status!=READOUT_COMPLETE) && (status != READOUT_FAILED) ) { if ((clock() - oStartTime) > oTimeOut) throw "Camera seems to be blocking!"; nmssSleep(50); } plhs[0] = mxCreateString("OK"); } else throw retCode; } // finish acq. if (bVerbose) mexPrintf("\nFinished readout..."); if (bVerbose) mexPrintf("\nUninitializing exposure controller...it needs some rest, yeah"); pl_exp_uninit_seq(); uns16 nXSize = reg[0].s2 - reg[0].s1 + 1; uns16 nYSize = reg[0].p2 - reg[0].p1 + 1; if (bVerbose) { uns16 nYSize_chip; uns16 nXSize_chip; mexPrintf("\nGet YSize of the chip"); pl_get_param(hCam, PARAM_PAR_SIZE, ATTR_CURRENT, &nYSize_chip); mexPrintf("\nGet XSize of the chip"); pl_get_param(hCam, PARAM_SER_SIZE, ATTR_CURRENT, &nXSize_chip); mexPrintf("\nChip size %d x %d", nXSize, nYSize); } //if (size != nXSize * nYSize) //{ // std::string sThrowThisError("Error while reading CCD\n"); // sThrowThisError += "Number of bytes readed is larger than X x Y!" // throw(sThrowThisError); //} plhs[1] = mxCreateNumericMatrix(nXSize, nYSize, // matrix dimensions mxUINT16_CLASS, // the camera returns unsigned int mxREAL); // no complex numbers unsigned short * poImage = (unsigned short *)mxGetData(plhs[1]); size_t bytes_to_copy = nXSize * nYSize * mxGetElementSize(plhs[1]); if (bVerbose) { //mexPrintf("\nElement size of plhs[1]= %d", mxGetElementSize(plhs[1])); mexPrintf("\nNumber of bytes read from camera: %d", bytes_to_copy); } // works only for one frame memcpy(poImage, poImagesBuffer[0], bytes_to_copy); // clean up after multiple exposure if (lNumOfFrames >= 1) pl_exp_finish_seq(hCam, poImageBuffer,0); } // camera hardware error message catch (rs_bool retCode) { nmssCAMError(nlhs, plhs); } // nanobiotech error message catch (char* msg) { //mexPrintf(msg); plhs[0] = mxCreateString("ERROR"); plhs[1] = mxCreateString(msg); } catch (std::string sErrorMsg) { //mexPrintf(msg); plhs[0] = mxCreateString("ERROR"); plhs[1] = mxCreateString(sErrorMsg.c_str()); } return; };
/***************************************************************************** * * SetLongParam_PvCam * * Description :: * This routine sets a parameter in PvCam, it takes care of data type for * the user, by taking a long from the user. * *----------------------------------------------------------------------------- */ bool SetLongParam_PvCam ( int16 handle, uns32 pvcam_cmd, long value ) { bool status = false; union { double dtmp; uns8 ubytetmp; int16 stmp; uns16 ustmp; int32 ltmp; uns32 ultmp; uns32 etmp; boolean btmp; int8 bytetmp; } temp; /* temp variable for values, which can be any data type. */ bool avail; /* PvCam available variable. */ uns16 DataType; /* PvCam data type variable. */ uns16 access; /* PvCam access variable. */ bool fcn_status; /* status of function. */ uns32 count; /* number of values in variable */ fcn_status = (bool)pl_get_param( handle, pvcam_cmd, ATTR_AVAIL, (void*)&temp ); avail = (bool)temp.btmp; if (fcn_status && avail) { pl_get_param( handle, pvcam_cmd, ATTR_TYPE, (void*)&DataType ); pl_get_param( handle, pvcam_cmd, ATTR_COUNT, (void*)&count); pl_get_param( handle, pvcam_cmd, ATTR_ACCESS, (void*)&access ); /* Make sure this is a valid parameter to set. */ if (access == ACC_READ_WRITE) { status = true; switch (DataType) { case TYPE_INT8 : /* signed char */ temp.bytetmp = (char) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.bytetmp); break; case TYPE_UNS8 : /* unsigned char */ temp.ubytetmp = (unsigned char) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.ubytetmp); break; case TYPE_INT16 : /* short */ temp.stmp = (short) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.stmp); break; case TYPE_UNS16 : /* unsigned short */ temp.ustmp = (unsigned short) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.ustmp); break; case TYPE_INT32 : /* long */ temp.ltmp = (long) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.ltmp); break; case TYPE_UNS32 : /* unsigned long */ temp.ultmp = (unsigned long) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.ultmp); break; case TYPE_FLT64 : /* double */ temp.dtmp = (double) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.dtmp); break; case TYPE_BOOLEAN : /* Boolean value */ temp.btmp = (boolean) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.btmp); break; case TYPE_ENUM : /* Can be treat as unsigned long */ temp.ultmp = (unsigned long) value; pl_set_param(handle, pvcam_cmd, (void *)&temp.ultmp); break; default: /* ptrs not supported yet. */ case TYPE_VOID_PTR : /* ptr to void */ case TYPE_VOID_PTR_PTR :/* void ptr to a ptr. */ case TYPE_CHAR_PTR : /* char */ status = false; break; } } } return(status); } /* end SetLongParam_PvCam */