ueyeclass.cpp

// Piranha.cpp: implementation of the CuEye class.
//
//////////////////////////////////////////////////////////////////////
//#include "stdafx.h"

#include "ueyeclass.hh"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CuEye::CuEye () 
{
  m_hu = 0;

}


CuEye::~CuEye ()
{
}


int CuEye::InitCamera (int nId)
{
  int nRet = IS_CANT_OPEN_DEVICE;
  HIDS hu = (HIDS) nId;

  if((m_hu == 0)) 
  {
    nRet = is_InitCamera (&hu,0);

    if (nRet == IS_SUCCESS)
    {
      m_hu = hu;
      // Disable Autoexit
      is_EnableAutoExit( m_hu, IS_DISABLE_AUTO_EXIT );
    }
    
     
  }
  

  return nRet;
}


int CuEye::ExitCamera ()
{
  int nRet = IS_CANT_CLOSE_DEVICE;

  if(m_hu != 0)
  {
    nRet = is_ExitCamera (m_hu);
    m_hu = 0;
  }

  return nRet;
}


int CuEye::SetErrorReport (int lMode)
{
  return is_SetErrorReport (m_hu, lMode);
}


int CuEye::GetErrorText (int lErr, char* pcErrText)
{
  return is_GetError(m_hu,&lErr,&pcErrText);
}
int CuEye::GetNumberOfCameras (int* plNumCameras)
{
  return is_GetNumberOfCameras (plNumCameras);
}


int CuEye::GetDllVersion (int* plDllVers)
{
  *plDllVers = is_GetDLLVersion();
  return IS_SUCCESS;
}


int CuEye::GetPciSlot (int* plSlot)
{
  if(plSlot != 0)
    *plSlot = 0;

  return IS_FUNCTION_NOT_SUPPORTED_YET;
}


int CuEye::GetIRQ (int* plIRQ)
{
  if(plIRQ != 0)
    *plIRQ = 0;

  return IS_FUNCTION_NOT_SUPPORTED_YET;
}


int CuEye::GetColorDepth (int* plBpp, int* plColFormat)
{
  return is_GetColorDepth (m_hu, plBpp, plColFormat);
}


int CuEye::CameraStatus (int lInfo, long lValue)
{
  return is_CameraStatus (m_hu, lInfo, (ULONG)lValue);
}


int CuEye::GetCameraType ()
{
  return is_GetCameraType (m_hu);
}


int CuEye::GetOsVersion ()
{
  BIASERR("Not longer defined in SDK.");
  //return is_GetOsVersion ();
  return -1;
}


int CuEye::SetBrightness (int lBright)
{
  BIASERR("Not longer defined in SDK.");
  //return is_SetBrightness (m_hu, lBright);
  return -1;
}


int CuEye::SetContrast (int lCont)
{
  BIASERR("Not longer supported in current SDK.");
  //return is_SetContrast (m_hu, lCont);
  return -1;
}


int CuEye::SetGamma (int lGamma)
{
  return is_Gamma(m_hu, IS_GAMMA_CMD_SET, (void *) &lGamma, sizeof(int));
  //return is_SetGamma (m_hu, lGamma);
}


int CuEye::SetWhiteBalance( INT nMode )
{
  return is_SetWhiteBalance(m_hu, nMode);
}


int CuEye::SetWhiteBalanceMultipliers(double dblRed, double dblGreen, double dblBlue )
{
  return is_SetWhiteBalanceMultipliers(m_hu, dblRed, dblGreen, dblBlue);
}


int CuEye::SetColorMode (int lMode)
{
  return is_SetColorMode (m_hu, lMode);
}


int CuEye::InitEvent (HANDLE hEv, int nWhich)
{
  return is_InitEvent (m_hu, hEv, nWhich);
}


int CuEye::EnableEvent (int nWhich)
{
  return is_EnableEvent (m_hu, nWhich);
}


int CuEye::DisableEvent (int nWhich)
{
  return is_DisableEvent (m_hu, nWhich);
}


int CuEye::ExitEvent (int nWhich)
{
  return is_ExitEvent (m_hu, nWhich);
}


int CuEye::EnableMessage (int nWhich, HWND hwnd)
{
  return is_EnableMessage(m_hu, nWhich, hwnd);
}


int CuEye::EnableAutoExit (int nMode)
{
  return is_EnableAutoExit(m_hu, nMode);
}


