void MainWindow::createActions()
{
Connect = new QAction("Connect",this);
Connect->setStatusTip("Connect to the default camera");
connect(Connect,SIGNAL(triggered()),this,SLOT(connectCamera()));
detectFace = new QAction("Detect Faces",this);
detectFace->setToolTip("Detect Faces from Camera");
detectFace->setCheckable(true);
connect(detectFace,SIGNAL(triggered(bool)),camera_thread,SLOT(setDetectFace(bool)));
detectEyes = new QAction("Detect Eyes",this);
detectEyes->setToolTip("Detects eyes from Camera");
detectEyes->setCheckable(true);
detectEyes->setEnabled(false);
connect(detectEyes,SIGNAL(triggered(bool)),camera_thread,SLOT(setDetectEyes(bool)));
connect(detectFace,SIGNAL(triggered(bool)),detectEyes,SLOT(setEnabled(bool)));
detectMouth = new QAction("Detect Lips",this);
detectMouth->setToolTip("Detects lips from Camera");
detectMouth->setCheckable(true);
detectMouth->setEnabled(false);
connect(detectMouth,SIGNAL(triggered(bool)),camera_thread,SLOT(setDetectMouth(bool)));
connect(detectFace,SIGNAL(triggered(bool)),detectMouth,SLOT(setEnabled(bool)));
fSave = new QAction("Save a Face",this);
fSave->setToolTip("Saves the face in the database");
connect(fSave,SIGNAL(triggered()),this,SLOT(callFace()));
recFace = new QAction("Recognise",this);
recFace->setToolTip("Recognises faces from the camera");
recFace->setCheckable(true);
connect(recFace,SIGNAL(triggered(bool)),camera_thread,SLOT(setRecFace(bool)));
}
bool CameraIP::update(){
if(!ipGrabber.isConnected()) {
connectCamera();
}
return CameraWrapper::update();
}; // returns true if frame is new
ControlWidget::ControlWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::ContolWidget)
{
ui->setupUi(this);
bool isConnected = false; Q_UNUSED(isConnected);
//isConnected = connect(ui->buttonConnect, SIGNAL(clicked(bool)), this, SIGNAL(captureImage())); Q_ASSERT(isConnected);
//isConnected = connect(ui->buttonContiniousMode, SIGNAL(clicked()), this, SLOT(toggleContiniousMode())); Q_ASSERT(isConnected);
isConnected = connect(ui->buttonConnect, SIGNAL(clicked()), this, SLOT(connectCamera())); Q_ASSERT(isConnected);
isConnected = connect(ui->buttonConnect, SIGNAL(clicked()), this, SLOT(startMonitoring())); Q_ASSERT(isConnected);
isConnected = connect(&shootTimer, SIGNAL(timeout()), this, SIGNAL(captureImage())); Q_ASSERT(isConnected);
isConnected = connect(ui->triggerwidget, SIGNAL(triggered()), this, SIGNAL(triggered())); Q_ASSERT(isConnected);
// Defaults
int index = ui->comboBoxRefreshRate->findText("0.3", static_cast<Qt::MatchFlags>( Qt::MatchExactly));
ui->comboBoxRefreshRate->setCurrentIndex(index);
}
bool CameraIP::setup(string _name, int width, int height, int framerate, string _url, string _user, string _pass) {
CameraWrapper::setup(_name, width, height, framerate);
//if(!ipGrabber.initGrabber(width, height)) return false;
url = _url;
user = _user;
password = _pass;
connectCamera();
//grabber->setURI("http://148.61.142.228/axis-cgi/mjpg/video.cgi?resolution=320x240");
name = _name;
frameNum = 0;
baseVideo = &ipGrabber;
ipGrabber.update();
return true;
}
asynStatus FastCCD::connect(asynUser *pasynUser){
return connectCamera();
}
/** Constructor for FastCCD driver; most parameters are simply passed to ADDriver::ADDriver.
* After calling the base class constructor this method creates a thread to collect the detector data,
* and sets reasonable default values the parameters defined in this class, asynNDArrayDriver, and ADDriver.
* \param[in] portName The name of the asyn port driver to be created.
* \param[in] maxBuffers The maximum number of NDArray buffers that the NDArrayPool for this driver is
* allowed to allocate. Set this to -1 to allow an unlimited number of buffers.
* \param[in] maxMemory The maximum amount of memory that the NDArrayPool for this driver is
* allowed to allocate. Set this to -1 to allow an unlimited amount of memory.
* \param[in] priority The thread priority for the asyn port driver thread if ASYN_CANBLOCK is set in asynFlags.
* \param[in] stackSize The stack size for the asyn port driver thread if ASYN_CANBLOCK is set in asynFlags.
*/
FastCCD::FastCCD(const char *portName, int maxBuffers, size_t maxMemory,
int priority, int stackSize, int packetBuffer, int imageBuffer,
const char *baseIP, const char *fabricIP, const char *fabricMAC)
: ADDriver(portName, 1, NUM_FastCCD_DET_PARAMS, maxBuffers, maxMemory,
asynUInt32DigitalMask, asynUInt32DigitalMask,
ASYN_CANBLOCK, 1, priority, stackSize)
{
int status = asynSuccess;
int sizeX, sizeY;
static const char *functionName = "FastCCD";
/* Write the packet and frame buffer sizes */
cinPacketBuffer = packetBuffer;
cinImageBuffer = imageBuffer;
/* Store the network information */
strncpy(cinBaseIP, baseIP, 20);
strncpy(cinFabricIP, fabricIP, 20);
strncpy(cinFabricMAC, fabricMAC, 20);
//Define the polling periods for the status thread.
statusPollingPeriod = 20; //seconds
dataStatsPollingPeriod = 0.1; //seconds
// Assume we are in continuous mode
framesRemaining = -1;
/* Create an EPICS exit handler */
epicsAtExit(exitHandler, this);
createParam(FastCCDPollingPeriodString, asynParamFloat64, &FastCCDPollingPeriod);
createParam(FastCCDMux1String, asynParamInt32, &FastCCDMux1);
createParam(FastCCDMux2String, asynParamInt32, &FastCCDMux2);
createParam(FastCCDFirmwarePathString, asynParamOctet, &FastCCDFirmwarePath);
createParam(FastCCDBiasPathString, asynParamOctet, &FastCCDBiasPath);
createParam(FastCCDClockPathString, asynParamOctet, &FastCCDClockPath);
createParam(FastCCDFCRICPathString, asynParamOctet, &FastCCDFCRICPath);
createParam(FastCCDFirmwareUploadString, asynParamInt32, &FastCCDFirmwareUpload);
createParam(FastCCDBiasUploadString, asynParamInt32, &FastCCDBiasUpload);
createParam(FastCCDClockUploadString, asynParamInt32, &FastCCDClockUpload);
createParam(FastCCDFCRICUploadString, asynParamInt32, &FastCCDFCRICUpload);
createParam(FastCCDPowerString, asynParamInt32, &FastCCDPower);
createParam(FastCCDFPPowerString, asynParamInt32, &FastCCDFPPower);
createParam(FastCCDCameraPowerString, asynParamInt32, &FastCCDCameraPower);
createParam(FastCCDBiasString, asynParamInt32, &FastCCDBias);
createParam(FastCCDClocksString, asynParamInt32, &FastCCDClocks);
createParam(FastCCDFPGAStatusString, asynParamUInt32Digital, &FastCCDFPGAStatus);
createParam(FastCCDDCMStatusString, asynParamUInt32Digital, &FastCCDDCMStatus);
createParam(FastCCDOverscanString, asynParamInt32, &FastCCDOverscan);
createParam(FastCCDFclkString, asynParamInt32, &FastCCDFclk);
createParam(FastCCDFCRICGainString, asynParamInt32, &FastCCDFCRICGain);
createParam(FastCCDVBus12V0String, asynParamFloat64, &FastCCDVBus12V0);
createParam(FastCCDVMgmt3v3String, asynParamFloat64, &FastCCDVMgmt3v3);
createParam(FastCCDVMgmt2v5String, asynParamFloat64, &FastCCDVMgmt2v5);
createParam(FastCCDVMgmt1v2String, asynParamFloat64, &FastCCDVMgmt1v2);
createParam(FastCCDVEnet1v0String, asynParamFloat64, &FastCCDVEnet1v0);
createParam(FastCCDVS3E3v3String, asynParamFloat64, &FastCCDVS3E3v3);
createParam(FastCCDVGen3v3String, asynParamFloat64, &FastCCDVGen3v3);
createParam(FastCCDVGen2v5String, asynParamFloat64, &FastCCDVGen2v5);
createParam(FastCCDV60v9String, asynParamFloat64, &FastCCDV60v9);
createParam(FastCCDV61v0String, asynParamFloat64, &FastCCDV61v0);
createParam(FastCCDV62v5String, asynParamFloat64, &FastCCDV62v5);
createParam(FastCCDVFpString, asynParamFloat64, &FastCCDVFp);
createParam(FastCCDIBus12V0String, asynParamFloat64, &FastCCDIBus12V0);
createParam(FastCCDIMgmt3v3String, asynParamFloat64, &FastCCDIMgmt3v3);
createParam(FastCCDIMgmt2v5String, asynParamFloat64, &FastCCDIMgmt2v5);
createParam(FastCCDIMgmt1v2String, asynParamFloat64, &FastCCDIMgmt1v2);
createParam(FastCCDIEnet1v0String, asynParamFloat64, &FastCCDIEnet1v0);
createParam(FastCCDIS3E3v3String, asynParamFloat64, &FastCCDIS3E3v3);
createParam(FastCCDIGen3v3String, asynParamFloat64, &FastCCDIGen3v3);
createParam(FastCCDIGen2v5String, asynParamFloat64, &FastCCDIGen2v5);
createParam(FastCCDI60v9String, asynParamFloat64, &FastCCDI60v9);
createParam(FastCCDI61v0String, asynParamFloat64, &FastCCDI61v0);
createParam(FastCCDI62v5String, asynParamFloat64, &FastCCDI62v5);
createParam(FastCCDIFpString, asynParamFloat64, &FastCCDIFp);
createParam(FastCCDLibCinVersionString, asynParamOctet, &FastCCDLibCinVersion);
createParam(FastCCDBoardIDString, asynParamInt32, &FastCCDBoardID);
createParam(FastCCDSerialNumString, asynParamInt32, &FastCCDSerialNum);
createParam(FastCCDFPGAVersionString, asynParamInt32, &FastCCDFPGAVersion);
createParam(FastCCDStatusHBString, asynParamInt32, &FastCCDStatusHB);
createParam(FastCCDBadPckString, asynParamInt32, &FastCCDBadPck);
createParam(FastCCDDroppedPckString, asynParamInt32, &FastCCDDroppedPck);
createParam(FastCCDLastFrameString, asynParamInt32, &FastCCDLastFrame);
createParam(FastCCDResetStatsString, asynParamInt32, &FastCCDResetStats);
createParam(FastCCDPacketBufferString, asynParamInt32, &FastCCDPacketBuffer);
createParam(FastCCDFrameBufferString, asynParamInt32, &FastCCDFrameBuffer);
createParam(FastCCDImageBufferString, asynParamInt32, &FastCCDImageBuffer);
// Create the epicsEvent for signaling to the status task when parameters should have changed.
// This will cause it to do a poll immediately, rather than wait for the poll time period.
this->statusEvent = epicsEventMustCreate(epicsEventEmpty);
if (!this->statusEvent) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: Failed to create event for status task.\n",
driverName, functionName);
return;
}
this->dataStatsEvent = epicsEventMustCreate(epicsEventEmpty);
if (!this->dataStatsEvent) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: Failed to create event for data stats task.\n",
driverName, functionName);
return;
}
try {
this->lock();
connectCamera();
this->unlock();
setStringParam(ADStatusMessage, "Initialized");
callParamCallbacks();
} catch (const std::string &e) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: %s\n",
driverName, functionName, e.c_str());
return;
}
sizeX = CIN_DATA_MAX_FRAME_X;
sizeY = CIN_DATA_MAX_FRAME_Y;
/* Set some default values for parameters */
status = asynSuccess;
status |= setDoubleParam(FastCCDPollingPeriod, statusPollingPeriod);
status |= setStringParam(ADManufacturer, "Berkeley Laboratory");
status |= setStringParam(ADModel, "1k x 2k FastCCD");
status |= setIntegerParam(ADSizeX, sizeX);
status |= setIntegerParam(ADSizeY, sizeY);
status |= setIntegerParam(ADBinX, 1);
status |= setIntegerParam(ADBinY, 1);
status |= setIntegerParam(ADMinX, 0);
status |= setIntegerParam(ADMinY, 0);
status |= setIntegerParam(ADMaxSizeX, sizeX);
status |= setIntegerParam(ADMaxSizeY, sizeY);
status |= setIntegerParam(ADReverseX, 0);
status |= setIntegerParam(ADReverseY, 0);
status |= setIntegerParam(ADImageMode, ADImageSingle);
status |= setIntegerParam(ADTriggerMode, 1);
status |= setDoubleParam(ADAcquireTime, 0.005);
status |= setDoubleParam(ADAcquirePeriod, 1.0);
status |= setIntegerParam(ADNumImages, 1);
status |= setIntegerParam(ADNumExposures, 1);
status |= setIntegerParam(NDArraySizeX, sizeX);
status |= setIntegerParam(NDArraySizeY, sizeY);
status |= setIntegerParam(NDDataType, NDUInt16);
status |= setIntegerParam(NDArraySize, sizeX*sizeY*sizeof(epicsUInt16));
status |= setDoubleParam(ADShutterOpenDelay, 0.);
status |= setDoubleParam(ADShutterCloseDelay, 0.);
status |= setIntegerParam(FastCCDFirmwareUpload, 0);
status |= setIntegerParam(FastCCDClockUpload, 0);
status |= setIntegerParam(FastCCDBiasUpload, 0);
status |= setIntegerParam(FastCCDPower, 0);
status |= setIntegerParam(FastCCDFPPower, 0);
status |= setIntegerParam(FastCCDCameraPower, 0);
status |= setIntegerParam(FastCCDBias, 0);
status |= setIntegerParam(FastCCDClocks, 0);
status |= setUIntDigitalParam(FastCCDFPGAStatus, 0x0, 0xFFFF);
status |= setUIntDigitalParam(FastCCDDCMStatus, 0x0, 0xFFFF);
status |= setIntegerParam(FastCCDMux1, 0);
status |= setIntegerParam(FastCCDMux2, 0);
status |= setStringParam(FastCCDFirmwarePath, "");
status |= setStringParam(FastCCDBiasPath, "");
status |= setStringParam(FastCCDClockPath, "");
status |= setStringParam(FastCCDFCRICPath, "");
status |= setIntegerParam(FastCCDOverscan, 2);
status |= setIntegerParam(FastCCDFclk, 0);
status |= setIntegerParam(FastCCDFCRICGain, 0);
status |= setDoubleParam(FastCCDVBus12V0, 0);
status |= setDoubleParam(FastCCDVMgmt3v3, 0);
status |= setDoubleParam(FastCCDVMgmt2v5, 0);
status |= setDoubleParam(FastCCDVMgmt1v2, 0);
status |= setDoubleParam(FastCCDVEnet1v0, 0);
status |= setDoubleParam(FastCCDVS3E3v3, 0);
status |= setDoubleParam(FastCCDVGen3v3, 0);
status |= setDoubleParam(FastCCDVGen2v5, 0);
status |= setDoubleParam(FastCCDV60v9, 0);
status |= setDoubleParam(FastCCDV61v0, 0);
status |= setDoubleParam(FastCCDV62v5, 0);
status |= setDoubleParam(FastCCDVFp, 0);
status |= setDoubleParam(FastCCDIBus12V0, 0);
status |= setDoubleParam(FastCCDIMgmt3v3, 0);
status |= setDoubleParam(FastCCDIMgmt2v5, 0);
status |= setDoubleParam(FastCCDIMgmt1v2, 0);
status |= setDoubleParam(FastCCDIEnet1v0, 0);
status |= setDoubleParam(FastCCDIS3E3v3, 0);
status |= setDoubleParam(FastCCDIGen3v3, 0);
status |= setDoubleParam(FastCCDIGen2v5, 0);
status |= setDoubleParam(FastCCDI60v9, 0);
status |= setDoubleParam(FastCCDI61v0, 0);
status |= setDoubleParam(FastCCDI62v5, 0);
status |= setDoubleParam(FastCCDIFp, 0);
status |= setStringParam(FastCCDLibCinVersion, (char *)cin_build_version);
callParamCallbacks();
// Signal the status thread to poll the detector
epicsEventSignal(statusEvent);
epicsEventSignal(dataStatsEvent);
if (stackSize == 0) {
stackSize = epicsThreadGetStackSize(epicsThreadStackMedium);
}
/* Create the thread that updates the detector status */
status = (epicsThreadCreate("FastCCDStatusTask",
epicsThreadPriorityMedium,
stackSize,
(EPICSTHREADFUNC)FastCCDStatusTaskC,
this) == NULL);
if(status) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: Failed to create status task.\n",
driverName, functionName);
return;
}
/* Create the thread that updates the data stats */
status = (epicsThreadCreate("FastCCDDataStatsTask",
epicsThreadPriorityMedium,
stackSize,
(EPICSTHREADFUNC)FastCCDDataStatsTaskC,
this) == NULL);
if(status) {
asynPrint(pasynUserSelf, ASYN_TRACE_ERROR,
"%s:%s: Failed to create data stats task.\n",
driverName, functionName);
return;
}
}
int main(int argc, char **argv)
{
errStatus status = ERR_OK;
char deviceAddress[50];
t_videoResolution newResolution;
status = discoverDevices(deviceAddress);
if(status != ERR_OK)
goto exitLabel;
printf("Received probe matches %s\n", deviceAddress);
status = connectCamera(deviceAddress);
if(status != ERR_OK)
goto exitLabel;
//printf("Media URL set to %s\n", mediaEP);
status = getSupportedResolutions();
if(status != ERR_OK)
goto exitLabel;
newResolution.Encoding = tt__VideoEncoding__H264;
newResolution.width = 1280;
newResolution.height = 720;
status = setResolution(newResolution);
if(status == ERR_RESOLUTION_NOT_SUPPORTED)
printf("Resolution not supported\n");
else
printf("Resolution supported\n");
if(status != ERR_OK)
goto exitLabel;
#if 0
struct _trt__GetVideoSourceConfiguration getVideoSourceConfigurationRequest;
getVideoSourceConfigurationRequest.ConfigurationToken = (char *)malloc(sizeof(videoSrcToken));
strcpy(getVideoSourceConfigurationRequest.ConfigurationToken, videoSrcToken);
struct _trt__GetVideoSourceConfigurationResponse getVideoSourceConfigurationResponse;
soap_call___trt__GetVideoSourceConfiguration(&soap, mediaEP, NULL, &getVideoSourceConfigurationRequest, &getVideoSourceConfigurationResponse);
if(getVideoSourceConfigurationResponse.Configuration == NULL)
{
printf("No video src config for %s\n", videoSrcToken);
status = 1;
goto exit;
}
else
{
printf("Video config available\n");
}
struct _trt__SetVideoSourceConfiguration setVideoSourceConfigurationRequest;
getVideoSourceConfigurationResponse.Configuration->Bounds->width = 1280;//640;
getVideoSourceConfigurationResponse.Configuration->Bounds->height = 720;//360;
getVideoSourceConfigurationResponse.Configuration->Bounds->x = 0;
getVideoSourceConfigurationResponse.Configuration->Bounds->y = 0;
setVideoSourceConfigurationRequest.Configuration = getVideoSourceConfigurationResponse.Configuration;
struct _trt__SetVideoSourceConfigurationResponse setVideoSourceConfigurationResponse;
soap_call___trt__SetVideoSourceConfiguration(&soap, mediaEP, NULL, &setVideoSourceConfigurationRequest, &setVideoSourceConfigurationResponse);
#endif
exitLabel:
cleanup();
return status;
}
Wormsign::Wormsign(QWidget *parent, Qt::WFlags flags)
: QWidget(parent, flags)
{
appVersion = "2.0";
//Populate Camera Options
QMainWindow * mainWin = (QMainWindow *)this->window();
mainWin->setWindowTitle("Wormsign " + appVersion + " - RealTime Larva Tracking - Questions: Gus Lott x4632");
expAgent = NULL;
int height = 1000;
int width = 1000;
setGeometry(50,50,width,height);
setMinimumHeight(height); setMaximumHeight(height);
setMinimumWidth(width); setMaximumWidth(width);
//setAutoFillBackground(true);
//setPalette(QColor(250,250,200));
//File Menu saves/loads config states.
//Create Preview Canvas for Camera
camThread = NULL;
canvas = new CamViewGL;
canvas->gui = this;
canvas->show();
//HARDWARE INTERFACES
//button to show/hide hardware interfaces
showHideHW = new QPushButton("<< Hide Config",this);
showHideHW->setGeometry(530,10,110,20); showHideHW->setCheckable(true);
showHideHW->setPalette(QColor(200,200,200)); showHideHW->setChecked(true);
connect(showHideHW,SIGNAL(clicked()),this,SLOT(hideHW()));
//Create Camera Control Interface
QStringList camStrList = CoreCamThread::listCams();
QGroupBox * camControlBox = new QGroupBox("Camera Control",this);
QFont fnt = camControlBox->font(); fnt.setBold(true); camControlBox->setFont(fnt);
camControlBox->setGeometry(645,10,350,200);
//pop-up list of available cameras
camList = new QComboBox(camControlBox);
camList->addItems(camStrList);
camList->setGeometry(10,20,200,20);
//connect toggle button
camConnect = new QPushButton("Connect",camControlBox);
camConnect->setGeometry(220,20,100,20);
camConnect->setCheckable(true); camConnect->setPalette(QPalette(QColor(200,200,200)));
connect(camConnect,SIGNAL(clicked()),this,SLOT(connectCamera()));
//ROI, Brightness, Gain, Gamma, Shutter - disabled
QLabel * roiLabel = new QLabel("ROI (xywh):",camControlBox);
roiLabel->setFont(fnt);
roiLabel->setGeometry(10,50,70,20);
for(int i=0; i<4; i++){
roiBox[i] = new QSpinBox(camControlBox);
roiBox[i]->setGeometry(10+80+ 65*i ,50,55,20);
roiBox[i]->setEnabled(false);
}
QLabel * tempLabel;
//Brightness
tempLabel = new QLabel("Brightness: ",camControlBox);
brightBox = new QSpinBox(camControlBox); brightBox->setEnabled(false);
brightSlider = new QSlider(Qt::Horizontal,camControlBox); brightSlider->setEnabled(false);
tempLabel->setGeometry(10,90,120,20); brightBox->setGeometry(110,90,70,20); brightSlider->setGeometry(190,90,150,20);
//Link slider/box and connect prop update
connect(brightBox,SIGNAL(valueChanged(int)),brightSlider,SLOT(setValue(int)));
connect(brightSlider,SIGNAL(valueChanged(int)),brightBox,SLOT(setValue(int)));
//Gain
tempLabel = new QLabel("Gain: ",camControlBox);
gainBox = new QSpinBox(camControlBox); gainBox->setEnabled(false);
gainSlider = new QSlider(Qt::Horizontal,camControlBox); gainSlider->setEnabled(false);
tempLabel->setGeometry(10,110,120,20); gainBox->setGeometry(110,110,70,20); gainSlider->setGeometry(190,110,150,20);
//Link slider/box and connect prop update
connect(gainBox,SIGNAL(valueChanged(int)),gainSlider,SLOT(setValue(int)));
connect(gainSlider,SIGNAL(valueChanged(int)),gainBox,SLOT(setValue(int)));
//Gamma
tempLabel = new QLabel("Gamma: ",camControlBox);
gammaBox = new QSpinBox(camControlBox); gammaBox->setEnabled(false);
gammaSlider = new QSlider(Qt::Horizontal,camControlBox); gammaSlider->setEnabled(false);
tempLabel->setGeometry(10,130,120,20); gammaBox->setGeometry(110,130,70,20); gammaSlider->setGeometry(190,130,150,20);
//Link slider/box and connect prop update
connect(gammaBox,SIGNAL(valueChanged(int)),gammaSlider,SLOT(setValue(int)));
connect(gammaSlider,SIGNAL(valueChanged(int)),gammaBox,SLOT(setValue(int)));
//Shutter
shutLabel = new QLabel("Shutter (x ms): ",camControlBox);
shutterBox = new QSpinBox(camControlBox); shutterBox->setEnabled(false);
shutterSlider = new QSlider(Qt::Horizontal,camControlBox); shutterSlider->setEnabled(false);
shutLabel->setGeometry(10,150,120,20); shutterBox->setGeometry(110,150,70,20); shutterSlider->setGeometry(190,150,150,20);
//Link slider/box and connect prop update
connect(shutterBox,SIGNAL(valueChanged(int)),shutterSlider,SLOT(setValue(int)));
connect(shutterSlider,SIGNAL(valueChanged(int)),shutterBox,SLOT(setValue(int)));
frameInt = new QLabel("Measured Frame Interval: ",camControlBox);
frameInt->setGeometry(10,175,200,20);
QPalette palette = frameInt->palette();
palette.setColor(frameInt->foregroundRole(), QColor(200,0,0));
frameInt->setPalette(palette);
//Create Network Connection Control interface, to biorules app
//Connection to Eric Trautman's Biorules Application
biorulesConnection = new BiorulesConnect();
//Panel
QGroupBox * netPanel = new QGroupBox("BioRules Network Connection",this);
netPanel->setFont(fnt);
netPanel->setGeometry(645,230,350,70);
//IP/Port Controls & Connect Button
tempLabel = new QLabel("IP:",netPanel);
tempLabel->setGeometry(10,20,30,20);
ipText = new QLineEdit(biorulesConnection->ip,netPanel);
ipText->setGeometry(40,20,150,20);
tempLabel = new QLabel("Port:",netPanel);
tempLabel->setGeometry(10,40,40,20);
portText = new QLineEdit(QString().sprintf("%d",biorulesConnection->port),netPanel);
portText->setGeometry(40,40,50,20); portText->setEnabled(false);
netConnect = new QPushButton("Connect",netPanel);
netConnect->setGeometry(220,20,100,20); netConnect->setFont(fnt);
netConnect->setCheckable(true); netConnect->setPalette(QColor(200,200,200));
connect(netConnect,SIGNAL(clicked()),this,SLOT(connectBioRules()));
//Create Stage Control Serial Connection Interface
stageThread = new StageThread(this);
stageThread->biorulesConnection = biorulesConnection;
connect(stageThread,SIGNAL(posUpdate()),this,SLOT(update()));
//Panel
QGroupBox * stagePanel = new QGroupBox("Zaber Stage Serial Interface",this);
stagePanel->setFont(fnt);
stagePanel->setGeometry(645,310,350,120);
tempLabel = new QLabel("Port:",stagePanel);
tempLabel->setGeometry(10,20,30,20);
stageComList = new QComboBox(stagePanel);
QStringList comStrList = stageThread->enumeratePorts(); //Scan for available serial ports
stageComList->insertItems(0,comStrList);
for(int i=0; i<comStrList.size(); i++)
if(comStrList[i] == stageThread->comName) stageComList->setCurrentIndex(i);
stageComList->setGeometry(40,20,100,20);
stageConnect = new QPushButton("Connect",stagePanel);
stageConnect->setGeometry(220,20,100,20); stageConnect->setFont(fnt);
stageConnect->setCheckable(true); stageConnect->setPalette(QColor(200,200,200));
connect(stageConnect,SIGNAL(clicked()),this,SLOT(connectStage()));
stageX = new QLabel(stagePanel);
stageX->setGeometry(10,45,150,20);
stageY = new QLabel(stagePanel);
stageY->setGeometry(170,45,150,20);
tempLabel = new QLabel("Velocity (0-4800): ",stagePanel);
tempLabel->setGeometry(10,70,120,20);
stageVel = new QSpinBox(stagePanel);
stageVel->setGeometry(130,70,100,20); stageVel->setEnabled(false); stageVel->setValue(0);
stageVel->setMinimum(0); stageVel->setMaximum(10000);
tempLabel = new QLabel("Acceleration: ",stagePanel);
tempLabel->setGeometry(10,90,120,20);
stageAccel = new QSpinBox(stagePanel);
stageAccel->setGeometry(130,90,100,20); stageAccel->setEnabled(false); stageAccel->setValue(0);
stageAccel->setMinimum(0); stageAccel->setMaximum(10000);
//Create Stimulus Control Serial Connection Interface, frame rate, intensity, manual stim
stimThread = new StimThread(this);
//Panel
QGroupBox * stimPanel = new QGroupBox("PhotoStim + Trigger System",this);
stimPanel->setFont(fnt);
stimPanel->setGeometry(645,440,350,50);
tempLabel = new QLabel("Port:",stimPanel);
tempLabel->setGeometry(10,20,30,20);
stimComList = new QComboBox(stimPanel);
stimComList->insertItems(0,comStrList);
for(int i=0; i<comStrList.size(); i++)
if(comStrList[i] == stimThread->comName) stimComList->setCurrentIndex(i);
stimComList->setGeometry(40,20,100,20);
stimConnect = new QPushButton("Connect",stimPanel);
stimConnect->setGeometry(220,20,100,20); stimConnect->setFont(fnt);
stimConnect->setCheckable(true); stimConnect->setPalette(QColor(200,200,200));
connect(stimConnect,SIGNAL(clicked()),this,SLOT(connectStim()));
//Experiment Controls, start/stop, log, file names
QGroupBox * expPanel = new QGroupBox("Experiment Control",this);
expPanel->setFont(fnt);
expPanel->setGeometry(645,500,350,160);
fnt.setBold(false);
dirSelect = new QPushButton("Browse...",expPanel);
dirSelect->setGeometry(10,20,70,20); dirSelect->setFont(fnt);
connect(dirSelect,SIGNAL(clicked()),this,SLOT(selectDir()));
dirOpen = new QPushButton("Open Dir",expPanel);
dirOpen->setGeometry(10,45,70,20); dirOpen->setFont(fnt);
connect(dirOpen,SIGNAL(clicked()),this,SLOT(openDir()));
expLoc.setFile("C:\\Data\\");
expDirectory = new QLabel(expLoc.path(),expPanel);
expDirectory->setGeometry(85,20,330,20);
expDirectory->setFont(fnt);
dataLog = new QCheckBox("Log Analysis Results and Stimuli",expPanel);
dataLog->setGeometry(85,45,200,20); dataLog->setChecked(true);
vidLog = new QCheckBox("Log Grayscale Video",expPanel);
vidLog->setGeometry(85,65,200,20); vidLog->setChecked(true);
markupLog = new QCheckBox("Log Video with Annotation",expPanel);
markupLog->setGeometry(85,85,200,20); markupLog->setChecked(false);
//list for available rules (including none) - from biorulesConnection
tempLabel = new QLabel("BioRule:",expPanel);
tempLabel->setGeometry(10,110,75,20);
bioRuleList = new QComboBox(expPanel);
bioRuleList->setGeometry(85,110,200,20);
//bioRuleList->insertItem(0,QString("NONE"));
tempLabel = new QLabel("Frame Trigger Interval (ms):",expPanel);
tempLabel->setGeometry(10,135,180,20);
frameIntIn = new QSpinBox(expPanel);
frameIntIn->setGeometry(180,135,50,20); frameIntIn->setValue(33);
frameIntIn->setRange(10,50);
fnt.setBold(true);
//Start/Stop Button and Experiment Ellapsed Time
fnt.setPointSize(17);
startStop = new QPushButton("START",this);
startStop->setGeometry(500,950,120,40); startStop->setCheckable(true); startStop->setEnabled(false);
startStop->setFont(fnt); startStop->setAutoFillBackground(true); startStop->setPalette(QPalette(QColor(200,0,0)));
expTime = new QLabel("0:00:00",this);
expTime->setGeometry(400,950,100,40);
expTime->setFont(fnt);
connect(startStop,SIGNAL(clicked()),this,SLOT(startStopExperiment()));
//DATA PLOTS
//Algorithm Performance Widget
perfGraph = new PerformanceGraph(this);
perfGraph->setGeometry(645,670,350,320);
//Data Visualization - widget drawing plots of results
plots.resize(4);
for(int i=0; i<4; i++){
plots[i] = new DataPlot(this);
plots[i]->setGeometry(10,20+240*i,300,230);
plots[i]->parameterList->setCurrentIndex(i);
}
//Global Arena Trajectory - widget drawing history of animal track - clear history button
arenaTrack = new ArenaTrack(this);
arenaTrack->setGeometry(320,40,310,300);
connect(bioRuleList,SIGNAL(currentIndexChanged(int)),arenaTrack,SLOT(update()));
//Behavior mode visualization (i.e. stopped, forward, back, casting left, etc)
behaviorModeView = new BehaviorModeView(this);
behaviorModeView->setGeometry(320,360,310,300);
//Manual controls
manualControls = new ManualControls(this);
manualControls->setGeometry(320,680,310,250);
//check for default config in pwd and load it
}
