int main(int argc, char *argv[])
{
int adcChannel=1, minX=0, minY=0, binX=1, binY=1, sizeX=1024, sizeY=1024;
int triggerMode=0, numExposures=2, numImages=3;
float mAcquireTime=0.1f, mAccumulatePeriod=1.0f, mAcquirePeriod=4.0f;
float acquireTimeAct, accumulatePeriodAct, acquirePeriodAct;
int AAKinetics=3, ATInternal=0;
time_t startTime, endTime;
int acquireStatus;
checkStatus(Initialize("/usr/local/etc/andor"));
printf("SetTriggerMode(%d)\n", triggerMode);
checkStatus(SetTriggerMode(ATInternal));
printf("SetADChannel(%d)\n", adcChannel);
checkStatus(SetADChannel(adcChannel));
//Set fastest HS speed.
printf("SetHSSpeed(0, 0)\n");
checkStatus(SetHSSpeed(0, 0));
printf("SetImage(%d,%d,%d,%d,%d,%d)\n",
binX, binY, minX+1, minX+sizeX, minY+1, minY+sizeY);
checkStatus(SetImage(binX, binY, minX+1, minX+sizeX, minY+1, minY+sizeY));
printf("SetExposureTime(%f)\n", mAcquireTime);
checkStatus(SetExposureTime(mAcquireTime));
printf("SetAcquisitionMode(AAKinetics)\n");
checkStatus(SetAcquisitionMode(AAKinetics));
printf("SetNumberAccumulations(%d)\n", numExposures);
checkStatus(SetNumberAccumulations(numExposures));
printf("SetAccumulationCycleTime(%f)\n", mAccumulatePeriod);
checkStatus(SetAccumulationCycleTime(mAccumulatePeriod));
printf("SetNumberKinetics(%d)\n", numImages);
checkStatus(SetNumberKinetics(numImages));
printf("SetKineticCycleTime(%f)\n", mAcquirePeriod);
checkStatus(SetKineticCycleTime(mAcquirePeriod));
checkStatus(GetAcquisitionTimings(&acquireTimeAct, &accumulatePeriodAct, &acquirePeriodAct));
printf("GetAcquisitionTimings(exposure=%f, accumulate=%f, kinetic=%f)\n",
acquireTimeAct, accumulatePeriodAct, acquirePeriodAct);
time(&startTime);
printf("StartAcquisition()\n");
checkStatus(StartAcquisition());
while (1) {
printf("GetStatus()\n");
checkStatus(GetStatus(&acquireStatus));
if (acquireStatus != DRV_ACQUIRING) break;
printf("WaitForAcquisition()\n");
checkStatus(WaitForAcquisition());
time(&endTime);
printf("Time since start=%f\n", difftime(endTime, startTime));
}
return 0;
}
void
capture_clara()
{
C(WaitForAcquisition());
at_32 first,last;
C(GetNumberNewImages(&first,&last));
int n=last-first;
printf("received %d images\n",1+n);
at_32 pixels=(1+n)*clara_h*clara_w;
at_32 validfirst,validlast;
C(GetImages16(first,last,clara_buf,pixels,
&validfirst,&validlast));
if((validlast!=last) || (validfirst!=first))
printf("couldn't get as many images as expected\n");
int i,len=clara_h*clara_w;
for(i=0;i<n+1;i++){
unsigned long long sum=0;
int j;
for(j=0;j<len;j++)
sum+=clara_buf[i*len+j];
printf("sum %012lld\n",sum);
}
}
void ANDOR885_Camera::playCamera(){
long imageSize = imageWidth*imageHeight;
int errorValue;
long index;
std::vector <WORD> singleImageVector(imageSize);
int i;
bool error;
int numPlayCameraExp = 1; //define a local number of exposures in case the cleanup event gets played before acquisition ends
int totalNumAcquired = 0; //this includes throwaway images
int numAcquiredDecrement = 0;
//#ifndef _DEBUG
ImageMagick::MyImage image;
image.imageData.reserve(imageSize);
//#endif
while(notDestructed){
//initializion for a new acquisition
numAcquired = 0;
totalNumAcquired = 0;
numAcquiredDecrement = 0;
index = 0;
error = false;
//Signal camera to play. the extra lock/unlock is for refresh Attributes to know
// whether it should signal the camera to play or not.
pauseCameraMutex->lock();
waitForEndOfAcquisitionMutex->lock();
isPlaying = false;
waitForEndOfAcquisitionCondition->broadcast();
waitForEndOfAcquisitionMutex->unlock();
pauseCameraCondition->wait();
stopEvent = false;
//Make time string before returning to setup event acquisition
timeStamp = imageWriter.makeTimeString();
isPlaying = true;
pauseCameraMutex->unlock();
// If camera hasn't been destructed in the meanwhile, get the exposures
if(notDestructed){
//Flag used by stopPlayEvent to stop acquisition
// this flag is reset to
// eventStatMutex->lock();
// eventStat = ANDOR_ON;
// eventStatMutex->unlock();
// Generate the temporary imageVector with a size large enough to hold all the exposures
// Declaring it here ensures that the size will be correct even if the number of exposures
// changes from event sequence to event sequence.
numPlayCameraExp = eventMetadata->size();
if (eventMetadata->at(0).description.compare("throwaway")==0){
numAcquiredDecrement = 1;
}
std::vector <WORD> tempImageVector(imageSize * numPlayCameraExp);
//Get the camera temperature at the beginning of the acquisition for metadata purposes
getCameraTemp();
while(totalNumAcquired < numPlayCameraExp)
{
//Check to make sure the acquisiton hasn't been stopped
/* eventStatMutex->lock();
if (eventStat == ANDOR_OFF) {
break;
}
eventStatMutex->unlock();
*/
//Saves data in one long array, tempImageVector
//See if an acquisition has occurred before settling in to wait
error = getCameraData(&totalNumAcquired, numPlayCameraExp, tempImageVector);
std::cout << "Number of exposures: " << numPlayCameraExp << std::endl;
// If there are still exposures to take, wait for them
// OR, if we're taking the sacrificial image in External Exposure trigger mode and we haven't already gotten an image...
if (totalNumAcquired < numPlayCameraExp)
{
std::cout<<"Waiting"<<std::endl;
errorValue = WaitForAcquisition();
std::cout<<"Done waiting"<<std::endl;
if (errorValue != DRV_SUCCESS){
break;
} else {
//Saves data in one long array, tempImageVector
error = getCameraData(&totalNumAcquired, numPlayCameraExp, tempImageVector);
}
}
std::cout << "Total number acquired: " << totalNumAcquired << std::endl;
numAcquired = totalNumAcquired - numAcquiredDecrement;
std::cout << "Number acquired: " << numAcquired << std::endl;
numAcquiredMutex->lock();
numAcquiredCondition->broadcast();
numAcquiredMutex->unlock();
}
/*
eventStatMutex->lock();
eventStat = ANDOR_OFF;
pauseCleanupCondition->signal();
eventStatMutex->unlock();
*/
std::cout << "Number acquired (broken out of while): " <<numAcquired << std::endl;
waitForCleanupEventMutex->lock();
while (!cleanupEvent)
{
waitForCleanupEventCondition->wait();
}
waitForCleanupEventMutex->unlock();
// Save pictures as long as there are pictures to be taken
if(numAcquired != 0 && !error) {
#ifndef _DEBUG
filePath = createFilePath(); //update filepath
imageWriter.imageVector.clear();
int firstRealImage;
if (eventMetadata->at(0).description.compare("throwaway")==0){
firstRealImage = 1;
takeThrowawayImage = false;
}
else
firstRealImage = 0;
for (i = firstRealImage; i < totalNumAcquired; i++) {
cropImageData(image.imageData, tempImageVector, i, eventMetadata->at(i).cropVector);
setMetadata(image, eventMetadata->at(i));
image.filename = filePath + eventMetadata->at(i).filename;
std::cout << image.filename << std::endl;
image.extension = extension;
if (eventMetadata->at(i).cropVector.empty()) {
image.imageHeight = imageHeight;
image.imageWidth = imageWidth;
} else {
image.imageHeight = eventMetadata->at(i).cropVector.at(3) + 1;
image.imageWidth = eventMetadata->at(i).cropVector.at(2) + 1;
}
image.rotationAngle = rotationAngle;
imageWriter.imageVector.push_back(image);
}
imagePreprocessor.processImages(imageWriter.imageVector, bitDepth);
imageWriter.writeImageVector();
#endif
}
}
else {
isPlaying = false;
}
}
return;
}