int CuEye::SetImageSize (int lWidth, int lHeight)
{

  IS_RECT rectAOI;

  rectAOI.s32X     = 0;
  rectAOI.s32Y     = 0;
  rectAOI.s32Width = lWidth;
  rectAOI.s32Height = lHeight;

  int nRet = is_AOI(m_hu, IS_AOI_IMAGE_SET_AOI, (void*)&rectAOI, sizeof(rectAOI));

  return nRet;
}


int CuEye::SetImagePos (int lPosX, int lPosY)
{
  //BIASERR("Not longer supported in current SDK.");
  //return is_SetImagePos (m_hu, lPosX, lPosY);
  
  IS_POINT_2D p;
  p.s32X = lPosX;
  p.s32Y = lPosY;

  return is_AOI(m_hu, IS_AOI_IMAGE_SET_POS, (void *)&p, sizeof(p));
  //return -1;
}


int CuEye::SetDisplayMode (int Mode)
{
  return is_SetDisplayMode (m_hu, Mode);
}


int CuEye::SetDisplayWindow (HWND hWnd)
{
  return is_SetHwnd (m_hu, hWnd);
}


int CuEye::SetDisplayKeyColor (int lKeyCol)
{
  BIASERR("Not longer supported in current SDK.");
  //return is_SetKeyColor (m_hu, (lKeyCol & 0x00FF0000) >> 16, (lKeyCol & 0x0000FF00) >> 8, lKeyCol & 0x000000FF);
  return -1;
}


int CuEye::SetMainDisplayWindow (HWND hWnd)
{
  BIASERR("Not longer defined in SDK.");
  //return is_SetParentHwnd (m_hu, hWnd);
  return -1;
}


int CuEye::UpdateDisplay ()
{
  BIASERR("Not longer supported in current SDK.");
  //return is_UpdateDisplay (m_hu);
  return -1;
}


int CuEye::CaptureVideo (int lWait)
{
  return is_CaptureVideo (m_hu, lWait);
}


int CuEye::StopLiveVideo (int lWait)
{
  return is_StopLiveVideo (m_hu, lWait);
}


int CuEye::FreezeVideo (int lWait)
{
    return is_FreezeVideo (m_hu, lWait);

}

int CuEye::SetCaptureMode (int lMode)
{
  BIASERR("Not longer defined in SDK.");
  //  return is_SetCaptureMode (m_hu, lMode);
  return -1;
}


int CuEye::GetAllPixelClocks(unsigned int* nPixelClockList)
{
  return is_PixelClock(m_hu, IS_PIXELCLOCK_CMD_GET_LIST, nPixelClockList, 150*sizeof(UINT));
}


int CuEye::SetEdgeEnhancement(int lMode)
{
  BIASERR("Not longer supported in current SDK.");
  //return is_SetEdgeEnhancement(m_hu, lMode);
  return -1;
}

int CuEye::AllocImageMem (int lWidth, int lHeight, int lBpp, char** ppcImgMem, int* plID)
{
  return is_AllocImageMem (m_hu, lWidth, lHeight, lBpp, ppcImgMem, plID);
}


int CuEye::FreeImageMem (char* pcMem, int lID)
{
  return is_FreeImageMem (m_hu, pcMem, lID);
}


int CuEye::SetImageMem (char* pcMem, int lID)
{
  return is_SetImageMem (m_hu, pcMem, lID);
}


int CuEye::GetActiveImageMem (char** ppcImgMem, int* plID)
{
  return is_GetActiveImageMem (m_hu, ppcImgMem, plID);
}

int CuEye::GetActSeqBuffer(char** ppcImgMem, int* plID){
  INT dummy;
  return is_GetActSeqBuf(m_hu, &dummy, ppcImgMem,ppcImgMem);
}

int CuEye::InquireImageMem (char* pcMem, int lID, int* plX, int* plY, int* plBpp, int* plPitch)
{
  return is_InquireImageMem (m_hu, pcMem, lID, plX, plY, plBpp, plPitch);
}


int CuEye::ReadTriggerPort (int* plIn)
{
  int nRet = IS_SUCCESS;

  if(plIn != 0)
    *plIn = is_SetExternalTrigger (m_hu, IS_GET_TRIGGER_INPUTS);
  else
    nRet = IS_NULL_POINTER;

  return nRet;
}



int CuEye::ReadDigitalPort (int* plIn)
{
  BIASERR("Not longer supported in current SDK.");
//  int nRet = IS_SUCCESS;

//  if(plIn != 0)
//    *plIn = is_SetIO (m_hu, IS_GET_IO);
//  else
//    nRet = IS_NULL_POINTER;

//  return nRet;
  return -1;
}


