コード例 #1
0
int IdsSourceSink::SetInterval(int msec) {
    double fps = 1000.0/((double)msec);
    double newfps;
    is_SetFrameRate(hCam,fps,&newfps);
    camTimeStep=1000.0/newfps;
    return camTimeStep;
}
コード例 #2
0
bool FlosIDSAdaptor::startCapture()
{	
    if(!isOpen()) {
        return false;
    }

    UINT   nMode;
    INT    nRet = IS_SUCCESS;
    double dNominal = 128;
    double dEnable  = 1;
            
    is_SetDisplayMode(m_deviceID, IS_SET_DM_DIB);
    is_SetExternalTrigger(m_deviceID, IS_SET_TRIGGER_SOFTWARE);

    nMode = IO_FLASH_MODE_TRIGGER_HI_ACTIVE;
    is_IO(m_deviceID, IS_IO_CMD_FLASH_SET_MODE, (void *)&nMode, sizeof(nMode));

    is_SetAutoParameter(m_deviceID, IS_SET_ENABLE_AUTO_GAIN, &dEnable, 0);
    is_SetAutoParameter(m_deviceID, IS_SET_AUTO_REFERENCE, &dNominal, 0);

    is_SetColorMode(m_deviceID, IS_CM_BGR8_PACKED);
    is_SetFrameRate(m_deviceID, 20, NULL);

    if((is_CaptureVideo(m_deviceID, IS_DONT_WAIT) != IS_SUCCESS)) {
        imaqkit::adaptorWarn("FlosIDSAdaptor:startCapture", "Could not start capturing.");
        return false;
    }

    setAcquisitionActive(true);
    PostThreadMessage(m_acquireThreadID, WM_USER, 0, 0);

    return true;
}
コード例 #3
0
ファイル: uEyeCapture.cpp プロジェクト: Aldrog/corecvs
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;
}
コード例 #4
0
ファイル: cameraApi.cpp プロジェクト: eberlid/flouryzer
void CameraApi::setFrameRate(double frameRate, double* newFrameRate)
{
	INT ret;
	if(mhCam != 0)
	{
		if(frameRate > 0.0)
		{
			ret = is_SetFrameRate(mhCam, frameRate, newFrameRate);
		}
		else
		{
			double stdRate;
			is_SetFrameRate(mhCam, IS_GET_DEFAULT_FRAMERATE, &stdRate);
			is_SetFrameRate(mhCam, stdRate, newFrameRate);
		}
	}
	else
		*newFrameRate = frameRate;
}
コード例 #5
0
ファイル: ofxUeye.cpp プロジェクト: paulobarcelos/ofxUeye
//////////////////////////////////////////////////////////////////////////////////
// setOptimalCameraTiming --------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////
void ofxUeye::setOptimalCameraTiming(bool value)
{
	if(value){
		int pixelClock;
		double fps;
		int result = is_SetOptimalCameraTiming (m_hCam, IS_BEST_PCLK_RUN_ONCE, 10000, &pixelClock, &fps);
		is_SetPixelClock (m_hCam, pixelClock);
		is_SetFrameRate (m_hCam, fps, &fps);
	}
}
コード例 #6
0
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;
    
}
コード例 #7
0
ファイル: ofxUeye.cpp プロジェクト: paulobarcelos/ofxUeye
//////////////////////////////////////////////////////////////////////////////////
// setFPS ------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////
int ofxUeye::setFPS(double fps)
{
	double newFPS;
	int result;
	result = is_SetFrameRate (m_hCam, fps, &newFPS);
	if(result == IS_SUCCESS)
		ofLog(OF_LOG_WARNING, "ofxUeye - setFPS - (%f) Success.", (float)newFPS);
	else
		ofLog(OF_LOG_WARNING, "ofxUeye - setFPS - Couldn't apply (%f).", (float)fps);
	return result;
}
コード例 #8
0
static int ids_core_Camera_setfps(ids_core_Camera *self, PyObject *value, void *closure) {
    int ret;
    double realfps;

    ret = is_SetFrameRate(self->handle, PyFloat_AsDouble(value), &realfps);
    switch (ret) {
        case IS_SUCCESS:
            return 0;
        case IS_INVALID_CAMERA_HANDLE:
            PyErr_SetString(PyExc_ValueError, "Invalid camera handle");
            return -1;
        case IS_INVALID_MODE:
            PyErr_SetString(PyExc_ValueError, "Camera is in standby mode, function not allowed.");
            return -1;
        case IS_INVALID_PARAMETER:
            PyErr_SetString(PyExc_ValueError, "One of the submitted parameters is outside the valid range or is not supported for this sensor or is not available in this mode.");
            return -1;
        default:
            PyErr_SetString(PyExc_ValueError, "An error occurred when setting fps.");
            return -1;
    }
}
コード例 #9
0
INT UEyeCamDriver::setFrameRate(bool& auto_frame_rate, double& frame_rate_hz) {
    if (!isConnected())
        return IS_INVALID_CAMERA_HANDLE;

    INT is_err = IS_SUCCESS;

    double pval1 = 0, pval2 = 0;
    double minFrameTime, maxFrameTime, intervalFrameTime, newFrameRate;

    // Make sure that auto shutter is enabled before enabling auto frame rate
    bool autoShutterOn = false;
    is_SetAutoParameter(cam_handle_, IS_GET_ENABLE_AUTO_SENSOR_SHUTTER, &pval1, &pval2);
    autoShutterOn |= (pval1 != 0);
    is_SetAutoParameter(cam_handle_, IS_GET_ENABLE_AUTO_SHUTTER, &pval1, &pval2);
    autoShutterOn |= (pval1 != 0);
    if (!autoShutterOn) {
        auto_frame_rate = false;
    }

    // Set frame rate / auto
    pval1 = auto_frame_rate;
    if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_SENSOR_FRAMERATE,
                                      &pval1, &pval2))
        != IS_SUCCESS) {
        if ((is_err = is_SetAutoParameter(cam_handle_, IS_SET_ENABLE_AUTO_FRAMERATE,
                                          &pval1, &pval2))
            != IS_SUCCESS) {
            std::cerr << "Auto frame rate mode is not supported for UEye camera '"
                      << cam_name_ << "' (" << err2str(is_err) << ")"
                      << std::endl;
            auto_frame_rate = false;
        }
    }
    if (!auto_frame_rate) {
        // Make sure that user-requested frame rate is achievable
        if ((is_err = is_GetFrameTimeRange(cam_handle_, &minFrameTime,
                                           &maxFrameTime, &intervalFrameTime))
            != IS_SUCCESS) {
            std::cerr << "Failed to query valid frame rate range from UEye camera '"
                      << cam_name_ << "'" << std::endl;
            return is_err;
        }
        CAP(frame_rate_hz, 1.0 / maxFrameTime, 1.0 / minFrameTime);

        // Update frame rate
        if ((is_err = is_SetFrameRate(cam_handle_, frame_rate_hz, &newFrameRate))
            != IS_SUCCESS) {
            std::cerr << "Failed to set frame rate to " << frame_rate_hz
                      << " MHz for UEye camera '" << cam_name_ << "'" << std::endl;
            return is_err;
        } else if (frame_rate_hz != newFrameRate) {
            frame_rate_hz = newFrameRate;
        }
    }

    std::cout << "Updated frame rate: "
              << ((auto_frame_rate) ? "auto" : to_string(frame_rate_hz))
              << " Hz" << std::endl;

    return is_err;
}
コード例 #10
0
INT GetFrameRate( HIDS hCam, double &fr) { 
	return is_SetFrameRate( hCam, IS_GET_FRAMERATE, &fr); 
}
コード例 #11
0
ファイル: uEyeCapture.cpp プロジェクト: Aldrog/corecvs
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);
}
コード例 #12
0
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;
    
}