diff --git a/TIAS_Imager2.sln b/TIAS_Imager2.sln new file mode 100644 index 0000000..d4b8424 --- /dev/null +++ b/TIAS_Imager2.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TIAS_Imager2", "TIAS_Imager2\TIAS_Imager2.vcxproj", "{F8F496AA-B04D-4793-9723-8EE364D338C3}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Debug|Win32.ActiveCfg = Debug|Win32 + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Debug|Win32.Build.0 = Debug|Win32 + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Debug|x64.ActiveCfg = Debug|x64 + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Debug|x64.Build.0 = Debug|x64 + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Release|Win32.ActiveCfg = Release|Win32 + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Release|Win32.Build.0 = Release|Win32 + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Release|x64.ActiveCfg = Release|x64 + {F8F496AA-B04D-4793-9723-8EE364D338C3}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/TIAS_Imager2/Config.txt b/TIAS_Imager2/Config.txt new file mode 100644 index 0000000..6b3218e --- /dev/null +++ b/TIAS_Imager2/Config.txt @@ -0,0 +1,20 @@ +CONTOUR_EXE :C:\TIAS_Bin\imager\contourTongue\contourTongue.exe +SHOKEN_EXE :C:\TIAS_Bin\imager\Shoken2\shoken2.exe +SAVE_PATH_BASE :C:\TIAS_Data +EXPOSURE :20.0 +GAIN :2.0 +GAIN_B :1.5 +GAIN_G :1.0 +GAIN_R :1.3 +GAMMA :1.0 +RECORD_FPS :10.0 +WHITE_BAL_VALUE :150.0 +NUM_SHOTS_LONG :200 +NUM_SHOTS_SHORT :50 +CHECKER_X1 :720 +CHECKER_Y1 :180 +CHECKER_X24 :120 +CHECKER_Y24 :1230 +LED_INTERVAL :10 +CHECKER_DETECT :2.5 +CONTROLLER_REV :1 \ No newline at end of file diff --git a/TIAS_Imager2/Imager.cpp b/TIAS_Imager2/Imager.cpp new file mode 100644 index 0000000..c42ae03 --- /dev/null +++ b/TIAS_Imager2/Imager.cpp @@ -0,0 +1,806 @@ +// Imager.cpp : �����t�@�C�� +// + +#include "stdafx.h" +#include "TIAS_Imager2.h" +#include "Imager.h" +#include +#include +#pragma comment(lib, "imagehlp.lib") + +// CImager�R���X�g���N�^ +CImager::CImager() + : m_hCam(NULL) + , m_StreamBufSize(0) + , m_StreamWrite(0) + , m_StreamW(0) + , m_StreamH(0) + , m_RawBuf(NULL) + , m_RotateBuf(NULL) + , m_FpsPreview(0) + , m_TimerResolution(0) + , m_TimerID(NULL) + , m_NumShots(0) + , m_ShotCount(0) + , m_RecordCount(0) + , m_SaveCountNormal(0) + , m_SaveCountGloss(0) + , m_CalibCount(0) + , m_RecordBuf(NULL) + , m_RecordTiming(NULL) + , m_WorkerThread(NULL) + , m_QuitSignal(FALSE) + //, m_AbortSignal(FALSE) + , m_Status(ST_NOCALIB) + , m_Event(EV_NONE) + , m_SubjectID(_T("")) + , m_Gender(0) + , m_SavePath(_T("")) + , m_InfoPath(_T("")) + , m_cdContourExe(CD_CONTOUR_EXE) + , m_cdShokenExe(CD_SHOKEN_EXE) + , m_cdSavePathBase(CD_SAVE_PATH_BASE) + , m_cdExposure(CD_EXPOSURE) + , m_cdGain(CD_GAIN) + , m_cdGainB(CD_GAIN_B) + , m_cdGainG(CD_GAIN_G) + , m_cdGainR(CD_GAIN_R) + , m_cdGamma(CD_GAMMA) + , m_cdRecordFps(CD_RECORD_FPS) + , m_cdWhiteBalValue(CD_WHITE_BAL_VALUE) + , m_cdCheckerDetect(CD_CHECKER_DETECT) + , m_cdNumShotsLong(CD_NUM_SHOTS_LONG) + , m_cdNumShotsShort(CD_NUM_SHOTS_SHORT) + , m_cdCheckerX1(CD_CHECKER_X1) + , m_cdCheckerY1(CD_CHECKER_Y1) + , m_cdCheckerX24(CD_CHECKER_X24) + , m_cdCheckerY24(CD_CHECKER_Y24) + , m_cdLedInterval(CD_LED_INTERVAL) + , m_cdLedOn(CD_LED_ON) + , m_cdLaserOn(CD_LASER_ON) +{ + for (int i = 0; i < DOUBLE_BUFFER; i ++) m_StreamBuf[i] = NULL; +} + +// CImager�f�X�g���N�^ +CImager::~CImager() +{ + // �^�C�}�[��� + timeEndPeriod(m_TimerResolution); + // �J�����ؒf + if (m_hCam != NULL) LucamCameraClose(m_hCam); + // ��������� + for (int i = 0; i < DOUBLE_BUFFER; i ++) SAFE_DELETEA(m_StreamBuf[i]); + SAFE_DELETEA(m_RawBuf); + SAFE_DELETEA(m_RotateBuf); + if (m_RecordBuf) + for (int i = 0; i < m_cdNumShotsLong; i ++) SAFE_DELETEA(m_RecordBuf[i]); + SAFE_DELETEA(m_RecordBuf); + SAFE_DELETEA(m_RecordTiming); +} + +// ������ +// �ߒl TRUE ����I�� FALSE �G���[���� +BOOL CImager::Init() +{ + BOOL rv = TRUE; + + try { + // �^�C�}�[������ + TIMECAPS timercaps; + ZeroMemory(&timercaps, sizeof(timercaps)); + timeGetDevCaps(&timercaps, sizeof(TIMECAPS)); + m_TimerResolution = timercaps.wPeriodMin; + TRACE("Timer resolution: %d ms\n", m_TimerResolution); + timeBeginPeriod(m_TimerResolution); + + // �J���������� + Valid((m_hCam = LucamCameraOpen(CAMERA_NUMBER)) != NULL, _T("�J�����ڑ����s")); +// Valid(LucamGpioConfigure(m_hCam, 0x3), "LucamGpioConfigure���s"); + Valid(LucamGpioWrite(m_hCam, LED_LASER_OFF), _T("LucamGpioWrite���s")); + + // �ݒ�t�@�C���ǂݍ��� + Valid(this->LoadConfig(), _T("�ݒ�t�@�C���ǂݍ��ݎ��s")); + + // �v���r���[�p�����[�^ + FLOAT fFrameRate = 0; + Valid(LucamGetFormat(m_hCam, &m_Fmt, &fFrameRate), _T("LucamGetFormat���s")); + m_Fmt.width = PREVIEW_WIDTH; + m_Fmt.height = PREVIEW_HEIGHT; + m_Fmt.binningX = PREVIEW_BINNING_X; + m_Fmt.binningY = PREVIEW_BINNING_Y; + m_StreamW = PREVIEW_WIDTH / PREVIEW_BINNING_X; + m_StreamH = PREVIEW_HEIGHT / PREVIEW_BINNING_Y; + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_EXPOSURE, m_cdExposure, NULL), + _T("LucamSetProperty LUCAM_PROP_EXPOSURE���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_GAIN, m_cdGain, NULL), + _T("LucamSetProperty LUCAM_PROP_GAIN���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_BLUE, m_cdGainB, NULL), + _T("LucamSetProperty LUCAM_PROP_GAIN_BLUE���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_GREEN1, m_cdGainG, NULL), + _T("LucamSetProperty LUCAM_PROP_GAIN_GREEN1���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_GREEN2, m_cdGainG, NULL), + _T("LucamSetProperty LUCAM_PROP_GAIN_GREEN2���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_RED, m_cdGainR, NULL), + _T("LucamSetProperty LUCAM_PROP_GAIN_RED���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_GAMMA, m_cdGamma, NULL), + _T("LucamSetProperty LUCAM_PROP_GAMMA���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_FLIPPING, LUCAM_PROP_FLIPPING_NONE, NULL), + _T("LucamSetProperty LUCAM_PROP_FLIPPING���s")); + Valid(LucamSetProperty(m_hCam, LUCAM_PROP_DIGITAL_GAIN, 1.0, NULL), + _T("LucamSetProperty LUCAM_PROP_DIGITAL_GAIN���s")); + fFrameRate = 10000.F; + Valid(LucamSetFormat(m_hCam, &m_Fmt, fFrameRate), _T("LucamSetFormat���s")); + + // �r�f�I�o�b�t�@ + m_RawBufSize = m_StreamW * m_StreamH; + m_StreamBufSize = m_RawBufSize * COLOR_CH; + Valid((m_RawBuf = new BYTE[m_RawBufSize]) != NULL, _T("�������m��1���s")); + for (int i = 0; i < DOUBLE_BUFFER; i ++) + Valid((m_StreamBuf[i] = new BYTE[m_StreamBufSize]) != NULL, _T("�������m��2���s")); + Valid((m_RotateBuf = new BYTE[m_StreamBufSize]) != NULL, _T("�������m��3���s")); + Valid((m_RecordBuf = new BYTE*[m_cdNumShotsLong]) != NULL, _T("�������m��4���s")); + for (int i = 0; i < m_cdNumShotsLong; i ++) { + Valid((m_RecordBuf[i] = new BYTE[m_RawBufSize]) != NULL, _T("�������m��5���s")); + } + Valid((m_RecordTiming = new DWORD [m_cdNumShotsLong]) != NULL, _T("�������m��6���s")); + + // �L�^�B�e�p�����[�^ + m_Sshot.bufferlastframe = FALSE; + m_Sshot.exposure = m_cdExposure; + m_Sshot.exposureDelay = 0.0; + m_Sshot.flReserved1 = 0.0; + m_Sshot.flReserved2 = 0.0; + m_Sshot.format.width = PREVIEW_WIDTH; + m_Sshot.format.height = PREVIEW_HEIGHT; + m_Sshot.format.pixelFormat = LUCAM_PF_8; + m_Sshot.format.binningX = 1; + m_Sshot.format.binningY = 1; + m_Sshot.format.flagsX = 0; + m_Sshot.format.flagsY = 0; + m_Sshot.format.xOffset = 0; + m_Sshot.format.yOffset = 0; + m_Sshot.gain = m_cdGain; + m_Sshot.gainBlue = m_cdGainB; + m_Sshot.gainGrn1 = m_cdGainG; + m_Sshot.gainGrn2 = m_cdGainG; + m_Sshot.gainRed = m_cdGainR; + m_Sshot.shutterType = LUCAM_SHUTTER_TYPE_ROLLING; + m_Sshot.strobeDelay = 0.0; + m_Sshot.timeout = 3000; + m_Sshot.ulReserved1 = 0; + m_Sshot.ulReserved2 = 0; + m_Sshot.useHwTrigger = FALSE; + m_Sshot.useStrobe = FALSE; + + // ��ƃX���b�h�J�n + m_WorkerThread = AfxBeginThread(this->WorkerTHentry, this); + + // �v���r���[�J�n + Valid(LucamAddStreamingCallback(m_hCam, StreamCBentry, this) != -1, + _T("LucamAddRgbPreviewCallback���s")); + Valid(LucamStreamVideoControl(m_hCam, START_STREAMING, NULL), _T("LucamStreamVideoControl���s")); + + } catch (CString errmsg) { + errmsg.Append(_T("\n\n�\�t�g�E�F�A���I�����܂��D")); + AfxMessageBox(errmsg, MB_OK | MB_ICONEXCLAMATION); + rv = FALSE; + } + + return rv; +} + +// �B�e�f�[�^���� +void CImager::StreamCB(BYTE *pData) +{ + // �񐔋L�^ + static int count = 0; + ++ count; + + // �L�^ + if (m_Status == ST_MEASURING) { + m_RecordTiming[m_ShotCount] = timeGetTime(); + memcpy(m_RecordBuf[m_ShotCount], pData, m_RawBufSize); +// TRACE("Record %d %dms\n", m_ShotCount, m_RecordTiming[m_ShotCount]-m_RecordTiming[0]); + if (++ m_ShotCount >= m_NumShots) this->EndRecord(); + // LED���� + if (m_ShotCount % (m_cdLedInterval) == m_cdLedInterval - 1) + LucamGpioWrite(m_hCam, m_cdLedOn); + if (m_ShotCount % (m_cdLedInterval) == 0) + LucamGpioWrite(m_hCam, LED_LASER_OFF); + } + + // RGB�ϊ� + LUCAM_CONVERSION lcConversion; + lcConversion.CorrectionMatrix = LUCAM_CM_FLUORESCENT; +// lcConversion.DemosaicMethod = LUCAM_DM_HIGH_QUALITY; + lcConversion.DemosaicMethod = LUCAM_DM_FAST; + LucamConvertFrameToRgb24(m_hCam, m_RotateBuf, pData, m_StreamW, m_StreamH, + m_Fmt.pixelFormat, &lcConversion); + + // 90�x��] + this->RotateImage(m_RotateBuf, m_StreamBuf[m_StreamWrite]); + + // �Z�� + if (m_Status == ST_CALIBRATING) { + if (count % CALIB_INTERVAL == 0) this->Calibrate(); + } + if (m_Status == ST_NOCALIB || m_Status == ST_CALIBRATING) + this->DrawCalibLine(m_StreamBuf[m_StreamWrite]); + + // �o�b�t�@�؂�ւ� + m_StreamWrite = (m_StreamWrite + 1) % DOUBLE_BUFFER; + + // FPS�v�� + const int FpsCount = 20; + static DWORD lastTime = GetTickCount(); + if (count % FpsCount == 0) { + DWORD now = GetTickCount(); + m_FpsPreview = 1000.0F * FpsCount / (now - lastTime); + lastTime = now; + } +} + +// ���[�J�[�X���b�h +void CImager::WorkerTH() +{ + BYTE* rotateBuf = new BYTE [m_StreamBufSize]; + BYTE* saveBuf = new BYTE [m_StreamBufSize]; + + while(!m_QuitSignal) { + if (m_ShotCount > m_RecordCount) { + + // RGB�ϊ� + LUCAM_CONVERSION lcConversion; + lcConversion.CorrectionMatrix = LUCAM_CM_FLUORESCENT; + lcConversion.DemosaicMethod = LUCAM_DM_HIGHER_QUALITY; + LucamConvertFrameToRgb24(m_hCam, rotateBuf, m_RecordBuf[m_RecordCount], + m_StreamW, m_StreamH, m_Fmt.pixelFormat, &lcConversion); + + // ��] + this->RotateImage(rotateBuf, saveBuf); + + // �ۑ� + ++ m_RecordCount; + //const int FN_BUF_SIZE = 1024; + //TCHAR filename[FN_BUF_SIZE]; + CString fname; + if (m_RecordCount % m_cdLedInterval > 0) { + // �ʏ�B�e + fname.Format(_T("%s%04d.%s"), PREFIX_NORMAL, + ++ m_SaveCountNormal, IMAGE_TYPE); + } else { + // ����B�e + fname.Format(_T("%s%04d.%s"), PREFIX_GLOSS, + ++ m_SaveCountGloss, IMAGE_TYPE); + } + CString fpath = m_SavePath + _T("\\") + fname; + +#ifdef _UNICODE + LucamSaveImageWEx(m_hCam, m_StreamH, m_StreamW, LUCAM_PF_24, + saveBuf, fpath.GetBuffer(0)); +#else + LucamSaveImageEx(m_hCam, m_StreamH, m_StreamW, LUCAM_PF_24, + saveBuf, fpath.GetBuffer(0)); +#endif + + // �^�C�~���O�L�^ + CStdioFile file; + file.Open(m_InfoPath, CFile::modeWrite | CFile::shareDenyWrite); + file.SeekToEnd(); + CString buf; + buf.Format(_T("%8d,%8d, %s\n"), m_RecordCount, + m_RecordTiming[m_RecordCount - 1] - m_RecordTiming[0], fname); + file.WriteString(buf); + file.Close(); + + // �Z���f�[�^�ۑ� + if (m_Event == EV_CALIB_DONE) this->WriteCalibData(saveBuf); + + // �I������ + if (m_RecordCount >= m_NumShots) { + if (m_Event == EV_MEAS_DONE) m_Event = EV_SAVE_DONE; + m_Status = ST_PREVIEW; + + // �����ԎB�e�̂��ƌ`����̓v���O�����N�� + if (m_NumShots == m_cdNumShotsLong) { + CString exePath(m_cdContourExe + _T(" ") + m_SavePath); +// system(exePath); + } + } + //if (m_AbortSignal) { + // m_AbortSignal = FALSE; + // m_ShotCount = m_RecordCount = 0; + // m_Status = ST_PREVIEW; + // m_Event = EV_ABORT; + //} + } else { + // �҂� + Sleep(1); + } + } + + SAFE_DELETEA(rotateBuf); + SAFE_DELETEA(saveBuf); +} + +// �摜90�x��] +void CImager::RotateImage(BYTE* src, BYTE* dst) +{ + for (int y = 0; y < m_StreamH; y ++) { + for (int x = 0; x < m_StreamW; x ++) { + int is = (y * m_StreamW + x) * COLOR_CH; + int it = ((m_StreamW - 1 - x) * m_StreamH + y) * COLOR_CH; + dst[it ] = src[is ]; + dst[it+1] = src[is+1]; + dst[it+2] = src[is+2]; + } + } +} + +// �B�e�J�n +void CImager::StartRecord(int numShots) +{ + // �B�e���� + m_NumShots = numShots; + CTime now = CTime::GetCurrentTime(); + m_SavePath = m_cdSavePathBase + _T("\\") + + now.Format("%Y-%m-%d\\%H_%M_%S-"); + if (m_Event == EV_CALIB_DONE) m_SavePath.Append(_T("�Z��")); + else m_SavePath.Append(m_SubjectID); +// TRACE(m_SavePath + _T("\n")); +#ifdef _UNICODE + ::SHCreateDirectory(NULL, m_SavePath + _T("\\")); +#else + MakeSureDirectoryPathExists(m_SavePath + _T("\\")); +#endif + this->WriteCondition(); + + // �B�e���[�h�֐؂�ւ� + LucamStreamVideoControl(m_hCam, STOP_STREAMING, NULL); + LucamEnableFastFrames(m_hCam, &m_Sshot); + m_ShotCount = m_RecordCount = m_SaveCountNormal = m_SaveCountGloss = 0; + m_Status = ST_MEASURING; + // �^�C�}�[�J�n + m_TimerID = timeSetEvent((UINT)(1000.F/m_cdRecordFps), m_TimerResolution, + (LPTIMECALLBACK)this->TimerCBentry, (DWORD_PTR)this, TIME_PERIODIC); +} + +// �B�e�I�� +void CImager::EndRecord() +{ + // �v���r���[���[�h�֐؂�ւ� + timeKillEvent(m_TimerID); + m_Status = ST_SAVING; + if (m_Event == EV_NONE) m_Event = EV_MEAS_DONE; + LucamDisableFastFrames(m_hCam); + LucamStreamVideoControl(m_hCam, START_STREAMING, NULL); + LucamGpioWrite(m_hCam, LED_LASER_OFF); +} + +// �B�e +void CImager::TakeFastFrame() +{ + LucamTakeFastFrame(m_hCam, m_RawBuf); + this->StreamCB(m_RawBuf); +} + +// ���f +void CImager::Abort() +{ + if (m_Status == ST_MEASURING) { + m_Event = EV_ABORT; + this->EndRecord(); + m_Status = ST_PREVIEW; + } +} + +// �Z���J�n +void CImager::StartCalibrate() +{ + m_CalibCount = 0; + m_Status = ST_CALIBRATING; +} + +// �Z���v�Z +void CImager::Calibrate() +{ + if (++ m_CalibCount > CALIB_MAX) { + AfxMessageBox(_T("�Z���G���[�i���������j")); + m_Event = EV_CALIB_FAILED; + m_Status = ST_NOCALIB; + return; + } + + this->GetCheckerColor(m_StreamBuf[m_StreamWrite]); + + // �Q�C���␳�v�Z + float gainBd = sqrt(m_cdWhiteBalValue / (float)m_CalibColor[CHECKER_WHITE].b); + float gainGd = sqrt(m_cdWhiteBalValue / (float)m_CalibColor[CHECKER_WHITE].g); + float gainRd = sqrt(m_cdWhiteBalValue / (float)m_CalibColor[CHECKER_WHITE].r); + m_Sshot.gainBlue *= gainBd; + m_Sshot.gainGrn1 *= gainGd; + m_Sshot.gainGrn2 *= gainGd; + m_Sshot.gainRed *= gainRd; + TRACE("Gain amp B x%.2f=%.2f, B x%.2f=%.2f, B x%.2f=%.2f\n", + gainBd, m_Sshot.gainBlue, gainGd, m_Sshot.gainGrn1, gainRd, m_Sshot.gainRed); + + // �O��l���� + if ( gainBd > m_cdCheckerDetect || gainBd < 1.F / m_cdCheckerDetect + || gainGd > m_cdCheckerDetect || gainGd < 1.F / m_cdCheckerDetect + || gainRd > m_cdCheckerDetect || gainRd < 1.F / m_cdCheckerDetect ) { + AfxMessageBox(_T("�Z���G���[�i�F�ω����߁j")); + m_Event = EV_CALIB_FAILED; + m_Status = ST_NOCALIB; + return; + } + + // �Z���l�̓K�p + LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_BLUE, m_Sshot.gainBlue, NULL); + LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_GREEN1, m_Sshot.gainGrn1, NULL); + LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_GREEN2, m_Sshot.gainGrn2, NULL); + LucamSetProperty(m_hCam, LUCAM_PROP_GAIN_RED, m_Sshot.gainRed, NULL); +#ifdef _DEBUG + float gainR, gainG, gainB; + LONG flg; + LucamGetProperty(m_hCam, LUCAM_PROP_GAIN_BLUE, &gainB, &flg); + LucamGetProperty(m_hCam, LUCAM_PROP_GAIN_GREEN1, &gainG, &flg); + LucamGetProperty(m_hCam, LUCAM_PROP_GAIN_RED, &gainR, &flg); + TRACE("Actual gain BGR: %.2f, %.2f, %.2f\n", gainB, gainG, gainR); +#endif + + // �������� + if (abs(gainBd - 1.0F) < 0.01F && + abs(gainGd - 1.0F) < 0.01F && + abs(gainRd - 1.0F) < 0.01F) { + m_Event = EV_CALIB_DONE; + } +} + +// �Z���f�[�^�ۑ� +void CImager::WriteCalibData(BYTE *img) +{ + this->GetCheckerColor(img); + + // �^�C�~���O�L�^ + CStdioFile file; + if (!file.Open(m_SavePath + _T("\\") + CALIB_DATA_FILE, + CFile::modeWrite | CFile::shareDenyWrite | CFile::modeCreate)) return; + + file.WriteString(_T("No , R , G , B\n")); + CString buf; + for (int i = 0; i < NUM_CHECKER; i ++) { + buf.Format(_T("%3d,%3d,%3d,%3d\n"), + i + 1, m_CalibColor[i].r, m_CalibColor[i].g, m_CalibColor[i].b); + file.WriteString(buf); + } + file.Close(); +} + +// �`�F�b�J�[�̐F�擾 +void CImager::GetCheckerColor(BYTE *img) +{ + int checkerIdx = 0; + for (int x = m_cdCheckerX1; x >= m_cdCheckerX24; x += (m_cdCheckerX24-m_cdCheckerX1)/3) { + for (int y = m_cdCheckerY1; y <= m_cdCheckerY24; y += (m_cdCheckerY24-m_cdCheckerY1)/5) { + int count = 0, r = 0, g = 0, b = 0; + for (int dy = -SAMPLE_SIZE; dy < SAMPLE_SIZE; dy ++) { + for (int dx = -SAMPLE_SIZE; dx < SAMPLE_SIZE; dx ++) { + int idx = ((m_StreamW-y+dy) * m_StreamH + x+dx) * COLOR_CH; + b += img[idx ]; + g += img[idx+1]; + r += img[idx+2]; + count ++; + } + } + m_CalibColor[checkerIdx].b = b / count; + m_CalibColor[checkerIdx].g = g / count; + m_CalibColor[checkerIdx].r = r / count; + if (checkerIdx == 18) TRACE("Checker[%2d] BGR = %d, %d, %d\n", checkerIdx, + m_CalibColor[checkerIdx].b, m_CalibColor[checkerIdx].g, m_CalibColor[checkerIdx].r); + checkerIdx ++; + } + } +} + +// �Z���⏕���`�� +void CImager::DrawCalibLine(BYTE* img) +{ + int lineX1 = m_cdCheckerX24 - (m_cdCheckerX1 - m_cdCheckerX24) / 6; + int lineX2 = m_cdCheckerX1 + (m_cdCheckerX1 - m_cdCheckerX24) / 6; + int lineXd = (m_cdCheckerX1 - m_cdCheckerX24) / 3; + int lineY1 = m_cdCheckerY1 - (m_cdCheckerY24 - m_cdCheckerY1) / 10; + int lineY2 = m_cdCheckerY24 + (m_cdCheckerY24 - m_cdCheckerY1) / 10; + int lineYd = (m_cdCheckerY24 - m_cdCheckerY1) / 5; + + // ���� + for (int x = lineX1; x <= lineX2; x += lineXd) { + for (int y = lineY1; y < lineY2; y ++) { + this->SetPoint(img, x , y, 255, 255, 255); + this->SetPoint(img, x+1, y, 255, 255, 255); + } + } + + // ���� + for (int x = lineX1; x <= lineX2; x ++) { + for (int y = lineY1; y < lineY2; y += lineYd) { + this->SetPoint(img, x, y , 255, 255, 255); + this->SetPoint(img, x, y+1, 255, 255, 255); + } + } + + // ROI�`�� + for (int x = m_cdCheckerX1; x >= m_cdCheckerX24; x += (m_cdCheckerX24-m_cdCheckerX1)/3) { + for (int y = m_cdCheckerY1; y <= m_cdCheckerY24; y += (m_cdCheckerY24-m_cdCheckerY1)/5) { + for (int dy = -SAMPLE_SIZE; dy < SAMPLE_SIZE; dy ++) { + for (int dx = -SAMPLE_SIZE; dx < SAMPLE_SIZE; dx ++) { + this->SetPoint(img, x+dx, y+dy, 255, 255, 0); + } + } + } + } +} + +// �o�b�t�@�ɓ_��`�� +void CImager::SetPoint(BYTE* img, int x, int y, int r, int g, int b) +{ + if (x < 0 || x >= m_StreamH || y < 0 || y >= m_StreamW) return; + int idx = ((m_StreamW-y) * m_StreamH + x) * COLOR_CH; + img[idx ] = b; + img[idx+1] = g; + img[idx+2] = r; +} + +// �\���o�b�t�@�ƃT�C�Y��Ԃ� +BYTE* CImager::GetStream(LONG &width, LONG &height) +{ + width = m_StreamH; + height = m_StreamW; + return m_StreamBuf[(m_StreamWrite - 1 + DOUBLE_BUFFER) % DOUBLE_BUFFER]; +} + +// �B�e�����L�^ +void CImager::WriteCondition() +{ + m_InfoPath = m_SavePath + _T("\\") + CONDITION_FILE; + CStdioFile file; + if (!file.Open(m_InfoPath, + CFile::modeWrite | CFile::shareDenyWrite | CFile::modeCreate)) return; + + CString buf; + file.WriteString(_T("�B�e�L�^\n\n")); + buf.Format(_T("%-9s: %s\n"), _T("����"), + CTime::GetCurrentTime().Format(_T("%Y/%m/%d %H:%M:%S"))); + file.WriteString(buf); + if (m_Event != EV_CALIB_DONE) { + buf.Format(_T("%-9s: %s\n"), _T("�팱��ID"), m_SubjectID); + file.WriteString(buf); + buf.Format(_T("%-9s: %s\n"), _T("����"), + m_Gender == 0 ? _T("�j��") : _T("����")); + file.WriteString(buf); + } + buf.Format(_T("%-9s:%6d\n"), _T("�摜��"), m_StreamH); + file.WriteString(buf); + buf.Format(_T("%-9s:%6d\n"), _T("�摜����"), m_StreamW); + file.WriteString(buf); + buf.Format(_T("%-9s:%6d\n"), _T("�B�e����"), m_NumShots); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("FPS"), m_cdRecordFps); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("�I������"), m_Sshot.exposure); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("Gain"), m_Sshot.gain); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("Gain B"), m_Sshot.gainBlue); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("Gain G1"), m_Sshot.gainGrn1); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("Gain G2"), m_Sshot.gainGrn2); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("Gain R"), m_Sshot.gainRed); + file.WriteString(buf); + buf.Format(_T("%-9s:%6.2f\n"), _T("Gamma"), m_cdGamma); + file.WriteString(buf); + + file.WriteString(_T("\n�B�e�ԍ�,�o��(ms),�t�@�C����\n")); + + file.Close(); +} + +// �X�e�[�^�X�o�[�\���������Ԃ� +CString CImager::GetStatusText() +{ + CString str(_T("")); + + switch(m_Event) { + case EV_CALIB_DONE: + str.AppendFormat(_T(" �Z������ (R:%3d G:%3d B:%3d) "), + m_CalibColor[CHECKER_WHITE].r, + m_CalibColor[CHECKER_WHITE].g, + m_CalibColor[CHECKER_WHITE].b); + break; + case EV_MEAS_DONE: + str.Append(_T(" �B�e�I��")); + break; + case EV_SAVE_DONE: + str.Append(_T(" �f�[�^�ۑ��I��")); + break; + } + + switch(m_Status) { + case ST_NOCALIB: + str.Append(_T(" �J���[�`�F�b�J�[�𑕒����čZ���{�^���������ĉ�����")); + break; + case ST_CALIBRATING: + str.Append(_T(" �Z����")); + break; + case ST_PREVIEW: + str.Append(_T(" �B�e�ł��܂�")); + break; + case ST_MEASURING: + str.AppendFormat(_T(" �B�e�� %d���B�e %d���ۑ� / %d��"), + m_ShotCount, m_RecordCount, m_NumShots); + break; + case ST_SAVING: + str.AppendFormat(_T(" �ۑ��� %d���B�e %d���ۑ� / %d��"), + m_ShotCount, m_RecordCount, m_NumShots); + break; + } + return str; +} + +// FPS�\���������Ԃ� +CString CImager::GetFpsText() +{ + CString str(_T("")); + str.Format(_T("%4.1f fps"), m_FpsPreview); + return str; +} + +// �I������ +void CImager::CloseApp() +{ + // �B�e��~ + if (m_Status == ST_MEASURING) { + timeKillEvent(m_TimerID); + LucamDisableFastFrames(m_hCam); + } else { + LucamStreamVideoControl(m_hCam, STOP_STREAMING, NULL); + } + LucamGpioWrite(m_hCam, LED_LASER_OFF); + + // ���[�J�[�X���b�h��~ + m_QuitSignal = TRUE; + if (m_WorkerThread) { + const int TIMEOUT = 1000; + WaitForSingleObject(m_WorkerThread->m_hThread, TIMEOUT); + } +} + +// �ݒ�t�@�C���̓ǂݍ��� +BOOL CImager::LoadConfig() +{ + m_InfoPath = m_SavePath + _T("\\") + CONDITION_FILE; + CStdioFile file; + if (!file.Open(CONFIG_FILE, CFile::modeRead | CFile::shareDenyWrite)) return FALSE; + + CString buf; + while (file.ReadString(buf)) { + CString header = this->GetConfigHeader(buf); + if (header == _T("CONTOUR_EXE")) + m_cdContourExe = this->GetConfigValue(buf); + if (header == _T("SHOKEN_EXE")) + m_cdShokenExe = this->GetConfigValue(buf); + if (header == _T("SAVE_PATH_BASE")) + m_cdSavePathBase = this->GetConfigValue(buf); + if (header == _T("EXPOSURE")) + m_cdExposure = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("GAIN")) + m_cdGain = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("GAIN_B")) + m_cdGainB = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("GAIN_G")) + m_cdGainG = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("GAIN_R")) + m_cdGainR = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("GAMMA")) + m_cdGamma = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("RECORD_FPS")) + m_cdRecordFps = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("WHITE_BAL_VALUE")) + m_cdWhiteBalValue = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("CHECKER_DETECT")) + m_cdCheckerDetect = (float)_tstof(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("NUM_SHOTS_LONG")) + m_cdNumShotsLong = _tstoi(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("NUM_SHOTS_SHORT")) + m_cdNumShotsShort = _tstoi(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("CHECKER_X1")) + m_cdCheckerX1 = _tstoi(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("CHECKER_Y1")) + m_cdCheckerY1 = _tstoi(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("CHECKER_X24")) + m_cdCheckerX24 = _tstoi(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("CHECKER_Y24")) + m_cdCheckerY24 = _tstoi(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("LED_INTERVAL")) + m_cdLedInterval = _tstoi(this->GetConfigValue(buf).GetBuffer(0)); + if (header == _T("CONTROLLER_REV")) { + if (_tstoi(this->GetConfigValue(buf).GetBuffer(0))) { + int tmp = m_cdLedOn; + m_cdLedOn = m_cdLaserOn; + m_cdLaserOn = tmp; + } + } + } + + file.Close(); + + if (m_cdNumShotsLong < m_cdNumShotsShort) return FALSE; + + return TRUE; +} + +// �ݒ薼�̎擾 +CString CImager::GetConfigHeader(const CString &buf) +{ + CString header(_T("")); + int dem = buf.Find(_T(":")); + if (dem > 0) { + header = buf.Left(dem - 1).Trim(); + } + + return header; +} + +// �ݒ�l�̎擾 +CString CImager::GetConfigValue(const CString &buf) +{ + CString value(_T("")); + int dem = buf.Find(_T(":")); + if (dem > 0) { + value = buf.Mid(dem + 1).Trim(); + } + + return value; +} + +// �������͂��J�� +void CImager::ShokenForm() +{ + m_SavePath = m_cdSavePathBase + _T("\\") + + CTime::GetCurrentTime().Format("%Y-%m-%d\\%H_%M_%S-") + m_SubjectID; + CString exePath(m_cdShokenExe + _T(" ") + m_SavePath + _T(" ") + m_SubjectID); +// system(exePath); +} + +// �ÓI�֐� ------------------------------------------------------------------- + +// �R�[���o�b�N�̃G���g���[�|�C���g +void __stdcall CImager::StreamCBentry(VOID *pContext, BYTE *pData, ULONG dataLength) +{ + ((CImager*)pContext)->StreamCB(pData); +} + +// �B�e�g���K�^�C�}�[�̃G���g���[�|�C���g +void CALLBACK CImager::TimerCBentry(UINT uiID, UINT uiNo, DWORD dwUser, DWORD dwNo1, DWORD dwNo2) +{ + ((CImager*)dwUser)->TakeFastFrame(); +} + +// ���[�J�[�X���b�h�̃G���g���[�|�C���g +UINT __cdecl CImager::WorkerTHentry(LPVOID pParam) +{ + ((CImager*)pParam)->WorkerTH(); + return 0; +} + +// �߂�l�̌��� +void CImager::Valid(INT v, TCHAR* errmsg) +{ + if (v == FALSE) { + CString msg(_T("�G���[���� : ")); + msg.Append(errmsg); + throw msg; + } +} diff --git a/TIAS_Imager2/Imager.h b/TIAS_Imager2/Imager.h new file mode 100644 index 0000000..37231ff --- /dev/null +++ b/TIAS_Imager2/Imager.h @@ -0,0 +1,177 @@ +#pragma once + +#include "lucamapi.h" +#ifdef X64 +#pragma comment(lib, "lucamapi64.lib") +#else +#pragma comment(lib, "lucamapi32.lib") +#endif + +#include +#pragma comment(lib, "winmm.lib") + +//#define ISHIGAKI 1 +#define CAMERA_NUMBER 1 +#define COLOR_CH 3 +#define PREVIEW_WIDTH 1280 +#define PREVIEW_HEIGHT 1024 +#define PREVIEW_BINNING_X 1 +#define PREVIEW_BINNING_Y 1 +#define DOUBLE_BUFFER 2 +#define LED_LASER_OFF 0 +//#if ISHIGAKI +//#define LED_ON 1 +//#define LASER_ON 2 +//#else +//#define LED_ON 2 +//#define LASER_ON 1 +//#endif +#define NUM_CHECKER 24 +#define CHECKER_WHITE 18 +#define SAMPLE_SIZE 5 +#define CALIB_INTERVAL 5 +#define CALIB_MAX 20 +#define CONFIG_FILE _T("Config.txt") +#define CONDITION_FILE _T("Info.txt") +#define CALIB_DATA_FILE _T("Calib.csv") +#define PREFIX_NORMAL _T("Shot") +#define PREFIX_GLOSS _T("VShot") +#define IMAGE_TYPE _T("bmp") +// �ύX�”\�Ƃ������萔 +#define CD_CONTOUR_EXE _T("C:\\TIAS_Bin\\imager\\contourTongue\\contourTongue.exe") +#define CD_SHOKEN_EXE _T("C:\\TIAS_Bin\\imager\\Shoken\\shoken.exe") +#define CD_SAVE_PATH_BASE _T("C:\\TIAS_Data") +#define CD_EXPOSURE 20.0F +#define CD_GAIN 1.0F +#define CD_GAIN_B 1.5F +#define CD_GAIN_G 1.0F +#define CD_GAIN_R 1.3F +#define CD_GAMMA 1.0F +#define CD_RECORD_FPS 10.0F +#define CD_WHITE_BAL_VALUE 50.0F +#define CD_NUM_SHOTS_LONG 200 +#define CD_NUM_SHOTS_SHORT 50 +#define CD_CHECKER_X1 720 +#define CD_CHECKER_Y1 180 +#define CD_CHECKER_X24 120 +#define CD_CHECKER_Y24 1230 +#define CD_LED_INTERVAL 10 +#define CD_CHECKER_DETECT 2.5F +#define CD_LED_ON 2 +#define CD_LASER_ON 1 + +// CImager �R�}���h �^�[�Q�b�g +class CImager : public CObject +{ +public: + enum CiStatus { ST_NOCALIB, ST_CALIBRATING, ST_PREVIEW, + ST_MEASURING, ST_SAVING }; + enum CiEvent { EV_NONE, EV_CALIB_DONE, EV_CALIB_FAILED, + EV_MEAS_DONE, EV_SAVE_DONE, EV_ABORT, EV_QUIT }; + struct CiRGB { int r, g, b; }; + +private: + HANDLE m_hCam; + LUCAM_FRAME_FORMAT m_Fmt; + LUCAM_SNAPSHOT m_Sshot; + BYTE* m_StreamBuf[DOUBLE_BUFFER]; + int m_StreamBufSize; + int m_StreamWrite; + int m_StreamW; + int m_StreamH; + int m_RawBufSize; + BYTE* m_RawBuf; + BYTE* m_RotateBuf; + float m_FpsPreview; + UINT m_TimerResolution; + MMRESULT m_TimerID; + int m_NumShots; + int m_ShotCount; + int m_RecordCount; + int m_SaveCountNormal; + int m_SaveCountGloss; + int m_CalibCount; + BYTE** m_RecordBuf; + DWORD* m_RecordTiming; + CWinThread* m_WorkerThread; + BOOL m_QuitSignal; + //BOOL m_AbortSignal; + CiStatus m_Status; + CiEvent m_Event; + CiRGB m_CalibColor[NUM_CHECKER]; + CString m_SubjectID; + int m_Gender; + CString m_SavePath; + CString m_InfoPath; + CString m_cdContourExe; + CString m_cdShokenExe; + CString m_cdSavePathBase; + float m_cdExposure; + float m_cdGain; + float m_cdGainB; + float m_cdGainG; + float m_cdGainR; + float m_cdGamma; + float m_cdRecordFps; + float m_cdWhiteBalValue; + float m_cdCheckerDetect; + int m_cdNumShotsLong; + int m_cdNumShotsShort; + int m_cdCheckerX1; + int m_cdCheckerY1; + int m_cdCheckerX24; + int m_cdCheckerY24; + int m_cdLedInterval; + int m_cdLedOn; + int m_cdLaserOn; + + void StartRecord(int numShots); + void EndRecord(); + void RotateImage(BYTE* src, BYTE* dst); + void DrawCalibLine(BYTE* img); + void SetPoint(BYTE* img, int x, int y, int r, int g, int b); + void Calibrate(); + void GetCheckerColor(BYTE *img); + void WriteCalibData(BYTE *img); + BOOL LoadConfig(); + CString GetConfigHeader(const CString &buf); + CString GetConfigValue(const CString &buf); + +public: + // �����o�[�֐� + CImager(); + virtual ~CImager(); + BOOL Init(); + void StreamCB(BYTE *pData); + void WorkerTH(); + CString GetStatusText(); + CString GetFpsText(); + void TakeFastFrame(); + void TakeOne() { this->StartRecord(1); } + void TakeShort() { this->StartRecord(m_cdNumShotsShort); } + void TakeLong() { this->StartRecord(m_cdNumShotsLong); } + void CloseApp(); + void StartCalibrate(); + void WriteCondition(); + void ShokenForm(); + void Abort(); + + // �v���p�e�B + BYTE* GetStream(LONG &width, LONG &height); + void ResetEvent() { m_Event = EV_NONE; } + CiEvent GetEvent() { return m_Event; } + CiStatus GetStatus() { return m_Status; } + int GetNumShotsLong() { return m_cdNumShotsLong; } + int GetNumShotsShort() { return m_cdNumShotsShort; } + float GetRecordFps() { return m_cdRecordFps; } + void SetSubject(CString id, int gender) + { m_SubjectID = id, m_Gender = gender; } + + // �ÓI�֐� + static void __stdcall StreamCBentry( + VOID *pContext, BYTE *pData, ULONG dataLength); + static void CALLBACK TimerCBentry( + UINT uiID, UINT uiNo, DWORD dwUser, DWORD dwNo1, DWORD dwNo2); + static UINT __cdecl WorkerTHentry(LPVOID pParam); + static void Valid(BOOL rv, TCHAR* errmsg); +}; diff --git a/TIAS_Imager2/MainFrm.cpp b/TIAS_Imager2/MainFrm.cpp new file mode 100644 index 0000000..9805cc5 --- /dev/null +++ b/TIAS_Imager2/MainFrm.cpp @@ -0,0 +1,84 @@ + +// MainFrm.cpp : CMainFrame �N���X�̎��� +// + +#include "stdafx.h" +#include "TIAS_Imager2.h" + +#include "MainFrm.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// CMainFrame + +IMPLEMENT_DYNCREATE(CMainFrame, CFrameWndEx) + +BEGIN_MESSAGE_MAP(CMainFrame, CFrameWndEx) + ON_WM_CREATE() +END_MESSAGE_MAP() + +static UINT indicators[] = +{ + ID_SEPARATOR, // �X�e�[�^�X ���C�� �C���W�P�[�^�[ + ID_INDICATOR_FPS, +}; + +// CMainFrame �R���X�g���N�V����/�f�X�g���N�V���� + +CMainFrame::CMainFrame() +{ +} + +CMainFrame::~CMainFrame() +{ +} + +int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) +{ + if (CFrameWndEx::OnCreate(lpCreateStruct) == -1) return -1; + + // �X�^�C���ݒ� + CMFCVisualManagerWindows::m_b3DTabsXPTheme = TRUE; + CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows)); + + // �X�e�[�^�X�o�[�ݒ� + if (!m_wndStatusBar.Create(this)) + { + TRACE0("�X�e�[�^�X �o�[�̍쐬�Ɏ��s���܂����B\n"); + return -1; // �쐬�ł��Ȃ��ꍇ + } + m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT)); + + // �^�C�g���o�[�ݒ� + //CAtlString title; + //title.LoadString(AFX_IDS_APP_TITLE); + SetWindowText(GetFileVersion()); + + return 0; +} + +BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) +{ + if( !CFrameWndEx::PreCreateWindow(cs) ) return FALSE; + + // �E�C���h�E�̑��� + cs.style = WS_OVERLAPPED | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU; + + // �E�C���h�E�T�C�Y + cs.x = 300; + cs.y = 0; + cs.cx = 750; + cs.cy = 717; + + return TRUE; +} + +// �X�e�[�^�X�o�[�i���b�Z�[�W�j�ɕ\�� +void CMainFrame::SetStatusMsg(int idx, CString str) +{ + if (str.GetLength() > 0) m_wndStatusBar.SetPaneText(idx, str); +} + +// CMainFrame ���b�Z�[�W �n���h���[ diff --git a/TIAS_Imager2/MainFrm.h b/TIAS_Imager2/MainFrm.h new file mode 100644 index 0000000..b31f170 --- /dev/null +++ b/TIAS_Imager2/MainFrm.h @@ -0,0 +1,39 @@ + +// MainFrm.h : CMainFrame �N���X�̃C���^�[�t�F�C�X +// + +#pragma once + +class CMainFrame : public CFrameWndEx +{ +public: + enum { SBAR_MSG = 0, SBAR_FPS = 1 }; + +protected: // �V���A��������̂ݍ쐬���܂��B + CMainFrame(); + DECLARE_DYNCREATE(CMainFrame) + +// ���� +public: + +// ���� +public: + +// �I�[�o�[���C�h +public: + virtual BOOL PreCreateWindow(CREATESTRUCT& cs); + void SetStatusMsg(int idx, CString str); + +// ���� +public: + virtual ~CMainFrame(); + +protected: // �R���g���[�� �o�[�p�����o�[ + CMFCStatusBar m_wndStatusBar; + +// �������ꂽ�A���b�Z�[�W���蓖�Ċ֐� +protected: + afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); + DECLARE_MESSAGE_MAP() + +}; diff --git a/TIAS_Imager2/ReadMe.txt b/TIAS_Imager2/ReadMe.txt new file mode 100644 index 0000000..5f18462 --- /dev/null +++ b/TIAS_Imager2/ReadMe.txt @@ -0,0 +1,21 @@ +�X�V���� + +2014.4.3 Ver2.21 +�ԉ��Ƀe�X�g�p�ɒ񋟂��邽�߉��� +VisualStudio2013 �Ƀv���W�F�N�gVerUP +UNICODE�� +�^�C�g���o�[�̃o�[�W�����\�����ڍ׉� + +2012.11.29 Ver2.2 +���f�@�\ +����{�b�N�X�̏o�͔��]�ݒ��config�t�@�C������”\�� + +2012.11.29 Ver2.1 +�F�ω������ݒ�p�����[�^�ɕύX +�Z���J��Ԃ������ݒ� +�FGAIN�̏��4.0���m�F +�Z�����ʂ�18�ԐF�[RGB�l�\�� +�����֓n��Path���C�� + +2012.11.28 Ver2.0 +��ʂ�쐬 diff --git a/TIAS_Imager2/TIAS_Imager2.cpp b/TIAS_Imager2/TIAS_Imager2.cpp new file mode 100644 index 0000000..073e2d3 --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2.cpp @@ -0,0 +1,145 @@ + +// TIAS_Imager2.cpp : �A�v���P�[�V�����̃N���X������`���܂��B +// + +#include "stdafx.h" +#include "afxwinappex.h" +#include "afxdialogex.h" +#include "TIAS_Imager2.h" +#include "MainFrm.h" + +#include "TIAS_Imager2Doc.h" +#include "TIAS_Imager2View.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + + +// CTIAS_Imager2App + +BEGIN_MESSAGE_MAP(CTIAS_Imager2App, CWinAppEx) + ON_COMMAND(ID_APP_ABOUT, &CTIAS_Imager2App::OnAppAbout) + // �W���̃t�@�C����{�h�L�������g �R�}���h + ON_COMMAND(ID_FILE_NEW, &CWinAppEx::OnFileNew) + ON_COMMAND(ID_FILE_OPEN, &CWinAppEx::OnFileOpen) +END_MESSAGE_MAP() + +// CTIAS_Imager2App �R���X�g���N�V���� +CTIAS_Imager2App::CTIAS_Imager2App() +{ + m_bHiColorIcons = TRUE; + SetAppID(_T("TIAS_Imager2.AppID.NoVersion")); + + m_Imager = new CImager; +} + +// CNH7CaptureApp �f�X�g���N�V���� +CTIAS_Imager2App::~CTIAS_Imager2App() +{ + delete m_Imager; +} + +// �B��� CTIAS_Imager2App �I�u�W�F�N�g +CTIAS_Imager2App theApp; + +// CTIAS_Imager2App ������ +BOOL CTIAS_Imager2App::InitInstance() +{ + INITCOMMONCONTROLSEX InitCtrls; + InitCtrls.dwSize = sizeof(InitCtrls); + InitCtrls.dwICC = ICC_WIN95_CLASSES; + InitCommonControlsEx(&InitCtrls); + + CWinAppEx::InitInstance(); + + // CImager�N���X�̏����� + if (!m_Imager->Init()) return FALSE; + + EnableTaskbarInteraction(FALSE); + + SetRegistryKey(_T("Chiba-u")); + LoadStdProfileSettings(0); // �W���� INI �t�@�C���̃I�v�V���������[�h���܂� (MRU ���܂�) + + InitContextMenuManager(); + InitKeyboardManager(); + InitTooltipManager(); + CMFCToolTipInfo ttParams; + ttParams.m_bVislManagerTheme = TRUE; + theApp.GetTooltipManager()->SetTooltipParams(AFX_TOOLTIP_TYPE_ALL, + RUNTIME_CLASS(CMFCToolTipCtrl), &ttParams); + + // �A�v���P�[�V�����p�̃h�L�������g �e���v���[�g��o�^���܂� + CSingleDocTemplate* pDocTemplate; + pDocTemplate = new CSingleDocTemplate( + IDR_MAINFRAME, + RUNTIME_CLASS(CTIAS_Imager2Doc), + RUNTIME_CLASS(CMainFrame), // ���C�� SDI �t���[�� �E�B���h�E + RUNTIME_CLASS(CTIAS_Imager2View)); + if (!pDocTemplate) return FALSE; + AddDocTemplate(pDocTemplate); + + // DDE�Afile open �ȂǕW���̃V�F�� �R�}���h�̃R�}���h ���C������͂��܂��B + CCommandLineInfo cmdInfo; + ParseCommandLine(cmdInfo); + if (!ProcessShellCommand(cmdInfo)) return FALSE; + + // ���C�� �E�B���h�E�����������ꂽ�̂ŁA�\���ƍX�V���s���܂��B + m_pMainWnd->ShowWindow(SW_SHOW); + m_pMainWnd->UpdateWindow(); + + return TRUE; +} + +// CTIAS_Imager2App ���b�Z�[�W �n���h���[ + +// �_�C�A���O�����s���邽�߂̃A�v���P�[�V���� �R�}���h +void CTIAS_Imager2App::OnAppAbout() +{ + CAboutDlg aboutDlg; + aboutDlg.DoModal(); +} + +// CTIAS_Imager2App �̃J�X�^�}�C�Y���ꂽ�ǂݍ��݃��\�b�h�ƕۑ����\�b�h + +void CTIAS_Imager2App::PreLoadState() +{ + //BOOL bNameValid; + //CString strName; + //bNameValid = strName.LoadString(IDS_EDIT_MENU); + //ASSERT(bNameValid); + //GetContextMenuManager()->AddMenu(strName, IDR_POPUP_EDIT); +} + +// CTIAS_Imager2App ���b�Z�[�W �n���h���[ + + + + + + +// ------------------------------------------------------------------------------------------- + +CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD) +{ +} + +void CAboutDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialogEx::DoDataExchange(pDX); +} + +BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx) +END_MESSAGE_MAP() +// ------------------------------------------------------------------------------------------- + + +BOOL CAboutDlg::OnInitDialog() +{ + CDialogEx::OnInitDialog(); + + CStatic *lbl = (CStatic *)GetDlgItem(IDC_VERSION); + lbl->SetWindowText(GetFileVersion()); + + return TRUE; +} diff --git a/TIAS_Imager2/TIAS_Imager2.h b/TIAS_Imager2/TIAS_Imager2.h new file mode 100644 index 0000000..630ff47 --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2.h @@ -0,0 +1,56 @@ + +// TIAS_Imager2.h : TIAS_Imager2 �A�v���P�[�V�����̃��C�� �w�b�_�[ �t�@�C�� +// +#pragma once + +#ifndef __AFXWIN_H__ + #error "PCH �ɑ΂��Ă��̃t�@�C�����C���N���[�h����O�� 'stdafx.h' ���C���N���[�h���Ă�������" +#endif + +#include "resource.h" // ���C�� �V���{�� +#include "Imager.h" + + +// CTIAS_Imager2App: +class CTIAS_Imager2App : public CWinAppEx +{ +private: + CImager *m_Imager; + +public: + //UINT m_nAppLook; + BOOL m_bHiColorIcons; + + CTIAS_Imager2App(); + ~CTIAS_Imager2App(); + virtual BOOL InitInstance(); + virtual void PreLoadState(); + afx_msg void OnAppAbout(); + CImager* Imager() { return m_Imager; } + DECLARE_MESSAGE_MAP() +}; + +extern CTIAS_Imager2App theApp; + + +// ------------------------------------------------------------------------------------------- +// �A�v���P�[�V�����̃o�[�W�������Ɏg���� CAboutDlg �_�C�A���O + +class CAboutDlg : public CDialogEx +{ +public: + CAboutDlg(); + +// �_�C�A���O �f�[�^ + enum { IDD = IDD_ABOUTBOX }; + +protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV �T�|�[�g + +// ���� +protected: + DECLARE_MESSAGE_MAP() +public: + virtual BOOL OnInitDialog(); +}; +// ------------------------------------------------------------------------------------------- diff --git a/TIAS_Imager2/TIAS_Imager2.rc b/TIAS_Imager2/TIAS_Imager2.rc new file mode 100644 index 0000000..3389347 --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2.rc Binary files differ diff --git a/TIAS_Imager2/TIAS_Imager2.vcxproj b/TIAS_Imager2/TIAS_Imager2.vcxproj new file mode 100644 index 0000000..037d3b9 --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2.vcxproj @@ -0,0 +1,228 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {F8F496AA-B04D-4793-9723-8EE364D338C3} + TIAS_Imager2 + MFCProj + + + + Application + true + Unicode + Static + v120 + + + Application + true + MultiByte + Static + v120 + + + Application + false + true + Unicode + Static + v120 + + + Application + false + true + MultiByte + Static + v120 + + + + + + + + + + + + + + + + + + + true + + + true + TIAS + + + false + TIAS + + + false + TIAS + + + + Use + Level3 + Disabled + WIN32;_WINDOWS;_DEBUG;%(PreprocessorDefinitions) + + + + + Windows + true + + + false + true + _DEBUG;%(PreprocessorDefinitions) + + + 0x0411 + _DEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + Use + Level3 + Disabled + WIN32;_WINDOWS;X64;_DEBUG;%(PreprocessorDefinitions) + + + Windows + true + + + false + _DEBUG;%(PreprocessorDefinitions) + + + 0x0411 + _DEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;_WINDOWS;NDEBUG;%(PreprocessorDefinitions) + + + Windows + true + true + true + + + false + true + NDEBUG;%(PreprocessorDefinitions) + + + 0x0411 + NDEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + Level3 + Use + MaxSpeed + true + true + WIN32;_WINDOWS;X64;NDEBUG;%(PreprocessorDefinitions) + + + Windows + true + true + true + + + false + NDEBUG;%(PreprocessorDefinitions) + + + 0x0411 + NDEBUG;%(PreprocessorDefinitions) + $(IntDir);%(AdditionalIncludeDirectories) + + + + + + + + + + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TIAS_Imager2/TIAS_Imager2.vcxproj.filters b/TIAS_Imager2/TIAS_Imager2.vcxproj.filters new file mode 100644 index 0000000..737d902 --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2.vcxproj.filters @@ -0,0 +1,84 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + + リソース ファイル + + + リソース ファイル + + + + + + ヘッダー ファイル + + + ヘッダー ファイル + + + ヘッダー ファイル + + + ヘッダー ファイル + + + ヘッダー ファイル + + + ヘッダー ファイル + + + ヘッダー ファイル + + + ヘッダー ファイル + + + ヘッダー ファイル + + + + + ソース ファイル + + + ソース ファイル + + + ソース ファイル + + + ソース ファイル + + + ソース ファイル + + + ソース ファイル + + + + + リソース ファイル + + + + + + \ No newline at end of file diff --git a/TIAS_Imager2/TIAS_Imager2Doc.cpp b/TIAS_Imager2/TIAS_Imager2Doc.cpp new file mode 100644 index 0000000..621d744 --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2Doc.cpp @@ -0,0 +1,137 @@ + +// TIAS_Imager2Doc.cpp : CTIAS_Imager2Doc �N���X�̎��� +// + +#include "stdafx.h" +// SHARED_HANDLERS �́A�v���r���[�A�T���l�C���A����ь����t�B���^�[ �n���h���[���������Ă��� ATL �v���W�F�N�g�Œ�`�ł��A +// ���̃v���W�F�N�g�Ƃ̃h�L�������g �R�[�h�̋��L���”\�ɂ��܂��B +#ifndef SHARED_HANDLERS +#include "TIAS_Imager2.h" +#endif + +#include "TIAS_Imager2Doc.h" + +#include + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// CTIAS_Imager2Doc + +IMPLEMENT_DYNCREATE(CTIAS_Imager2Doc, CDocument) + +BEGIN_MESSAGE_MAP(CTIAS_Imager2Doc, CDocument) +END_MESSAGE_MAP() + + +// CTIAS_Imager2Doc �R���X�g���N�V����/�f�X�g���N�V���� + +CTIAS_Imager2Doc::CTIAS_Imager2Doc() +{ + // TODO: ���̈ʒu�� 1 �x�����Ă΂��\�z�p�̃R�[�h��lj����Ă��������B + +} + +CTIAS_Imager2Doc::~CTIAS_Imager2Doc() +{ +} + +BOOL CTIAS_Imager2Doc::OnNewDocument() +{ + if (!CDocument::OnNewDocument()) + return FALSE; + + // TODO: ���̈ʒu�ɍď�����������lj����Ă��������B + // (SDI �h�L�������g�͂��̃h�L�������g���ė��p���܂��B) + + return TRUE; +} + + + + +// CTIAS_Imager2Doc �V���A���� + +void CTIAS_Imager2Doc::Serialize(CArchive& ar) +{ + if (ar.IsStoring()) + { + // TODO: �i�[����R�[�h�������ɒlj����Ă��������B + } + else + { + // TODO: �ǂݍ��ރR�[�h�������ɒlj����Ă��������B + } +} + +#ifdef SHARED_HANDLERS + +// �T���l�C���̃T�|�[�g +void CTIAS_Imager2Doc::OnDrawThumbnail(CDC& dc, LPRECT lprcBounds) +{ + // ���̃R�[�h��ύX���ăh�L�������g�̃f�[�^��`�悵�܂� + dc.FillSolidRect(lprcBounds, RGB(255, 255, 255)); + + CString strText = _T("TODO: implement thumbnail drawing here"); + LOGFONT lf; + + CFont* pDefaultGUIFont = CFont::FromHandle((HFONT) GetStockObject(DEFAULT_GUI_FONT)); + pDefaultGUIFont->GetLogFont(&lf); + lf.lfHeight = 36; + + CFont fontDraw; + fontDraw.CreateFontIndirect(&lf); + + CFont* pOldFont = dc.SelectObject(&fontDraw); + dc.DrawText(strText, lprcBounds, DT_CENTER | DT_WORDBREAK); + dc.SelectObject(pOldFont); +} + +// �����n���h���[�̃T�|�[�g +void CTIAS_Imager2Doc::InitializeSearchContent() +{ + CString strSearchContent; + // �h�L�������g�̃f�[�^���猟���R���e���c��ݒ肵�܂��B + // �R���e���c�̊e������ ";" �ŋ�؂�K�v������܂� + + // ��: strSearchContent = _T("point;rectangle;circle;ole object;"); + SetSearchContent(strSearchContent); +} + +void CTIAS_Imager2Doc::SetSearchContent(const CString& value) +{ + if (value.IsEmpty()) + { + RemoveChunk(PKEY_Search_Contents.fmtid, PKEY_Search_Contents.pid); + } + else + { + CMFCFilterChunkValueImpl *pChunk = NULL; + ATLTRY(pChunk = new CMFCFilterChunkValueImpl); + if (pChunk != NULL) + { + pChunk->SetTextValue(PKEY_Search_Contents, value, CHUNK_TEXT); + SetChunkValue(pChunk); + } + } +} + +#endif // SHARED_HANDLERS + +// CTIAS_Imager2Doc �f�f + +#ifdef _DEBUG +void CTIAS_Imager2Doc::AssertValid() const +{ + CDocument::AssertValid(); +} + +void CTIAS_Imager2Doc::Dump(CDumpContext& dc) const +{ + CDocument::Dump(dc); +} +#endif //_DEBUG + + +// CTIAS_Imager2Doc �R�}���h diff --git a/TIAS_Imager2/TIAS_Imager2Doc.h b/TIAS_Imager2/TIAS_Imager2Doc.h new file mode 100644 index 0000000..daee305 --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2Doc.h @@ -0,0 +1,48 @@ + +// TIAS_Imager2Doc.h : CTIAS_Imager2Doc �N���X�̃C���^�[�t�F�C�X +// + + +#pragma once + + +class CTIAS_Imager2Doc : public CDocument +{ +protected: // �V���A��������̂ݍ쐬���܂��B + CTIAS_Imager2Doc(); + DECLARE_DYNCREATE(CTIAS_Imager2Doc) + +// ���� +public: + +// ���� +public: + +// �I�[�o�[���C�h +public: + virtual BOOL OnNewDocument(); + virtual void Serialize(CArchive& ar); +#ifdef SHARED_HANDLERS + virtual void InitializeSearchContent(); + virtual void OnDrawThumbnail(CDC& dc, LPRECT lprcBounds); +#endif // SHARED_HANDLERS + +// ���� +public: + virtual ~CTIAS_Imager2Doc(); +#ifdef _DEBUG + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; +#endif + +protected: + +// �������ꂽ�A���b�Z�[�W���蓖�Ċ֐� +protected: + DECLARE_MESSAGE_MAP() + +#ifdef SHARED_HANDLERS + // �����n���h���[�̌����R���e���c��ݒ肷��w���p�[�֐� + void SetSearchContent(const CString& value); +#endif // SHARED_HANDLERS +}; diff --git a/TIAS_Imager2/TIAS_Imager2View.cpp b/TIAS_Imager2/TIAS_Imager2View.cpp new file mode 100644 index 0000000..3bd2c5d --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2View.cpp @@ -0,0 +1,254 @@ + +// TIAS_Imager2View.cpp : CTIAS_Imager2View �N���X�̎��� +// + +#include "stdafx.h" +// SHARED_HANDLERS �́A�v���r���[�A�T���l�C���A����ь����t�B���^�[ �n���h���[���������Ă��� ATL �v���W�F�N�g�Œ�`�ł��A +// ���̃v���W�F�N�g�Ƃ̃h�L�������g �R�[�h�̋��L���”\�ɂ��܂��B +#ifndef SHARED_HANDLERS +#include "TIAS_Imager2.h" +#endif + +#include "TIAS_Imager2Doc.h" +#include "TIAS_Imager2View.h" +#include "MainFrm.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#endif + +// CTIAS_Imager2View + +IMPLEMENT_DYNCREATE(CTIAS_Imager2View, CFormView) + +BEGIN_MESSAGE_MAP(CTIAS_Imager2View, CFormView) + ON_WM_DESTROY() + ON_WM_PAINT() + ON_WM_TIMER() + ON_BN_CLICKED(IDC_BTN_ONESHOT, &CTIAS_Imager2View::OnBnClickedBtnOneshot) + ON_BN_CLICKED(IDC_BTN_LONGSHOT, &CTIAS_Imager2View::OnBnClickedBtnLongshot) + ON_BN_CLICKED(IDC_BTN_SHORTSHOT, &CTIAS_Imager2View::OnBnClickedBtnShortshot) + ON_BN_CLICKED(IDC_BTN_CALIB, &CTIAS_Imager2View::OnBnClickedBtnCalib) + ON_BN_CLICKED(IDC_BTN_SHOKEN, &CTIAS_Imager2View::OnBnClickedBtnShoken) + ON_BN_CLICKED(IDC_BTN_ABORT, &CTIAS_Imager2View::OnBnClickedBtnAbort) +END_MESSAGE_MAP() + +// CTIAS_Imager2View �R���X�g���N�V���� +CTIAS_Imager2View::CTIAS_Imager2View() + : CFormView(CTIAS_Imager2View::IDD) + , m_xvEdtID(_T("")) + , m_xvGender(0) +{ + // �r�b�g�}�b�v���̐��� + ZeroMemory(&m_Bih, sizeof(BITMAPINFOHEADER)); + m_Bih.biSize = sizeof(BITMAPINFOHEADER); + m_Bih.biWidth = 640; + m_Bih.biHeight = 512; // ���̒l���w�肷��Ə㉺���] + m_Bih.biBitCount = 24; + m_Bih.biPlanes = 1; + m_Bih.biCompression = BI_RGB; +} + +// CTIAS_Imager2View �f�X�g���N�V���� +CTIAS_Imager2View::~CTIAS_Imager2View() +{ + m_FontBtn.DeleteObject(); +} + +// DDX +void CTIAS_Imager2View::DoDataExchange(CDataExchange* pDX) +{ + CFormView::DoDataExchange(pDX); + DDX_Text(pDX, IDC_EDT_ID, m_xvEdtID); + DDX_Radio(pDX, IDC_RAD_GENDERM, m_xvGender); +} + +// �E�C���h�E�����O�̐ݒ� +BOOL CTIAS_Imager2View::PreCreateWindow(CREATESTRUCT& cs) +{ + return CFormView::PreCreateWindow(cs); +} + +// �E�C���h�E������ +void CTIAS_Imager2View::OnInitialUpdate() +{ + CFormView::OnInitialUpdate(); + GetParentFrame()->RecalcLayout(); + ResizeParentToFit(); + + // �R���g���[�������� + m_FontBtn.CreatePointFont(140, _T("�l�r �S�V�b�N")); + GetDlgItem(IDC_BTN_ONESHOT)->SetFont(&m_FontBtn); + CString buf; + int fps = (int)theApp.Imager()->GetRecordFps(); + int numShort = theApp.Imager()->GetNumShotsShort(); + int numLong = theApp.Imager()->GetNumShotsLong(); + buf.Format(_T("�㗠�B�e\n%d�b%d��"), numShort / fps, numShort); + GetDlgItem(IDC_BTN_SHORTSHOT)->SetWindowText(buf); + GetDlgItem(IDC_BTN_SHORTSHOT)->SetFont(&m_FontBtn); + buf.Format(_T("��\�B�e\n%d�b%d��"), numLong / fps, numLong); + GetDlgItem(IDC_BTN_LONGSHOT)->SetWindowText(buf); + GetDlgItem(IDC_BTN_LONGSHOT)->SetFont(&m_FontBtn); + GetDlgItem(IDC_BTN_CALIB)->SetFont(&m_FontBtn); + GetDlgItem(IDC_BTN_SHOKEN)->SetFont(&m_FontBtn); + GetDlgItem(IDC_TXT_ID)->SetFont(&m_FontBtn); + GetDlgItem(IDC_EDT_ID)->SetFont(&m_FontBtn); + GetDlgItem(IDC_RAD_GENDERM)->SetFont(&m_FontBtn); + GetDlgItem(IDC_RAD_GENDERF)->SetFont(&m_FontBtn); + + m_xvGender = 0; + UpdateData(FALSE); + + // �^�C�}�[�N�� + SetTimer(REDRAW_TIMER, 33, NULL); +} + +// CTIAS_Imager2View ���b�Z�[�W �n���h���[ + +// ��ʍX�V +void CTIAS_Imager2View::OnPaint() +{ + CPaintDC dc(this); + + BYTE *buf = theApp.Imager()->GetStream(m_Bih.biWidth, m_Bih.biHeight); + if (buf) { + RECT r; + GetClientRect(&r); + + // �摜�`�� + SetStretchBltMode(dc.GetSafeHdc(), COLORONCOLOR); + StretchDIBits(dc.GetSafeHdc(), + 0, 0, r.bottom * abs(m_Bih.biWidth) / abs(m_Bih.biHeight), r.bottom, + 0, 0, abs(m_Bih.biWidth), abs(m_Bih.biHeight), buf, + (BITMAPINFO*)&m_Bih, DIB_RGB_COLORS, SRCCOPY); + } + + // �X�e�[�^�X�o�[�X�V + ((CMainFrame*)AfxGetMainWnd())->SetStatusMsg(CMainFrame::SBAR_MSG, theApp.Imager()->GetStatusText()); + ((CMainFrame*)AfxGetMainWnd())->SetStatusMsg(CMainFrame::SBAR_FPS, theApp.Imager()->GetFpsText()); + + // �C�x���g���� + this->EventProc(); +} + +// ��ʍX�V�^�C�}�[ +void CTIAS_Imager2View::OnTimer(UINT_PTR nIDEvent) +{ + if (nIDEvent == REDRAW_TIMER) Invalidate(FALSE); + + CFormView::OnTimer(nIDEvent); +} + +// �����V���b�g�B�e +void CTIAS_Imager2View::OnBnClickedBtnOneshot() +{ + if (!this->BeginProc()) return; + theApp.Imager()->TakeOne(); +} + +// �����ԎB�e +void CTIAS_Imager2View::OnBnClickedBtnLongshot() +{ + if (!this->BeginProc()) return; + theApp.Imager()->TakeLong(); +} + +// �Z���ԎB�e +void CTIAS_Imager2View::OnBnClickedBtnShortshot() +{ + if (!this->BeginProc()) return; + theApp.Imager()->TakeShort(); +} + +// ���f�{�^�� +void CTIAS_Imager2View::OnBnClickedBtnAbort() +{ + theApp.Imager()->Abort(); +} + +// �Z�� +void CTIAS_Imager2View::OnBnClickedBtnCalib() +{ + this->BeginProc(FALSE, FALSE); + m_CalibRecoded = FALSE; + theApp.Imager()->StartCalibrate(); +} + +// �������̓{�^�� +void CTIAS_Imager2View::OnBnClickedBtnShoken() +{ + if (!this->BeginProc()) return; + this->EnableControls(TRUE); + theApp.Imager()->ShokenForm(); +} + +// �E�C���h�E�j���� +void CTIAS_Imager2View::OnDestroy() +{ + CFormView::OnDestroy(); + + theApp.Imager()->CloseApp(); +} + +// �C�x���g���� +void CTIAS_Imager2View::EventProc() +{ + switch (theApp.Imager()->GetEvent()) { + case CImager::EV_CALIB_DONE: + if (!m_CalibRecoded) { + m_CalibRecoded = TRUE; + theApp.Imager()->TakeOne(); + } + if (theApp.Imager()->GetStatus() == CImager::ST_PREVIEW) this->EnableControls(TRUE); + break; + case CImager::EV_MEAS_DONE: + this->EnableControls(TRUE); + break; + case CImager::EV_SAVE_DONE: + this->EnableControls(TRUE); + break; + case CImager::EV_ABORT: + this->EnableControls(TRUE); + break; + case CImager::EV_CALIB_FAILED: + GetDlgItem(IDC_BTN_CALIB)->EnableWindow(TRUE); + break; + } +} + +// �����J�n +BOOL CTIAS_Imager2View::BeginProc(BOOL bNeedCheck, BOOL bAbortable) +{ + theApp.Imager()->ResetEvent(); + + if (bNeedCheck) { + UpdateData(); + if (m_xvEdtID.GetLength() < 1) { + AfxMessageBox(_T("�팱��ID����͂��Ă�������")); + return FALSE; + } + theApp.Imager()->SetSubject(m_xvEdtID, m_xvGender); + } + + this->EnableControls(FALSE, bAbortable); + + return TRUE; +} + +// �R���g���[���̗L���E������ +void CTIAS_Imager2View::EnableControls(BOOL bEnable, BOOL bAbortable) +{ + GetDlgItem(IDC_EDT_ID)->EnableWindow(bEnable); + GetDlgItem(IDC_RAD_GENDERM)->EnableWindow(bEnable); + GetDlgItem(IDC_RAD_GENDERF)->EnableWindow(bEnable); + GetDlgItem(IDC_BTN_ONESHOT)->EnableWindow(bEnable); + GetDlgItem(IDC_BTN_CALIB)->EnableWindow(bEnable); + GetDlgItem(IDC_BTN_SHOKEN)->EnableWindow(bEnable); + GetDlgItem(IDC_BTN_LONGSHOT)->EnableWindow(bEnable); + GetDlgItem(IDC_BTN_SHORTSHOT)->EnableWindow(bEnable); + + if (bAbortable || bEnable) { + GetDlgItem(IDC_BTN_ABORT)->EnableWindow(!bEnable); + } +} + diff --git a/TIAS_Imager2/TIAS_Imager2View.h b/TIAS_Imager2/TIAS_Imager2View.h new file mode 100644 index 0000000..1007b7e --- /dev/null +++ b/TIAS_Imager2/TIAS_Imager2View.h @@ -0,0 +1,52 @@ + +// TIAS_Imager2View.h : CTIAS_Imager2View �N���X�̃C���^�[�t�F�C�X +// + +#pragma once + +#include "resource.h" + +#define REDRAW_TIMER 1 +#define RIGHT_MARGIN 200 + +class CTIAS_Imager2View : public CFormView +{ +public: + enum{ IDD = IDD_TIAS_IMAGER2_FORM }; + + virtual ~CTIAS_Imager2View(); + CTIAS_Imager2Doc* GetDocument() const; + +protected: + BITMAPINFOHEADER m_Bih; + CFont m_FontBtn; + CString m_xvEdtID; + int m_xvGender; + BOOL m_CalibRecoded; + + BOOL BeginProc(BOOL bNeedCheck = TRUE, BOOL bAbortable = TRUE); + void EnableControls(BOOL bEnable, BOOL bAbortable = TRUE); + void EventProc(); + CTIAS_Imager2View(); + DECLARE_DYNCREATE(CTIAS_Imager2View) + DECLARE_MESSAGE_MAP() + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV �T�|�[�g + virtual void OnInitialUpdate(); // �\�z��ɏ��߂ČĂяo����܂��B + virtual BOOL PreCreateWindow(CREATESTRUCT& cs); + afx_msg void OnPaint(); + afx_msg void OnTimer(UINT_PTR nIDEvent); + afx_msg void OnDestroy(); + afx_msg void OnBnClickedBtnOneshot(); + afx_msg void OnBnClickedBtnLongshot(); + afx_msg void OnBnClickedBtnShortshot(); + afx_msg void OnBnClickedBtnCalib(); + afx_msg void OnBnClickedBtnShoken(); +public: + afx_msg void OnBnClickedBtnAbort(); +}; + +#ifndef _DEBUG // TIAS_Imager2View.cpp �̃f�o�b�O �o�[�W���� +inline CTIAS_Imager2Doc* CTIAS_Imager2View::GetDocument() const + { return reinterpret_cast(m_pDocument); } +#endif + diff --git a/TIAS_Imager2/lucamapi.h b/TIAS_Imager2/lucamapi.h new file mode 100644 index 0000000..09870f3 --- /dev/null +++ b/TIAS_Imager2/lucamapi.h @@ -0,0 +1,554 @@ +/***************************************************************************** +* +* Copyright (c) 2002-2008 Lumenera Corporation. All rights reserved. +* +*****************************************************************************/ + +#ifndef __LUCAMAPI_H +#define __LUCAMAPI_H + + + +#ifdef LUCAMAPI_EXPORTS +#ifdef __cplusplus +#define LUCAM_API extern "C" __declspec(dllexport) +#else +#define LUCAM_API __declspec(dllexport) +#endif +#else +#ifdef __cplusplus +#define LUCAM_API extern "C" __declspec(dllimport) +#else +#define LUCAM_API __declspec(dllimport) +#endif +#endif + +#if (_MSC_VER >= 1300) +#define LUCAM_DEPRECATED __declspec(deprecated) +#else +#define LUCAM_DEPRECATED +#endif + + +#define LUCAM_EXPORT __stdcall + + + + +//----------- Pixel Format IDs ------------------ + +#define LUCAM_PF_8 0 +#define LUCAM_PF_16 1 +#define LUCAM_PF_24 2 +#define LUCAM_PF_YUV422 3 +#define LUCAM_PF_COUNT 4 +#define LUCAM_PF_FILTER 5 +#define LUCAM_PF_32 6 +#define LUCAM_PF_48 7 + + +//----------- Properties ------------------------ + +#define LUCAM_PROP_BRIGHTNESS 0 +#define LUCAM_PROP_CONTRAST 1 +#define LUCAM_PROP_HUE 2 +#define LUCAM_PROP_SATURATION 3 +#define LUCAM_PROP_SHARPNESS 4 +#define LUCAM_PROP_GAMMA 5 + +#define LUCAM_PROP_PAN 16 +#define LUCAM_PROP_TILT 17 +#define LUCAM_PROP_ROLL 18 +#define LUCAM_PROP_ZOOM 19 +#define LUCAM_PROP_EXPOSURE 20 +#define LUCAM_PROP_IRIS 21 +#define LUCAM_PROP_FOCUS 22 + + + +#define LUCAM_PROP_GAIN 40 +#define LUCAM_PROP_GAIN_RED 41 +#define LUCAM_PROP_GAIN_BLUE 42 +#define LUCAM_PROP_GAIN_GREEN1 43 +#define LUCAM_PROP_GAIN_GREEN2 44 +#define LUCAM_PROP_GAIN_MAGENTA 41 +#define LUCAM_PROP_GAIN_CYAN 42 +#define LUCAM_PROP_GAIN_YELLOW1 43 +#define LUCAM_PROP_GAIN_YELLOW2 44 + + +#define LUCAM_PROP_DEMOSAICING_METHOD 64 +#define LUCAM_PROP_CORRECTION_MATRIX 65 +#define LUCAM_PROP_FLIPPING 66 + +#define LUCAM_PROP_DIGITAL_WHITEBALANCE_U 69 // from -100 to 100 +#define LUCAM_PROP_DIGITAL_WHITEBALANCE_V 70 // from -100 to 100 +#define LUCAM_PROP_DIGITAL_GAIN 71 // from 0 to 2, 1 means a gain of 1.0 +#define LUCAM_PROP_DIGITAL_GAIN_RED 72 // from 0 to 2.5, 1 means a gain of 1.0. Relates to GAIN_Y and WHITEBALANCE +#define LUCAM_PROP_DIGITAL_GAIN_GREEN 73 // from 0 to 2.5, 1 means a gain of 1.0. Relates to GAIN_Y and WHITEBALANCE +#define LUCAM_PROP_DIGITAL_GAIN_BLUE 74 // from 0 to 2.5, 1 means a gain of 1.0. Relates to GAIN_Y and WHITEBALANCE + +#define LUCAM_PROP_COLOR_FORMAT 80 // (read only) +#define LUCAM_PROP_MAX_WIDTH 81 // (read only) +#define LUCAM_PROP_MAX_HEIGHT 82 // (read only) + +#define LUCAM_PROP_ABS_FOCUS 85 // requires the auto lens to be initialized +#define LUCAM_PROP_BLACK_LEVEL 86 + +#define LUCAM_PROP_KNEE1_EXPOSURE 96 +#define LUCAM_PROP_STILL_KNEE1_EXPOSURE 96 +#define LUCAM_PROP_KNEE2_EXPOSURE 97 +#define LUCAM_PROP_STILL_KNEE2_EXPOSURE 97 +#define LUCAM_PROP_STILL_KNEE3_EXPOSURE 98 +#define LUCAM_PROP_VIDEO_KNEE 99 +#define LUCAM_PROP_KNEE1_LEVEL 99 +#define LUCAM_PROP_THRESHOLD 101 +#define LUCAM_PROP_AUTO_EXP_TARGET 103 +#define LUCAM_PROP_TIMESTAMPS 105 +#define LUCAM_PROP_SNAPSHOT_CLOCK_SPEED 106 // 0 is the fastest +#define LUCAM_PROP_AUTO_EXP_MAXIMUM 107 +#define LUCAM_PROP_TEMPERATURE 108 +#define LUCAM_PROP_TRIGGER 110 +#define LUCAM_PROP_FRAME_GATE 112 +#define LUCAM_PROP_EXPOSURE_INTERVAL 113 +#define LUCAM_PROP_PWM 114 +#define LUCAM_PROP_MEMORY 115 // value is RO and represent # of frames in memory +#define LUCAM_PROP_STILL_STROBE_DURATION 116 +#define LUCAM_PROP_FAN 118 +#define LUCAM_PROP_SYNC_MODE 119 +#define LUCAM_PROP_SNAPSHOT_COUNT 120 +#define LUCAM_PROP_LSC_X 121 +#define LUCAM_PROP_LSC_Y 122 +#define LUCAM_PROP_AUTO_IRIS_MAX 123 +#define LUCAM_PROP_LENS_STABILIZATION 124 +#define LUCAM_PROP_VIDEO_TRIGGER 125 +#define LUCAM_PROP_KNEE2_LEVEL 163 +#define LUCAM_PROP_THRESHOLD_LOW 165 +#define LUCAM_PROP_THRESHOLD_HIGH 166 +#define LUCAM_PROP_TEMPERATURE2 167 +#define LUCAM_PROP_LIGHT_FREQUENCY 168 +#define LUCAM_PROP_LUMINANCE 169 +#define LUCAM_PROP_AUTO_GAIN_MAXIMUM 170 +#define LUCAM_PROP_AUTO_SHARPNESS_GAIN_THRESHOLD_LOW 171 +#define LUCAM_PROP_AUTO_SHARPNESS_GAIN_THRESHOLD_HIGH 172 +#define LUCAM_PROP_AUTO_SHARPNESS_LOW 173 +#define LUCAM_PROP_AUTO_SHARPNESS_HIGH 174 + +#define LUCAM_PROP_JPEG_QUALITY 256 + + +#define LUCAM_PROP_FLAG_USE 0x80000000 +#define LUCAM_PROP_FLAG_AUTO 0x40000000 +#define LUCAM_PROP_FLAG_MASTER 0x40000000 // for LUCAM_PROP_SYNC_MODE +#define LUCAM_PROP_FLAG_STROBE_FROM_START_OF_EXPOSURE 0x20000000 +#define LUCAM_PROP_FLAG_BACKLASH_COMPENSATION 0x20000000 // LUCAM_PROP_IRIS and LUCAM_PROP_FOCUS +#define LUCAM_PROP_FLAG_USE_FOR_SNAPSHOTS 0x04000000 // For LUCAM_PROP_IRIS +#define LUCAM_PROP_FLAG_POLARITY 0x10000000 +#define LUCAM_PROP_FLAG_MEMORY_READBACK 0x08000000 // for LUCAM_PROP_MEMORY +#define LUCAM_PROP_FLAG_BUSY 0x00040000 +#define LUCAM_PROP_FLAG_UNKNOWN_MAXIMUM 0x00020000 +#define LUCAM_PROP_FLAG_UNKNOWN_MINIMUM 0x00010000 +#define LUCAM_PROP_FLAG_LITTLE_ENDIAN 0x80000000 // for LUCAM_PROP_COLOR_FORMAT +#define LUCAM_PROP_FLAG_ALTERNATE 0x00080000 +#define LUCAM_PROP_FLAG_READONLY 0x00010000 // in caps param of GetPropertyRange + +// Prop flags for VIDEO_TRIGGER (also uses LUCAM_PROP_FLAG_USE) +#define LUCAM_PROP_FLAG_HW_ENABLE 0x40000000 +#define LUCAM_PROP_FLAG_SW_TRIGGER 0x00200000 // self cleared + + +// Those flags can be used with the LUCAM_PROP_GAMMA / LUCAM_PROP_BRIGHTNESS / LUCAM_PROP_CONTRAST +// properties. They are available on specifica cameras only. +#define LUCAM_PROP_FLAG_RED 0x00000001 +#define LUCAM_PROP_FLAG_GREEN1 0x00000002 +#define LUCAM_PROP_FLAG_GREEN2 0x00000004 +#define LUCAM_PROP_FLAG_BLUE 0x00000008 + + +// Do not access these properties unless you know what you are doing. + +#define LUCAM_PROP_STILL_EXPOSURE 50 +#define LUCAM_PROP_STILL_GAIN 51 +#define LUCAM_PROP_STILL_GAIN_RED 52 +#define LUCAM_PROP_STILL_GAIN_GREEN1 53 +#define LUCAM_PROP_STILL_GAIN_GREEN2 54 +#define LUCAM_PROP_STILL_GAIN_BLUE 55 +#define LUCAM_PROP_STILL_GAIN_MAGENTA 52 +#define LUCAM_PROP_STILL_GAIN_YELLOW1 53 +#define LUCAM_PROP_STILL_GAIN_YELLOW2 54 +#define LUCAM_PROP_STILL_GAIN_CYAN 55 + + +// color pattern for the LUCAM_PROP_COLOR_FORMAT property +#define LUCAM_CF_MONO 0 +#define LUCAM_CF_BAYER_RGGB 8 +#define LUCAM_CF_BAYER_GRBG 9 +#define LUCAM_CF_BAYER_GBRG 10 +#define LUCAM_CF_BAYER_BGGR 11 +#define LUCAM_CF_BAYER_CYYM 16 +#define LUCAM_CF_BAYER_YCMY 17 +#define LUCAM_CF_BAYER_YMCY 18 +#define LUCAM_CF_BAYER_MYYC 19 + +// parameter for the LUCAM_PROP_FLIPPING property +#define LUCAM_PROP_FLIPPING_NONE 0 +#define LUCAM_PROP_FLIPPING_X 1 +#define LUCAM_PROP_FLIPPING_Y 2 +#define LUCAM_PROP_FLIPPING_XY 3 + + + +//----------- Version Structure ------------------ + +typedef struct { + ULONG firmware; // Firmware version + ULONG fpga; // FPGA version + ULONG api; // API version + ULONG driver; // Device driver version + ULONG serialnumber; // of the camera + ULONG reserved; // do not use +} LUCAM_VERSION; + + +//------------- Frame format -------------------- + +typedef struct { + ULONG xOffset; // x coordinate on imager of top left corner of subwindow in pixels + ULONG yOffset; // y coordinate on imager of top left corner of subwindow in pixels + ULONG width; // width in pixels of subwindow + ULONG height; // height in pixels of subwindow + ULONG pixelFormat; // pixel format for data + union + { + USHORT subSampleX; // sub-sample ratio in x direction in pixels (x:1) + USHORT binningX; // binning ratio in x direction in pixels (x:1) + }; + USHORT flagsX; // LUCAM_FRAME_FORMAT_FLAGS_* + union + { + USHORT subSampleY; // sub-sample ratio in y direction in pixels (y:1) + USHORT binningY; // binning ratio in y direction in pixels (y:1) + }; + USHORT flagsY; // LUCAM_FRAME_FORMAT_FLAGS_* +} LUCAM_FRAME_FORMAT; + +#define LUCAM_FRAME_FORMAT_FLAGS_BINNING 0x0001 + + +//------------ Snapshot Settings Structure ------- + + +typedef struct { + FLOAT exposure; // Exposure in milliseconds + FLOAT gain; // Overall gain as a multiplicative factor + union { + struct { + FLOAT gainRed; // Gain for Red pixels as multiplicative factor + FLOAT gainBlue; // Gain for Blue pixels as multiplicative factor + FLOAT gainGrn1; // Gain for Green pixels on Red rows as multiplicative factor + FLOAT gainGrn2; // Gain for Green pixels on Blue rows as multiplicative factor + }; + struct { + FLOAT gainMag; // Gain for Magenta pixels as multiplicative factor + FLOAT gainCyan; // Gain for Cyan pixels as multiplicative factor + FLOAT gainYel1; // Gain for Yellow pixels on Magenta rows as multiplicative factor + FLOAT gainYel2; // Gain for Yellow pixels on Cyan rows as multiplicative factor + }; + }; + union + { + BOOL useStrobe; // for backward compatibility + ULONG strobeFlags; // use LUCAM_PROP_FLAG_USE and/or LUCAM_PROP_FLAG_STROBE_FROM_START_OF_EXPOSURE + }; + FLOAT strobeDelay; // time interval from when exposure starts to time the flash is fired in milliseconds + BOOL useHwTrigger; // wait for hardware trigger + FLOAT timeout; // maximum time to wait for hardware trigger prior to returning from function in milliseconds + LUCAM_FRAME_FORMAT format; // frame format for data + ULONG shutterType; + FLOAT exposureDelay; + union + { + BOOL bufferlastframe; // set to TRUE if you want TakeFastFrame to return an already received frame. + ULONG ulReserved1; + }; + ULONG ulReserved2; // must be set to 0 + FLOAT flReserved1; // must be set to 0 + FLOAT flReserved2; // must be set to 0 +} LUCAM_SNAPSHOT; + + +//------------ Streaming Video Modes -------------- + +#define STOP_STREAMING 0 +#define START_STREAMING 1 +#define START_DISPLAY 2 +#define PAUSE_STREAM 3 +#define START_RGBSTREAM 6 + +//------------ Streaming AVI Modes -------------- +#define STOP_AVI 0 +#define START_AVI 1 +#define PAUSE_AVI 2 + +//------------ Parameters for AVI types -------------- +#define AVI_RAW_LUMENERA 0 +#define AVI_STANDARD_24 1 +#define AVI_STANDARD_32 2 +#define AVI_XVID_24 3 +#define AVI_STANDARD_8 4 // for monochrome only + + +//---------- Parameters for LucamConvertFrameToRgb24 -------------- + +typedef struct +{ + ULONG DemosaicMethod; + ULONG CorrectionMatrix; + +}LUCAM_CONVERSION; + +// to use with LUCAM_CONVERSION.DemosaicMethod +#define LUCAM_DM_NONE 0 +#define LUCAM_DM_FAST 1 +#define LUCAM_DM_HIGH_QUALITY 2 +#define LUCAM_DM_HIGHER_QUALITY 3 +#define LUCAM_DM_SIMPLE 8 + + +// to use with LUCAM_CONVERSION.CorrectionMatrix +#define LUCAM_CM_NONE 0 +#define LUCAM_CM_FLUORESCENT 1 +#define LUCAM_CM_DAYLIGHT 2 +#define LUCAM_CM_INCANDESCENT 3 +#define LUCAM_CM_XENON_FLASH 4 +#define LUCAM_CM_HALOGEN 5 + +#define LUCAM_CM_IDENTITY 14 +#define LUCAM_CM_CUSTOM 15 + + +//----------- Shutter types ------------ + +#define LUCAM_SHUTTER_TYPE_GLOBAL 0 +#define LUCAM_SHUTTER_TYPE_ROLLING 1 + + +//----------- Extern interfaces ------- + +#define LUCAM_EXTERN_INTERFACE_USB1 1 +#define LUCAM_EXTERN_INTERFACE_USB2 2 + + + +//---------- Functions ---------------- + +LUCAM_API LONG LUCAM_EXPORT LucamNumCameras(void); +LUCAM_API LONG LUCAM_EXPORT LucamEnumCameras(LUCAM_VERSION *pVersionsArray, ULONG arrayCount); + +LUCAM_API HANDLE LUCAM_EXPORT LucamCameraOpen(ULONG index); +LUCAM_API BOOL LUCAM_EXPORT LucamCameraClose(HANDLE hCamera); +LUCAM_API BOOL LUCAM_EXPORT LucamCameraReset(HANDLE hCamera); + +LUCAM_API BOOL LUCAM_EXPORT LucamQueryVersion(HANDLE hCamera, LUCAM_VERSION *pVersion); +LUCAM_API BOOL LUCAM_EXPORT LucamQueryExternInterface(HANDLE hCamera, ULONG *pExternInterface); +LUCAM_API BOOL LUCAM_EXPORT LucamGetCameraId(HANDLE hCamera, ULONG *pId); + +LUCAM_API BOOL LUCAM_EXPORT LucamGetProperty(HANDLE hCamera, ULONG property, FLOAT *pValue, LONG *pFlags); +LUCAM_API BOOL LUCAM_EXPORT LucamSetProperty(HANDLE hCamera, ULONG property, FLOAT value, LONG flags); +LUCAM_API BOOL LUCAM_EXPORT LucamPropertyRange(HANDLE hCamera, ULONG property, FLOAT *pMin, FLOAT *pMax, FLOAT *pDefault, LONG *pFlags); + +LUCAM_API BOOL LUCAM_EXPORT LucamDisplayPropertyPage(HANDLE hCamera, HWND parentWnd); +LUCAM_API BOOL LUCAM_EXPORT LucamDisplayVideoFormatPage(HANDLE hCamera, HWND parentWnd); + +LUCAM_API BOOL LUCAM_EXPORT LucamQueryDisplayFrameRate(HANDLE hCamera, FLOAT *pValue); + +LUCAM_API BOOL LUCAM_EXPORT LucamCreateDisplayWindow(HANDLE hCamera, LPCTSTR lpTitle = NULL, DWORD dwStyle = WS_OVERLAPPED|WS_MINIMIZEBOX|WS_CAPTION|WS_SYSMENU|WS_VISIBLE, int x = 0, int y = 0, int width = 0, int height = 0, HWND parent = NULL, HMENU childId = NULL); +LUCAM_API BOOL LUCAM_EXPORT LucamDestroyDisplayWindow(HANDLE hCamera); +LUCAM_API BOOL LUCAM_EXPORT LucamAdjustDisplayWindow(HANDLE hCamera, LPCTSTR lpTitle = NULL, int x = 0, int y = 0, int width = 0, int height = 0); + +LUCAM_API BOOL LUCAM_EXPORT LucamReadRegister(HANDLE hCamera, LONG address, LONG numReg, LONG *pValue); +LUCAM_API BOOL LUCAM_EXPORT LucamWriteRegister(HANDLE hCamera, LONG address, LONG numReg, LONG *pValue); + +LUCAM_API BOOL LUCAM_EXPORT LucamSetFormat(HANDLE hCamera, LUCAM_FRAME_FORMAT *pFormat, FLOAT frameRate); +LUCAM_API BOOL LUCAM_EXPORT LucamGetFormat(HANDLE hCamera, LUCAM_FRAME_FORMAT *pFormat, FLOAT *pFrameRate); + +LUCAM_API ULONG LUCAM_EXPORT LucamEnumAvailableFrameRates(HANDLE hCamera, ULONG entryCount, FLOAT *pAvailableFrameRates); + +LUCAM_API BOOL LUCAM_EXPORT LucamStreamVideoControl (HANDLE hCamera, ULONG controlType, HWND hWnd); +LUCAM_API BOOL LUCAM_EXPORT LucamStreamVideoControlAVI (HANDLE hCamera, ULONG controlType, LPCWSTR pFileName, HWND hWnd); + +LUCAM_API BOOL LUCAM_EXPORT LucamTakeVideo(HANDLE hCamera, LONG numFrames, BYTE *pData); +LUCAM_API BOOL LUCAM_EXPORT LucamTakeVideoEx(HANDLE hCamera, BYTE *pData, ULONG *pLength, ULONG timeout); +LUCAM_API BOOL LUCAM_EXPORT LucamCancelTakeVideo(HANDLE hCamera); + +LUCAM_API BOOL LUCAM_EXPORT LucamTakeSnapshot(HANDLE hCamera, LUCAM_SNAPSHOT *pSettings, BYTE *pData); + +LUCAM_API LUCAM_DEPRECATED BOOL LUCAM_EXPORT LucamSaveImage(ULONG width, ULONG height, ULONG pixelFormat, BYTE *pData, const CHAR *pFilename); +LUCAM_API BOOL LUCAM_EXPORT LucamSaveImageEx(HANDLE hCamera, ULONG width, ULONG height, ULONG pixelFormat, BYTE *pData, const CHAR *pFilename); +LUCAM_API LUCAM_DEPRECATED BOOL LUCAM_EXPORT LucamSaveImageW(ULONG width, ULONG height, ULONG pixelFormat, BYTE *pData, const WCHAR *pFilename); +LUCAM_API BOOL LUCAM_EXPORT LucamSaveImageWEx(HANDLE hCamera, ULONG width, ULONG height, ULONG userPixelFormat, BYTE *pData, const WCHAR *pWFilename); + +LUCAM_API LONG LUCAM_EXPORT LucamAddStreamingCallback(HANDLE hCamera, VOID (__stdcall *VideoFilter)(VOID *pContext, BYTE *pData, ULONG dataLength), VOID *pCBContext); +LUCAM_API BOOL LUCAM_EXPORT LucamRemoveStreamingCallback(HANDLE hCamera, LONG callbackId); + +LUCAM_API LONG LUCAM_EXPORT LucamAddRgbPreviewCallback(HANDLE hCamera, VOID (__stdcall *RgbVideoFilter)(VOID *pContext, BYTE *pData, ULONG dataLength, ULONG unused), VOID *pContext, ULONG rgbPixelFormat); +LUCAM_API BOOL LUCAM_EXPORT LucamRemoveRgbPreviewCallback(HANDLE hCamera, LONG callbackId); +LUCAM_API BOOL LUCAM_EXPORT LucamQueryRgbPreviewPixelFormat(HANDLE hCamera, ULONG *pRgbPixelFormat); + +LUCAM_API LONG LUCAM_EXPORT LucamAddSnapshotCallback(HANDLE hCamera, VOID (__stdcall *SnapshotCallback)(VOID *pContext, BYTE *pData, ULONG dataLength), VOID *pCBContext); +LUCAM_API BOOL LUCAM_EXPORT LucamRemoveSnapshotCallback(HANDLE hCamera, LONG callbackId); + +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToRgb24(HANDLE hCamera, BYTE *pDest, BYTE *pSrc, ULONG width, ULONG height, ULONG pixelFormat, LUCAM_CONVERSION *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToRgb32(HANDLE hCamera, BYTE *pDest, BYTE *pSrc, ULONG width, ULONG height, ULONG pixelFormat, LUCAM_CONVERSION *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToRgb48(HANDLE hCamera, USHORT *pDest, USHORT *pSrc, ULONG width, ULONG height, ULONG userPixelFormat, LUCAM_CONVERSION *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToGreyscale8(HANDLE hCamera, BYTE *pDest, BYTE *pSrc, ULONG width, ULONG height, ULONG userPixelFormat, LUCAM_CONVERSION *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToGreyscale16(HANDLE hCamera, USHORT *pDest, USHORT *pSrc, ULONG width, ULONG height, ULONG userPixelFormat, LUCAM_CONVERSION *pParams); +LUCAM_API VOID LUCAM_EXPORT LucamConvertBmp24ToRgb24(UCHAR *pFrame, ULONG width, ULONG height); + +//This function is used for converting a raw AVI to a standard AVI +LUCAM_API BOOL LUCAM_EXPORT LucamConvertRawAVIToStdVideo(HANDLE hCamera, const WCHAR *pOutputFileName, const WCHAR *pInputFileName, ULONG outputType); + +//The 3 next functions are used for previewing raw AVI files +LUCAM_API HANDLE LUCAM_EXPORT LucamPreviewAVIOpen(const WCHAR *pFileName); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIClose(HANDLE hAVI); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIControl(HANDLE hAVI, ULONG previewControlType, HWND previewWindow); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIGetDuration(HANDLE hAVI, LONGLONG *pDurationMinutes, LONGLONG *pDurationSeconds, LONGLONG *pDurationMilliseconds, LONGLONG *pDurationMicroSeconds); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIGetFrameCount(HANDLE hAVI, LONGLONG *pFrameCount); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIGetFrameRate(HANDLE hAVI, FLOAT *pFrameRate); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIGetPositionTime(HANDLE hAVI, LONGLONG *pPositionMinutes, LONGLONG *pPositionSeconds, LONGLONG *pPositionMilliSeconds, LONGLONG *pPositionMicroSeconds); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIGetPositionFrame(HANDLE hAVI, LONGLONG *pPositionCurrentFrame); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVISetPositionTime(HANDLE hAVI, LONGLONG pPositionMinutes, LONGLONG pPositionSeconds, LONGLONG pPositionMilliSeconds, LONGLONG pPositionMicroSeconds); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVISetPositionFrame(HANDLE hAVI, LONGLONG pPositionFrame); +LUCAM_API BOOL LUCAM_EXPORT LucamPreviewAVIGetFormat(HANDLE hAVI, LONG *width, LONG *height, LONG *fileType, LONG *bitDepth); + + +LUCAM_API BOOL LUCAM_EXPORT LucamSetupCustomMatrix(HANDLE hCamera, FLOAT *pMatrix); +LUCAM_API BOOL LUCAM_EXPORT LucamGetCurrentMatrix(HANDLE hCamera, FLOAT *pMatrix); + +LUCAM_API BOOL LUCAM_EXPORT LucamEnableFastFrames(HANDLE hCamera, LUCAM_SNAPSHOT *pSettings); +LUCAM_API BOOL LUCAM_EXPORT LucamTakeFastFrame(HANDLE hCamera, BYTE *pData); +LUCAM_API BOOL LUCAM_EXPORT LucamForceTakeFastFrame(HANDLE hCamera, BYTE *pData); +LUCAM_API BOOL LUCAM_EXPORT LucamTakeFastFrameNoTrigger(HANDLE hCamera, BYTE *pData); +LUCAM_API BOOL LUCAM_EXPORT LucamDisableFastFrames(HANDLE hCamera); +LUCAM_API BOOL LUCAM_EXPORT LucamSetTriggerMode(HANDLE hCamera, BOOL useHwTrigger); +LUCAM_API BOOL LUCAM_EXPORT LucamTriggerFastFrame(HANDLE hCamera); +LUCAM_API BOOL LUCAM_EXPORT LucamCancelTakeFastFrame(HANDLE hCamera); + +LUCAM_API HANDLE LUCAM_EXPORT LucamEnableSynchronousSnapshots(ULONG numberOfCameras, HANDLE *phCameras, LUCAM_SNAPSHOT **ppSettings); +LUCAM_API BOOL LUCAM_EXPORT LucamTakeSynchronousSnapshots(HANDLE syncSnapsHandle, BYTE **ppBuffers); +LUCAM_API BOOL LUCAM_EXPORT LucamDisableSynchronousSnapshots(HANDLE syncSnapsHandle); + +LUCAM_API BOOL LUCAM_EXPORT LucamGpioRead(HANDLE hCamera, BYTE *pGpoValues, BYTE *pGpiValues); +LUCAM_API BOOL LUCAM_EXPORT LucamGpioWrite(HANDLE hCamera, BYTE gpoValues); +LUCAM_API BOOL LUCAM_EXPORT LucamGpoSelect(HANDLE hCamera, BYTE gpoEnable); // Selects between GPO output or alternate function +LUCAM_API BOOL LUCAM_EXPORT LucamGpioConfigure(HANDLE hCamera, BYTE enableOutput); // Enables output drive on a pin. + +LUCAM_API BOOL LUCAM_EXPORT LucamOneShotAutoExposure(HANDLE hCamera, UCHAR target, ULONG startX, ULONG startY, ULONG width, ULONG height); +LUCAM_API BOOL LUCAM_EXPORT LucamOneShotAutoWhiteBalance(HANDLE hCamera, ULONG startX, ULONG startY, ULONG width, ULONG height); +LUCAM_API BOOL LUCAM_EXPORT LucamOneShotAutoWhiteBalanceEx(HANDLE hCamera, float redOverGreen, float blueOverGreen, ULONG startX, ULONG startY, ULONG width, ULONG height); +LUCAM_API BOOL LUCAM_EXPORT LucamDigitalWhiteBalance(HANDLE hCamera, ULONG startX, ULONG startY, ULONG width, ULONG height); +LUCAM_API BOOL LUCAM_EXPORT LucamDigitalWhiteBalanceEx(HANDLE hCamera, float redOverGreen, float blueOverGreen, ULONG startX, ULONG startY, ULONG width, ULONG height); +LUCAM_API BOOL LUCAM_EXPORT LucamAdjustWhiteBalanceFromSnapshot(HANDLE hCamera, LUCAM_SNAPSHOT *pSettings, BYTE *pData, float redOverGreen, float blueOverGreen, ULONG startX, ULONG startY, ULONG width, ULONG height); +LUCAM_API BOOL LUCAM_EXPORT LucamOneShotAutoIris(HANDLE hCamera, UCHAR target, ULONG startX, ULONG startY, ULONG width, ULONG height); +LUCAM_API BOOL LUCAM_EXPORT LucamContinuousAutoExposureEnable(HANDLE hCamera, UCHAR target, ULONG startX, ULONG startY, ULONG width, ULONG height, FLOAT lightingPeriod); +LUCAM_API BOOL LUCAM_EXPORT LucamContinuousAutoExposureDisable(HANDLE hCamera); + +LUCAM_API BOOL LUCAM_EXPORT LucamAutoFocusStart(HANDLE hCamera, ULONG startX, ULONG startY, ULONG width, ULONG height, FLOAT putZeroThere1, FLOAT putZeroThere2, FLOAT putZeroThere3, BOOL (__stdcall * ProgressCallback)(void *context, FLOAT percentageCompleted), void *contextForCallback); +LUCAM_API BOOL LUCAM_EXPORT LucamAutoFocusWait(HANDLE hCamera, DWORD timeout); +LUCAM_API BOOL LUCAM_EXPORT LucamAutoFocusStop(HANDLE hCamera); +LUCAM_API BOOL LUCAM_EXPORT LucamAutoFocusQueryProgress(HANDLE hCamera, FLOAT *pPercentageCompleted); +LUCAM_API BOOL LUCAM_EXPORT LucamInitAutoLens(HANDLE hCamera, BOOL force); + +LUCAM_API BOOL LUCAM_EXPORT LucamSetup8bitsLUT(HANDLE hCamera, UCHAR *pLut, ULONG length); // length must be 0 or 256 +LUCAM_API BOOL LUCAM_EXPORT LucamSetup8bitsColorLUT(HANDLE hCamera, UCHAR *pLut, ULONG length, BOOL applyOnRed, BOOL applyOnGreen1, BOOL applyOnGreen2 , BOOL applyOnBlue); // length must be 0 or 256 + +LUCAM_API int LUCAM_EXPORT LucamRs232Transmit(HANDLE hCamera, char *pData, int length); +LUCAM_API int LUCAM_EXPORT LucamRs232Receive(HANDLE hCamera, char *pData, int maxLength); +LUCAM_API BOOL LUCAM_EXPORT LucamAddRs232Callback(HANDLE hCamera, void (__stdcall * callback)(void *), void *context); +LUCAM_API VOID LUCAM_EXPORT LucamRemoveRs232Callback(HANDLE hCamera); + +LUCAM_API BOOL LUCAM_EXPORT LucamPermanentBufferRead(HANDLE hCamera, UCHAR *pBuf, ULONG offset, ULONG length); +LUCAM_API BOOL LUCAM_EXPORT LucamPermanentBufferWrite(HANDLE hCamera, UCHAR *pBuf, ULONG offset, ULONG length); + +LUCAM_API BOOL LUCAM_EXPORT LucamGetTruePixelDepth(HANDLE hCamera, ULONG *pCount); + +LUCAM_API BOOL LUCAM_EXPORT LucamSetTimeout(HANDLE hCamera, BOOL still, FLOAT timeout); + +LUCAM_API ULONG LUCAM_EXPORT LucamGetLastError(void); +LUCAM_API ULONG LUCAM_EXPORT LucamGetLastErrorForCamera(HANDLE hCamera); + +// New Structure used for the new conversion functions + +typedef struct _LUCAM_CONVERSION_PARAMS +{ + ULONG Size; // of this structure + ULONG DemosaicMethod; + ULONG CorrectionMatrix; + BOOL FlipX; + BOOL FlipY; + FLOAT Hue; + FLOAT Saturation; + BOOL UseColorGainsOverWb; + union + { + struct + { + FLOAT DigitalGain; + FLOAT DigitalWhiteBalanceU; + FLOAT DigitalWhiteBalanceV; + }; + struct + { + FLOAT DigitalGainRed; + FLOAT DigitalGainGreen; + FLOAT DigitalGainBlue; + }; + }; +}LUCAM_CONVERSION_PARAMS, *PLUCAM_CONVERSION_PARAMS; + + +typedef struct _LUCAM_IMAGE_FORMAT +{ + ULONG Size; // of this structure + ULONG Width; + ULONG Height; + ULONG PixelFormat; + ULONG ImageSize; + + ULONG LucamReserved[8]; + +}LUCAM_IMAGE_FORMAT, *PLUCAM_IMAGE_FORMAT; + +LUCAM_API BOOL LUCAM_EXPORT LucamGetVideoImageFormat(HANDLE hCamera, LUCAM_IMAGE_FORMAT *pImageFormat); +LUCAM_API BOOL LUCAM_EXPORT LucamGetStillImageFormat(HANDLE hCamera, LUCAM_IMAGE_FORMAT *pImageFormat); + +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToRgb24Ex(HANDLE hCamera, BYTE *pDest, const BYTE *pSrc, const LUCAM_IMAGE_FORMAT *pImageFormat, const LUCAM_CONVERSION_PARAMS *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToRgb32Ex(HANDLE hCamera, BYTE *pDest, const BYTE *pSrc, const LUCAM_IMAGE_FORMAT *pImageFormat, const LUCAM_CONVERSION_PARAMS *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToRgb48Ex(HANDLE hCamera, USHORT *pDest, const USHORT *pSrc, const LUCAM_IMAGE_FORMAT *pImageFormat, const LUCAM_CONVERSION_PARAMS *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToGreyscale8Ex(HANDLE hCamera, BYTE *pDest, const BYTE *pSrc, LUCAM_IMAGE_FORMAT *pImageFormat, LUCAM_CONVERSION_PARAMS *pParams); +LUCAM_API BOOL LUCAM_EXPORT LucamConvertFrameToGreyscale16Ex(HANDLE hCamera, USHORT *pDest, const USHORT *pSrc, LUCAM_IMAGE_FORMAT *pImageFormat, LUCAM_CONVERSION_PARAMS *pParams); + + +LUCAM_API PVOID LUCAM_EXPORT LucamRegisterEventNotification(HANDLE hCamera, DWORD eventId, HANDLE hEvent); +LUCAM_API BOOL LUCAM_EXPORT LucamUnregisterEventNotification(HANDLE hCamera, PVOID pEventInformation); + +// For use with LucamRegisterEventNotification +#define LUCAM_EVENT_START_OF_READOUT 2 +#define LUCAM_EVENT_GPI1_CHANGED 4 +#define LUCAM_EVENT_GPI2_CHANGED 5 +#define LUCAM_EVENT_GPI3_CHANGED 6 +#define LUCAM_EVENT_GPI4_CHANGED 7 +#define LUCAM_EVENT_DEVICE_SURPRISE_REMOVAL 32 + + +LUCAM_API BOOL LUCAM_EXPORT LucamPerformDualTapCorrection(HANDLE hCamera, BYTE *pFrame, const LUCAM_IMAGE_FORMAT *pImageFormat); +LUCAM_API BOOL LUCAM_EXPORT LucamPerformMonoGridCorrection(HANDLE hCamera, BYTE *pFrame, const LUCAM_IMAGE_FORMAT *pImageFormat); + +LUCAM_API BOOL LUCAM_EXPORT LucamGetImageIntensity(HANDLE hCamera, BYTE *pFrame, LUCAM_IMAGE_FORMAT *pImageFormat , ULONG startX, ULONG startY, ULONG width, ULONG height, FLOAT *pIntensity, FLOAT *pRedIntensity, FLOAT *pGreen1Intensity, FLOAT *pGreen2Intensity, FLOAT *pBlueIntensity); + +LUCAM_API BOOL LUCAM_EXPORT LucamAutoRoiGet(HANDLE hCamera, LONG *pStartX, LONG *pStartY, LONG *pWidth, LONG *pHeight); +LUCAM_API BOOL LUCAM_EXPORT LucamAutoRoiSet(HANDLE hCamera, LONG startX, LONG startY, LONG width, LONG height); + + +#endif // __LUCAMAPI_H + diff --git a/TIAS_Imager2/lucamerr.h b/TIAS_Imager2/lucamerr.h new file mode 100644 index 0000000..668424b --- /dev/null +++ b/TIAS_Imager2/lucamerr.h @@ -0,0 +1,845 @@ +/***************************************************************************** +* +* Copyright (c) Lumenera Corporation 2002-2008. All rights reserved. +* +*****************************************************************************/ +#ifndef __LUCAMERR_H +#define __LUCAMERR_H + +//----------------------------------------------------------------------------- +// Id: LucamNoError +// +// Meaning: +// Initialization value in the API. +// +#define LucamNoError 0 + +//----------------------------------------------------------------------------- +// Id: LucamNoSuchIndex +// +// Meaning: +// The index passed to LucamCameraOpen was 0. It must be >= 1. +// +#define LucamNoSuchIndex 1 + +//----------------------------------------------------------------------------- +// Id: LucamSnapshotNotSupported +// +// Meaning: +// The camera does not support snapshots or fast frames. +// +#define LucamSnapshotNotSupported 2 + +//----------------------------------------------------------------------------- +// Id: LucamInvalidPixelFormat +// +// Meaning: +// The pixel format parameter passed to the function is invalid +// +#define LucamInvalidPixelFormat 3 + +//----------------------------------------------------------------------------- +// Id: LucamSubsamplingZero +// +// Meaning: +// A subsampling of zero was passed to a function. +// +#define LucamSubsamplingZero 4 + +//----------------------------------------------------------------------------- +// Id: LucamBusy +// +// Meaning: +// The function is unavailable because the camera is busy with streaming or +// capturing fast frames. +// +#define LucamBusy 5 + +//----------------------------------------------------------------------------- +// Id: LucamFailedToSetSubsampling +// +// Meaning: +// The API failed to set the requested subsampling. This can be due to +// the camera being disconnected. It can also be due to a filter +// not being there. +// +#define LucamFailedToSetSubsampling 6 + +//----------------------------------------------------------------------------- +// Id: LucamFailedToSetStartPosition +// +// Meaning: +// The API failed to set the requested subsampling. This can be due to +// the camera being disconnected. +// +#define LucamFailedToSetStartPosition 7 + +//----------------------------------------------------------------------------- +// Id: LucamPixelFormatNotSupported +// +// Meaning: +// The camera does not support the pixel format passed to the function. +// +#define LucamPixelFormatNotSupported 8 + +//----------------------------------------------------------------------------- +// Id: LucamInvalidFrameFormat +// +// Meaning: +// The format passed to the function does not pass the camera requirements. +// Verify that (xOffset + width) is not greater than the camera's maximum +// width. Verify that (width / subSamplingX) is a multiple of some 'nice' +// value. Do the same for the y. +// +#define LucamInvalidFrameFormat 9 + +//----------------------------------------------------------------------------- +// Id: LucamPreparationFailed +// +// Meaning: +// The API failed to prepare the camera for streaming or snapshot. This can +// due to the camera being disconnected. If START_STREAMING succeeds and +// START_DISPLAY fails with this error, this can be due to a filter not +// being there or registered. +// +#define LucamPreparationFailed 10 + +//----------------------------------------------------------------------------- +// Id: LucamCannotRun +// +// Meaning: +// The API failed to get the camera running. This can be due to a bandwidth +// problem. +// +#define LucamCannotRun 11 + +//----------------------------------------------------------------------------- +// Id: LucamNoTriggerControl +// +// Meaning: +// Contact Lumenera. +// +#define LucamNoTriggerControl 12 + +//----------------------------------------------------------------------------- +// Id: LucamNoPin +// +// Meaning: +// Contact Lumenera. +// +#define LucamNoPin 13 + +//----------------------------------------------------------------------------- +// Id: LucamNotRunning +// +// Meaning: +// The function failed because it requires the camera to be running, and it +// is not. +// +#define LucamNotRunning 14 + +//----------------------------------------------------------------------------- +// Id: LucamTriggerFailed +// +// Meaning: +// Contact Lumenera. +// +#define LucamTriggerFailed 15 + +//----------------------------------------------------------------------------- +// Id: LucamCannotSetupFrameFormat +// +// Meaning: +// The camera does not support that its frame format get setup. This will +// happen if your camera is plugged to a USB 1 port and it does not +// support it. LucamCameraOpen will still succeeds, but if a call to +// LucamGetLastError will return this value. +// +#define LucamCannotSetupFrameFormat 16 + +//----------------------------------------------------------------------------- +// Id: LucamDirectShowInitError +// +// Meaning: +// Direct Show initialization error. This may happen if you run the API +// before having installed a DS compatible camera ever before. The +// Lumenera camera is DS compatible. +// +#define LucamDirectShowInitError 17 + +//----------------------------------------------------------------------------- +// Id: LucamCameraNotFound +// +// Meaning: +// The function LucamCameraOpen did not find the camera # index. +// +#define LucamCameraNotFound 18 + +//----------------------------------------------------------------------------- +// Id: LucamTimeout +// +// Meaning: +// The function timed out. +// +#define LucamTimeout 19 + +//----------------------------------------------------------------------------- +// Id: LucamPropertyUnknown +// +// Meaning: +// The API does not know the property passed to LucamGetProperty, +// LucamSetProperty or LucamGetPropertyRange. You may be using an old dll. +// +#define LucamPropertyUnknown 20 + +//----------------------------------------------------------------------------- +// Id: LucamPropertyUnsupported +// +// Meaning: +// The camera does not support that property. +// +#define LucamPropertyUnsupported 21 + +//----------------------------------------------------------------------------- +// Id: LucamPropertyAccessFailed +// +// Meaning: +// The API failed to access the property. Most likely, the reason is that the +// camera does not support that property. +// +#define LucamPropertyAccessFailed 22 + +//----------------------------------------------------------------------------- +// Id: LucamLucustomNotFound +// +// Meaning: +// The lucustom.ax filter was not found. +// +#define LucamLucustomNotFound 23 + +//----------------------------------------------------------------------------- +// Id: LucamPreviewNotRunning +// +// Meaning: +// The function failed because preview is not running. +// +#define LucamPreviewNotRunning 24 + +//----------------------------------------------------------------------------- +// Id: LucamLutfNotLoaded +// +// Meaning: +// The function failed because lutf.ax is not loaded. +// +#define LucamLutfNotLoaded 25 + +//----------------------------------------------------------------------------- +// Id: LucamDirectShowError +// +// Meaning: +// An error related to the operation of DirectShow occured. +// +#define LucamDirectShowError 26 + +//----------------------------------------------------------------------------- +// Id: LucamNoMoreCallbacks +// +// Meaning: +// The function LucamAddStreamingCallback failed because the API cannot +// support any more callbacks +// +#define LucamNoMoreCallbacks 27 + +//----------------------------------------------------------------------------- +// Id: LucamUndeterminedFrameFormat +// +// Meaning: +// The API does not know what is the frame format of the camera. +// +#define LucamUndeterminedFrameFormat 28 + +//----------------------------------------------------------------------------- +// Id: LucamInvalidParameter +// +// Meaning: +// An parameter has an obviously wrong value. +// +#define LucamInvalidParameter 29 + +//----------------------------------------------------------------------------- +// Id: LucamNotEnoughResources +// +// Meaning: +// Resource allocation failed. +// +#define LucamNotEnoughResources 30 + +//----------------------------------------------------------------------------- +// Id: LucamNoSuchConversion +// +// Meaning: +// One of the members of the LUCAM_CONVERSION structure passed is either +// unknown or inappropriate +// +#define LucamNoSuchConversion 31 + +//----------------------------------------------------------------------------- +// Id: LucamParameterNotWithinBoundaries +// +// Meaning: +// A parameter representing a quantity is outside the allowed boundaries. +// +#define LucamParameterNotWithinBoundaries 32 + +//----------------------------------------------------------------------------- +// Id: LucamBadFileIo +// +// Meaning: +// An error occured creating a file or writing to it. Verify that the +// path exists. +// +#define LucamBadFileIo 33 + +//----------------------------------------------------------------------------- +// Id: LucamGdiplusNotFound +// +// Meaning: +// gdiplus.dll is needed and was not found. +// +#define LucamGdiplusNotFound 34 + +//----------------------------------------------------------------------------- +// Id: LucamGdiplusError +// +// Meaning: +// gdiplus.dll reported an error. This may happen if there is a file io error. +// +#define LucamGdiplusError 35 + +//----------------------------------------------------------------------------- +// Id: LucamUnknownFormatType +// +// Meaning: +// Contact Lumenera. +// +#define LucamUnknownFormatType 36 + +//----------------------------------------------------------------------------- +// Id: LucamFailedCreateDisplay +// +// Meaning: +// The API failed to create the display window. The reason could be +// unsufficient resources. +// +#define LucamFailedCreateDisplay 37 + +//----------------------------------------------------------------------------- +// Id: LucamDpLibNotFound +// +// Meaning: +// deltapolation.dll is needed and was not found. +// +#define LucamDpLibNotFound 38 + +//----------------------------------------------------------------------------- +// Id: LucamDpCmdNotSupported +// +// Meaning: +// The deltapolation command is not supported by the delta polation library. +// +#define LucamDpCmdNotSupported 39 + +//----------------------------------------------------------------------------- +// Id: LucamDpCmdUnknown +// +// Meaning: +// The deltapolation command is unknown or invalid. +// +#define LucamDpCmdUnknown 40 + +//----------------------------------------------------------------------------- +// Id: LucamNotWhilePaused +// +// Meaning: +// The function cannot be performed when the camera is in paused state. +// +#define LucamNotWhilePaused 41 + +//----------------------------------------------------------------------------- +// Id: LucamCaptureFailed +// +// Meaning: +// Contact Lumenera. +// +#define LucamCaptureFailed 42 + +//----------------------------------------------------------------------------- +// Id: LucamDpError +// +// Meaning: +// Contact Lumenera. +// +#define LucamDpError 43 + +//----------------------------------------------------------------------------- +// Id: LucamNoSuchFrameRate +// +// Meaning: +// Contact Lumenera. +// +#define LucamNoSuchFrameRate 44 + +//----------------------------------------------------------------------------- +// Id: LucamInvalidTarget +// +// Meaning: +// One of the target parameters is wrong. This error code is used when +// startX + width > (frameFormat.width / frameFormat.subSampleX) or +// startY + height > (frameFormat.height / frameFormat.subSampleY) or +// if any of those parameter is odd (not a multiple of 2) or +// if width or height is 0. +// +#define LucamInvalidTarget 45 + +//----------------------------------------------------------------------------- +// Id: LucamFrameTooDark +// +// Meaning: +// The frame is too dark to perform white balance. +// +#define LucamFrameTooDark 46 + +//----------------------------------------------------------------------------- +// Id: LucamKsPropertySetNotFound +// +// Meaning: +// A DirectShow interface necessary to carry out the operation was not found. +// +#define LucamKsPropertySetNotFound 47 + +//----------------------------------------------------------------------------- +// Id: LucamCancelled +// +// Meaning: +// The user cancelled the operation. +// +#define LucamCancelled 48 + +//----------------------------------------------------------------------------- +// Id: LucamKsControlNotSupported +// +// Meaning: +// The DirectShow IKsControl interface is not supported (did you unplugged the camera?). +// +#define LucamKsControlNotSupported 49 + +//----------------------------------------------------------------------------- +// Id: LucamEventNotSupported +// +// Meaning: +// Some module attempted to register an unsupported event. +// +#define LucamEventNotSupported 50 + +//----------------------------------------------------------------------------- +// Id: LucamNoPreview +// +// Meaning: +// The function failed because preview was not setup. +// +#define LucamNoPreview 51 + +//----------------------------------------------------------------------------- +// Id: LucamSetPositionFailed +// +// Meaning: +// A function setting window position failed (invalid parameters??). +// +#define LucamSetPositionFailed 52 + +//----------------------------------------------------------------------------- +// Id: LucamNoFrameRateList +// +// Meaning: +// The frame rate list is not available. +// +#define LucamNoFrameRateList 53 + +//----------------------------------------------------------------------------- +// Id: LucamFrameRateInconsistent +// +// Meaning: +// There was an error building the frame rate list. +// +#define LucamFrameRateInconsistent 54 + +//----------------------------------------------------------------------------- +// Id: LucamCameraNotConfiguredForCmd +// +// Meaning: +// The camera does not support that particular command. +// +#define LucamCameraNotConfiguredForCmd 55 + +//---------------------------------------------------------------------------- +// Id: LucamGraphNotReady +// +// Meaning: +// The graph is not ready. +// +#define LucamGraphNotReady 56 + +//---------------------------------------------------------------------------- +// Id: LucamCallbackSetupError +// +// Meaning: +// Contact Lumenera. +// +#define LucamCallbackSetupError 57 + +//---------------------------------------------------------------------------- +// Id: LucamInvalidTriggerMode +// +// Meaning: +// You cannot cause a soft trigger when hw trigger is enabled. +// +#define LucamInvalidTriggerMode 58 + +//---------------------------------------------------------------------------- +// Id: LucamNotFound +// +// Meaning: +// The API was asked to return soomething that is not there. +// +#define LucamNotFound 59 + +//---------------------------------------------------------------------------- +// Id: LucamEepromTooSmall +// +// Meaning: +// The onboard EEPROM is too small. +// +#define LucamPermanentBufferNotSupported 60 + +//---------------------------------------------------------------------------- +// Id: LucamEepromWriteFailed +// +// Meaning: +// The API failed to write to the onboard eeprom. +// +#define LucamEepromWriteFailed 61 + +//---------------------------------------------------------------------------- +// Id: LucamUnknownFileType +// +// Meaning: +// The API failed because it failed to recognize the file type of a +// file name passed to it.. +// +#define LucamUnknownFileType 62 + +//---------------------------------------------------------------------------- +// Id: LucamEventIdNotSupported +// +// Meaning: +// LucamRegisterEventNotification failed because the event is not supported. +// +#define LucamEventIdNotSupported 63 + +//---------------------------------------------------------------------------- +// Id: LucamEepromCorrupted +// +// Meaning: +// The API found that the EEPROM was corrupted. +// +#define LucamEepromCorrupted 64 + +//---------------------------------------------------------------------------- +// Id: LucamSectionTooBig +// +// Meaning: +// The VPD section to write to the eeprom is too big. +// +#define LucamSectionTooBig 65 + +//----------------------------------------------------------------------------- +// Id: LucamFrameTooBright +// +// Meaning: +// The frame is too bright to perform white balance. +// +#define LucamFrameTooBright 66 + +//----------------------------------------------------------------------------- +// Id: LucamNoCorrectionMatrix +// +// Meaning: +// The camera is configured to have no correction matrix (LUCAM_PROP_CORRECTION_MATRIX +// is LUCAM_CM_NONE). +// +#define LucamNoCorrectionMatrix 67 + +//----------------------------------------------------------------------------- +// Id: LucamUnknownCameraModel +// +// Meaning: +// The API failed because it needs to know the camera model and it is not available. +// +#define LucamUnknownCameraModel 68 + +//----------------------------------------------------------------------------- +// Id: LucamApiTooOld +// +// Meaning: +// The API failed because it needs to be upgraded to access a feature of the camera. +// +#define LucamApiTooOld 69 + +//----------------------------------------------------------------------------- +// Id: LucamSaturationZero +// +// Meaning: +// The API failed because the saturation is currently 0. +// +#define LucamSaturationZero 70 + +//----------------------------------------------------------------------------- +// Id: LucamAlreadyInitialised +// +// Meaning: +// The API failed because the object was already initialised. +// +#define LucamAlreadyInitialised 71 + +//----------------------------------------------------------------------------- +// Id: LucamSameInputAndOutputFile +// +// Meaning: +// The API failed because the object was already initialised. +// +#define LucamSameInputAndOutputFile 72 + +//----------------------------------------------------------------------------- +// Id: LucamFileConversionFailed +// +// Meaning: +// The API failed because the file conversion was not completed. +// +#define LucamFileConversionFailed 73 + +//----------------------------------------------------------------------------- +// Id: LucamFileAlreadyConverted +// +// Meaning: +// The API failed because the file is already converted in the desired format. +// +#define LucamFileAlreadyConverted 74 + +//----------------------------------------------------------------------------- +// Id: LucamPropertyPageNotSupported +// +// Meaning: +// The API failed to display the property page. +// +#define LucamPropertyPageNotSupported 75 + +//----------------------------------------------------------------------------- +// Id: LucamPropertyPageCreationFailed +// +// Meaning: +// The API failed to create the property page. +// +#define LucamPropertyPageCreationFailed 76 + +//----------------------------------------------------------------------------- +// Id: LucamDirectShowFilterNotInstalled +// +// Meaning: +// The API did not find the required direct show filter. +// +#define LucamDirectShowFilterNotInstalled 77 + +//----------------------------------------------------------------------------- +// Id: LucamIndividualLutNotAvailable +// +// Meaning: +// The camera does not support that different LUTs are applied to each color. +// +#define LucamIndividualLutNotAvailable 78 + +//----------------------------------------------------------------------------- +// Id: LucamUnexpectedError +// +// Meaning: +// Contact Lumenera. +// +#define LucamUnexpectedError 79 + +//----------------------------------------------------------------------------- +// Id: LucamStreamingStopped +// +// Meaning: +// LucamTakeFastFrame or LucamTakeVideo failed because another thread interrupted +// the streaming by a call to LucamDisableFastFrames or LucamStreamVideoControl. +// +#define LucamStreamingStopped 80 + +//----------------------------------------------------------------------------- +// Id: LucamMustBeInSwTriggerMode +// +// Meaning: +// LucamForceTakeFastFrame was called while the camera is in hardware trigger +// still mode and the camera does not support taking a sw trigger snapshot while +// in that state. +// +#define LucamMustBeInSwTriggerMode 81 + +//----------------------------------------------------------------------------- +// Id: LucamTargetFlaky +// +// Meaning: +// The target is too flaky to perform auto focus. +// +#define LucamTargetFlaky 82 + +//----------------------------------------------------------------------------- +// Id: LucamAutoLensUninitialized +// +// Meaning: +// The auto lens needs to be initialized before the function is used. +// +#define LucamAutoLensUninitialized 83 + +//----------------------------------------------------------------------------- +// Id: LucamLensNotInstalled +// +// Meaning: +// The function failed because the lens were not installed correctly. Verify +// that changing the focus has any effect. +// +#define LucamLensNotInstalled 84 + +//----------------------------------------------------------------------------- +// Id: LucamUnknownError +// +// Meaning: +// The function failed because of an unknoen error. Contact Lumenera. +// +#define LucamUnknownError 85 + +//----------------------------------------------------------------------------- +// Id: LucamFocusNoFeedbackError +// +// Meaning: +// There is no feedback available for focus. +// +#define LucamFocusNoFeedbackError 86 + +//----------------------------------------------------------------------------- +// Id: LucamLutfTooOld +// +// Meaning: +// LuTF.ax is too old for this feature. +// +#define LucamLutfTooOld 87 + +//----------------------------------------------------------------------------- +// Id: LucamUnknownAviFormat +// +// Meaning: +// Unknown or invalid AVI format for input file. +// +#define LucamUnknownAviFormat 88 + +//----------------------------------------------------------------------------- +// Id: LucamUnknownAviType +// +// Meaning: +// Unknown AVI type. Verify the AVI type parameter. +// +#define LucamUnknownAviType 89 + +//----------------------------------------------------------------------------- +// Id: LucamInvalidAviConversion +// +// Meaning: +// The AVI conversion is invalid. +// +#define LucamInvalidAviConversion 90 + +//----------------------------------------------------------------------------- +// Id: LucamSeekFailed +// +// Meaning: +// The seeking operation failed. +// +#define LucamSeekFailed 91 + +//----------------------------------------------------------------------------- +// Id: LucamAviRunning +// +// Meaning: +// The function cannot be performed while an AVI is being captured. +// +#define LucamAviRunning 92 + +//----------------------------------------------------------------------------- +// Id: LucamCameraAlreadyOpened +// +// Meaning: +// An attempt was made to open a camera for streaming-related reasons while +// it is already opened for such. +// +#define LucamCameraAlreadyOpened 93 + +//----------------------------------------------------------------------------- +// Id: LucamNoSubsampledHighRes +// +// Meaning: +// The API cannot take a high resolution image in subsampled mode or binning mode. +// +#define LucamNoSubsampledHighRes 94 + +//----------------------------------------------------------------------------- +// Id: LucamOnlyOnMonochrome +// +// Meaning: +// The API function is only available on monochrome cameras. +// +#define LucamOnlyOnMonochrome 95 + +//----------------------------------------------------------------------------- +// Id: LucamNo8bppTo48bpp +// +// Meaning: +// Building a 48 bpp image from an 8 bpp image is invalid. +// +#define LucamNo8bppTo48bpp 96 + +//----------------------------------------------------------------------------- +// Id: LucamLut8Obsolete +// +// Meaning: +// Use 12 bits lut instead. +// +#define LucamLut8Obsolete 97 + +//----------------------------------------------------------------------------- +// Id: LucamFunctionNotSupported +// +// Meaning: +// That functionnality is not supported. +// +#define LucamFunctionNotSupported 98 + +//----------------------------------------------------------------------------- +// Id: LucamRetryLimitReached +// +// Meaning: +// Property access failed due to a retry limit. +// +#define LucamRetryLimitReached 99 + + +#endif // __LUCAMERR_H + diff --git a/TIAS_Imager2/res/TIAS_Imager2.ico b/TIAS_Imager2/res/TIAS_Imager2.ico new file mode 100644 index 0000000..e90ae97 --- /dev/null +++ b/TIAS_Imager2/res/TIAS_Imager2.ico Binary files differ diff --git a/TIAS_Imager2/res/TIAS_Imager2.rc2 b/TIAS_Imager2/res/TIAS_Imager2.rc2 new file mode 100644 index 0000000..61faf9e --- /dev/null +++ b/TIAS_Imager2/res/TIAS_Imager2.rc2 Binary files differ diff --git a/TIAS_Imager2/resource.h b/TIAS_Imager2/resource.h new file mode 100644 index 0000000..87ba2ec --- /dev/null +++ b/TIAS_Imager2/resource.h Binary files differ diff --git a/TIAS_Imager2/stdafx.cpp b/TIAS_Imager2/stdafx.cpp new file mode 100644 index 0000000..024ad85 --- /dev/null +++ b/TIAS_Imager2/stdafx.cpp @@ -0,0 +1,38 @@ + +// stdafx.cpp : �W���C���N���[�h TIAS_Imager2.pch �݂̂� +// �܂ރ\�[�X �t�@�C���́A�v���R���p�C���ς݃w�b�_�[�ɂȂ�܂��B +// stdafx.obj �ɂ̓v���R���p�C�����ꂽ�^��񂪊܂܂�܂��B + +#include "stdafx.h" + + +// �o�[�W�������\�[�X����t�@�C���o�[�W�����l���擾 +#pragma comment(lib, "version.lib") +CString GetFileVersion(void) +{ + CString ret; + DWORD size, dw; + TCHAR path[_MAX_PATH + 1]; + LPVOID lp, lpbuf; + UINT usize; + VS_FIXEDFILEINFO* info; + WORD ver[4]; + + ret.Empty(); + if (::GetModuleFileName(NULL, path, _MAX_PATH) != 0) { + if ((size = ::GetFileVersionInfoSize(path, &dw)) > 0) { + if ((lp = ::GlobalAlloc(GMEM_FIXED, size)) != NULL) { + ::GetFileVersionInfo(path, 0, size, lp); + ::VerQueryValue(lp, _T(""), &lpbuf, &usize); + info = (VS_FIXEDFILEINFO*)lpbuf; + ver[3] = HIWORD(info->dwFileVersionMS); + ver[2] = LOWORD(info->dwFileVersionMS); + ver[1] = HIWORD(info->dwFileVersionLS); + ver[0] = LOWORD(info->dwFileVersionLS); + ret.Format(_T("TIAS�B�e�v���O���� Ver %d.%d%d"), ver[3], ver[2], ver[1]); + GlobalFree(lp); + } + } + } + return ret; +} diff --git a/TIAS_Imager2/stdafx.h b/TIAS_Imager2/stdafx.h new file mode 100644 index 0000000..b984b46 --- /dev/null +++ b/TIAS_Imager2/stdafx.h @@ -0,0 +1,42 @@ + +#pragma once + +#ifndef _SECURE_ATL +#define _SECURE_ATL 1 +#endif + +#ifndef VC_EXTRALEAN +#define VC_EXTRALEAN // Windows �w�b�_�[����g�p����Ă��Ȃ����������O���܂��B +#endif + +#include "targetver.h" + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // �ꕔ�� CString �R���X�g���N�^�[�͖����I�ł��B + +// ��ʓI�Ŗ������Ă����S�� MFC �̌x�����b�Z�[�W�̈ꕔ�̔�\�����������܂��B +#define _AFX_ALL_WARNINGS +#include // MFC �̃R�A����ѕW���R���|�[�l���g +#include // MFC �̊g������ +#ifndef _AFX_NO_OLE_SUPPORT +#include // MFC �� Internet Explorer 4 �R���� �R���g���[�� �T�|�[�g +#endif +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include // MFC �� Windows �R���� �R���g���[�� �T�|�[�g +#endif // _AFX_NO_AFXCMN_SUPPORT +#include // MFC �ɂ����郊�{���ƃR���g���[�� �o�[�̃T�|�[�g +#include + +#ifdef _UNICODE +#if defined _M_IX86 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") +#elif defined _M_X64 +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") +#else +#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") +#endif +#endif + +#define SAFE_DELETE(v) { if ((v) != NULL) { delete v; v = NULL; } } +#define SAFE_DELETEA(v) { if ((v) != NULL) { delete [] v; v = NULL; } } + +CString GetFileVersion(void); \ No newline at end of file diff --git a/TIAS_Imager2/targetver.h b/TIAS_Imager2/targetver.h new file mode 100644 index 0000000..10b7ccd --- /dev/null +++ b/TIAS_Imager2/targetver.h @@ -0,0 +1,8 @@ +#pragma once + +// SDKDDKVer.h ���C���N���[�h����ƁA���p�ł���ł���ʂ� Windows �v���b�g�t�H�[������`����܂��B + +// �ȑO�� Windows �v���b�g�t�H�[���p�ɃA�v���P�[�V�������r���h����ꍇ�́AWinSDKVer.h ���C���N���[�h���A +// SDKDDKVer.h ���C���N���[�h����O�ɁA�T�|�[�g�ΏۂƂ���v���b�g�t�H�[���������悤�� _WIN32_WINNT �}�N����ݒ肵�܂��B + +#include diff --git a/TIAS_Imager2/xpstyle.manifest b/TIAS_Imager2/xpstyle.manifest new file mode 100644 index 0000000..467a048 --- /dev/null +++ b/TIAS_Imager2/xpstyle.manifest @@ -0,0 +1,22 @@ + + + +アプリケーションの説明 + + + + + +