int CuEye::WriteDigitalPort (int lOut)
{
  BIASERR("Not longer supported in current SDK.");
//return is_SetIO (m_hu, lOut);
  return -1;
}


int CuEye::SetExternalTrigger (int lMode)
{
  return is_SetExternalTrigger (m_hu, lMode);
}


int CuEye::GetCameraInfo (CAMINFO* pInfo)
{
  int nRet = IS_SUCCESS;

  if(pInfo != 0)
    nRet = is_GetCameraInfo (m_hu, pInfo);
  else
    nRet = IS_NULL_POINTER;

  return nRet;
}


int CuEye::ReadEEPROM (int lAdr, char* pcBuf, int lCount)
{
  int nRet = IS_SUCCESS;

  if(pcBuf != 0)
    nRet = is_ReadEEPROM (m_hu, lAdr, pcBuf, lCount);
  else
    nRet = IS_INVALID_PARAMETER;

  return nRet;
}


int CuEye::WriteEEPROM (int lAdr, char* pcBuf, int lCount)
{
  int nRet = IS_SUCCESS;

  if(pcBuf != 0)
    nRet = is_WriteEEPROM (m_hu, lAdr, pcBuf, lCount);
  else
    nRet = IS_INVALID_PARAMETER;

  return nRet;
}


int CuEye::SaveImage (char* pcFile)
{
  BIASERR("Not longer supported in current SDK.");
//  return is_SaveImage (m_hu, pcFile);
  return -1;
}


int CuEye::LoadImage (char* pcFile)
{
  BIASERR("Not longer supported in current SDK.");
//return is_LoadImage (m_hu, pcFile);
  return -1;
}


int CuEye::SaveImageMem (char* pcFile, char* pcMem, int lID)
{
  BIASERR("Not longer supported in current SDK.");
//  return is_SaveImageMem (m_hu, pcFile, pcMem, lID);
  return -1;
}


int CuEye::RenderBitmap (int nMemID, HWND hwnd, int nMode)
{
  return is_RenderBitmap(m_hu, nMemID, hwnd, nMode);
}


int CuEye::SetScaler (int nMode)
{
  BIASERR("Not longer defined in SDK.");
  //if(nMode)
  //  return is_SetScaler(m_hu, IS_SET_SCALER_ON, IS_SET_SCALER_ON);
  //else
  //  return is_SetScaler(m_hu, IS_SET_SCALER_OFF, IS_SET_SCALER_OFF);
  return -1;
}


int CuEye::SetPixelClock(unsigned int nClock)
{
  return is_PixelClock(m_hu, IS_PIXELCLOCK_CMD_SET, (void*)&nClock, sizeof(nClock));
}


int CuEye::SetFrameRate(double dFr, double* pdFrNew)
{
  return is_SetFrameRate(m_hu, dFr, pdFrNew);
}


int CuEye::SetExposureTime(double EXP, double* newEXP)
{
  return is_Exposure (m_hu, IS_EXPOSURE_CMD_SET_EXPOSURE, (void*)&EXP, sizeof(EXP));
}

double CuEye::GetExposureTime()
{
  double newexp =0.0;

  is_Exposure(m_hu, IS_EXPOSURE_CMD_GET_EXPOSURE, (void*)&newexp, sizeof(newexp));

  return newexp;
}

int CuEye::SetGain(int gainMaster)
{
    int ret =0;
    ret = is_SetHardwareGain(m_hu, gainMaster, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER, IS_IGNORE_PARAMETER);
    return ret;
}

int CuEye::SetGain(int gainMaster, int gainRed, int gainGreen, int gainBlue)
{
    int ret =0;
    ret = is_SetHardwareGain(m_hu, gainMaster, gainRed, gainGreen, gainBlue);
    return ret;
}

int CuEye::SetGain(double gain)
{
    int ret =0;

    BIASERR("Do not use this method, use SetGain(int) instead!");
    ret = is_SetHardwareGain(m_hu,(int) gain,IS_IGNORE_PARAMETER,IS_IGNORE_PARAMETER,IS_IGNORE_PARAMETER);
    return ret;
}

double CuEye::GetGain()
{
   return is_SetHardwareGain(m_hu,IS_GET_MASTER_GAIN,IS_IGNORE_PARAMETER,IS_IGNORE_PARAMETER,IS_IGNORE_PARAMETER);
}


int CuEye::Renumerate( int reserved )
{
  // return is_Renumerate( m_hu, reserved );
  return -1;
}


int CuEye::GetSensorInfo( PSENSORINFO pInfo )
{
  return is_GetSensorInfo( m_hu, pInfo );
}