wxString ResolveFile( const wxString& aFileName, const ENV_VAR_MAP* aEnvVars,
const PROJECT* aProject )
{
wxFileName full( aFileName );
if( full.IsAbsolute() )
return full.GetFullPath();
if( aProject )
{
wxFileName fn( createFilePath( aProject->GetProjectPath(), aFileName ) );
if( fn.Exists() )
return fn.GetFullPath();
}
if( aEnvVars )
{
for( auto& entry : *aEnvVars )
{
wxFileName fn( createFilePath( entry.second.GetValue(), aFileName ) );
if( fn.Exists() )
return fn.GetFullPath();
}
}
return wxEmptyString;
}
bool ExamplePageProvider::loadPage( const int16 x, const int16 y, PageInitParams * pInitParams, IOverhangTerrainPage * pPage )
{
const static size_t HALF = 1 << ((sizeof(size_t) << 3) - 1);
const Real r = Real(3.1415926535897932 / 180.0);
const size_t
nTverts = pInitParams->countVerticesPerPageSide,
x0 = size_t(int16(nTverts - 1) * x + HALF),
y0 = size_t(int16(nTverts - 1) * y + HALF);
for (size_t j = y0; j < nTverts + y0; ++j)
for (size_t i = x0; i < nTverts + x0; ++i)
pInitParams->heightmap[((nTverts - 1) - (j - y0)) * nTverts + (i - x0)] = Real(cos(double(i)*r*1.5)*100 + sin(double(j)*r*1.5)*100);
*pPage << *pInitParams;
try
{
StreamSerialiser ins = StreamSerialiser(Root::getSingleton().openFileStream(createFilePath(x, y), _sResourceGroupName));
Ogre::LogManager::getSingletonPtr() ->stream(LML_NORMAL) << "Reading from terrain page (" << x << "x" << y << ")";
*pPage << ins;
} catch (Exception & e)
{
Ogre::LogManager::getSingletonPtr() ->stream(LML_CRITICAL) << "Failure opening terrain page (" << x << "x" << y << "): " << e.getFullDescription();
}
pPage->conjoin();
return true;
}
void QuantixCamera::initializeCameraAcquisition()
{
cleanupEvent = false;
stopEvent = false;
if (!pl_exp_start_seq(cameraHandle, imageBuffer)) {
stopEvent = true;
std::cerr << "Could not start Quantix acquisition" << std::endl;
}
checkQuantixStatus();
//Wait for the acquisition to start before checking for data
acquisitionMutex->lock();
isAcquiring = true;
acquisitionCondition->broadcast(); //there should only be one thread waiting for this
acquisitionMutex->unlock();
timeStamp = imageWriter.makeTimeString();
imageWriter.imageVector.clear();
filePath = createFilePath();
//isPlaying = true;
}
bool ExamplePageProvider::savePage( const IOverhangTerrainPage * pPage, const int16 x, const int16 y, const size_t nPageAxis, const unsigned long nTotalPageSize )
{
try
{
StreamSerialiser outs = StreamSerialiser(Root::getSingleton().createFileStream(createFilePath(x, y), _sResourceGroupName, true));
*pPage >> outs;
} catch (Exception & e)
{
Ogre::LogManager::getSingletonPtr() ->stream(LML_CRITICAL) << "Failure writing terrain page (" << x << "x" << y << "): " << e.getFullDescription();
}
return true; // Height maps don't need to be saved, meta-balls embody terrain deformation state
}
QuantixCamera::QuantixCamera(int16 handle): cameraHandle(handle)
{
initialized = false;
notDestructed = false;
extension = ".tif";
rotationAngle = 270; // makes the height the right direction
isAcquiring = false;
imageBuffer = NULL;
pauseCameraMutex = new omni_mutex();
pauseCameraCondition = new omni_condition(pauseCameraMutex);
acquisitionMutex = new omni_mutex();
acquisitionCondition = new omni_condition(acquisitionMutex);
bool cleanupEvent = false;
filePath = createFilePath();
try {
cameraState = new QuantixState(cameraHandle);
//Initialize data collection libraries
if (!pl_exp_init_seq())
throw CameraException("Could not init Quantix for acquisition");
initialized = true; // change to True eventually
}
catch(CameraException &e)
{
std::cerr << "Camera Initialization Error: " << e.what() << std::endl;
initialized = false;
}
if (initialized){
notDestructed = true;
//imageBuffer = (uns16 *) malloc(100);
//omni_thread::create(playCameraWrapper, (void*) this, omni_thread::PRIORITY_HIGH);
}
}
/** Called when asyn clients call pasynOctet->write().
* This function performs actions for some parameters, including NDAttributesFile.
* For all parameters it sets the value in the parameter library and calls any registered callbacks..
* \param[in] pasynUser pasynUser structure that encodes the reason and address.
* \param[in] value Address of the string to write.
* \param[in] nChars Number of characters to write.
* \param[out] nActual Number of characters actually written. */
asynStatus asynNDArrayDriver::writeOctet(asynUser *pasynUser, const char *value,
size_t nChars, size_t *nActual)
{
int addr=0;
int function = pasynUser->reason;
asynStatus status = asynSuccess;
const char *functionName = "writeOctet";
status = getAddress(pasynUser, &addr); if (status != asynSuccess) return(status);
/* Set the parameter in the parameter library. */
status = (asynStatus)setStringParam(addr, function, (char *)value);
if ((function == NDAttributesFile) ||
(function == NDAttributesMacros)) {
this->readNDAttributesFile();
} else if (function == NDFilePath) {
status = this->checkPath();
if (status == asynError) {
// If the directory does not exist then try to create it
int pathDepth;
getIntegerParam(NDFileCreateDir, &pathDepth);
status = createFilePath(value, pathDepth);
status = this->checkPath();
}
}
/* Do callbacks so higher layers see any changes */
status = (asynStatus)callParamCallbacks(addr, addr);
if (status)
epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
"%s:%s: status=%d, function=%d, value=%s",
driverName, functionName, status, function, value);
else
asynPrint(pasynUser, ASYN_TRACEIO_DRIVER,
"%s:%s: function=%d, value=%s\n",
driverName, functionName, function, value);
*nActual = nChars;
return status;
}
bool copyImageContents(const std::string& img, const std::string& dst)
{
namespace fs = boost::filesystem;
boost::system::error_code ec;
// make sure that image exists
if (!fs::exists(fs::path(img))) {
LOGE("Image " << img << " does not exist");
return false;
}
const std::string mountPoint = createFilePath(dirName(img), "/mp/");
// create a mount point for copied image
if (!createEmptyDir(mountPoint)) {
LOGE("Cannot create mount point for copied image.");
return false;
}
// create dst directory
if (!createEmptyDir(dst)) {
LOGE("Cannot create directory for data.");
return false;
}
// find free loop device for image
std::string loopdev;
if (!utils::getFreeLoopDevice(loopdev)) {
LOGE("Failed to get free loop device.");
return false;
}
LOGT("Using " << loopdev << " to mount image");
// mount an image
if (!utils::mountImage(img, loopdev, mountPoint)) {
LOGE("Cannot mount image.");
return false;
}
// copy data
LOGI("Beginning image copy");
if (!utils::copyDirContents(mountPoint, dst)) {
LOGE("Failed to copy image.");
utils::umountImage(mountPoint, loopdev);
LOGD("Removing already copied data");
fs::remove_all(fs::path(dst));
return false;
}
LOGI("Finished image copy");
// umount image
if (!utils::umountImage(mountPoint, loopdev)) {
LOGE("Failed to umount image");
LOGD("Removing copied data");
fs::remove_all(fs::path(dst));
return false;
}
// remove mount point
if (!fs::remove(fs::path(mountPoint), ec)) {
LOGW("Failed to remove mount point: " << ec.message());
}
return true;
}
/**
* Wątek obsługujący pojedynczą wiadomość przesłaną do serwera.
*/
void Server::handleMessage(tcp::socket* socket){
boost::array<char, 8192> messageBuffer;
boost::system::error_code error;
ioService.run();
socket->read_some(boost::asio::buffer(messageBuffer), error);
if (error){
cerr<<error<<endl;
socket->close();
delete socket;
return;
}
Message message;
deserialize(message, messageBuffer.data());
cout<<"Otrzymano wiadomość: "<<endl;
cout<<message.toString()<<endl;
int result;
string response;
string sessionId;
History emptyHistory;
vector<string> mismatchingParameters;
History* history;
if(message.getAction()!=REGISTER
&& message.getAction()!=LOGIN
&& message.getAction()!=UNREGISTER
&& (serverStore.getSessionId(message.getUserId())!=message.getSessionId()
|| serverStore.getSessionId(message.getUserId())==""))
{
response = createResponse(NOT_LOGGED_IN);
socket->write_some(boost::asio::buffer(response), error);
socket->close();
delete socket;
return;
}
switch(message.getAction()){
case REGISTER:
{
// muszą być dwa parametry
if (message.getParameters().size() != 2)
{
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
}
else
{
// tworzymy użyszkodnika
result = serverStore.registerUser(message.getParameters()[0], message.getParameters()[1]);
switch (result)
{
case 0: // użytkownik dodany poprawnie
response = createResponse(OK);
break;
case -1: // login zajęty
response = createResponse(INCORRECT_LOGIN);
break;
}
socket->write_some(boost::asio::buffer(response), error);
}
break;
}
case LOGIN:
{
// muszą być dwa parametry
if (message.getParameters().size() != 2)
{
response = createResponse(WRONG_SYNTAX, "", &emptyHistory);
socket->write_some(boost::asio::buffer(response), error);
}
else
{
// logowanie użyszkodnika
result = serverStore.loginUser(message.getParameters()[0], message.getParameters()[1]);
switch (result)
{
case 0: // użytkownik zalogowany poprawnie
history = serverStore.getHistory(message.getUserId());
if(history==NULL){
history = &emptyHistory;
}
sessionId = generateSessionId();
serverStore.setSessionId(message.getUserId(), sessionId);
response = createResponse(OK, sessionId, history);
serverStore.clearHistory(message.getUserId());
break;
case -1: // niepoprawny login
response = createResponse(INCORRECT_LOGIN, "", &emptyHistory);
break;
case -2: // niepoprawne haslo
response = createResponse(INCORRECT_PASSWORD, "", &emptyHistory);
break;
}
socket->write_some(boost::asio::buffer(response), error);
}
break;
}
case LOGOUT:
{
serverStore.setSessionId(message.getUserId(), "");
response = createResponse(OK);
socket->write_some(boost::asio::buffer(response), error);
break;
}
case UNREGISTER:
{
// muszą być dwa parametry
if (message.getParameters().size() != 2)
{
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
}
else
{
// usuwamy użyszkodnika
result = serverStore.unregisterUser(message.getParameters()[0], message.getParameters()[1]);
switch (result)
{
case 0: // użytkownik usunięty poprawnie
response = createResponse(OK);
break;
case -1: // login błędny
response = createResponse(INCORRECT_LOGIN);
break;
case -2: // hasło błędne
response = createResponse(INCORRECT_PASSWORD);
break;
}
socket->write_some(boost::asio::buffer(response), error);
}
break;
}
case LIST:
{
//jeśli podano parametry - błąd
if(message.getParameters().size()!=0){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
vector<string> filenames = serverStore.list(message.getUserId());
response = createResponse(OK, filenames);
socket->write_some(boost::asio::buffer(response), error);
filenames.clear();
break;
}
case LIST_SHARED:
{
//jeśli podano parametry - błąd
if(message.getParameters().size()!=0){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
vector<string> names = serverStore.listShared(message.getUserId());
response = createResponse(OK, names);
socket->write_some(boost::asio::buffer(response), error);
names.clear();
break;
}
case UPLOAD:
//jeśli nie podano parametrów - błąd
if(message.getParameters().size()==0){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//żądanie poprawne, rozpocznij transfer
dataPortAccessMutex.lock();
response = createResponse(OK);
socket->write_some(boost::asio::buffer(response), error);
for(unsigned int i=0; i<message.getParameters().size(); ++i){
cout<<"Użytkownik "<<message.getUserId()<<" przesyła plik "<<message.getParameters()[i]<<endl;
result = fileTransferManager.receiveFile(message.getSource(), createFilePath(message.getUserId(), message.getParameters()[i]), i!=0);
if(!result){
cerr<<"Nie przesłano pliku"<<endl;
break;
}
serverStore.add(message.getUserId(), message.getParameters()[i]);
if(serverStore.fileExists(message.getUserId(), message.getParameters()[i])){
serverStore.updateHistory(FILE_MODIFIED, message.getUserId(), message.getParameters()[i]);
}
cout<<"Gotowe."<<endl;
}
dataPortAccessMutex.unlock();
break;
case DOWNLOAD:
//jeśli nie podano parametrów - błąd
if(message.getParameters().size()==0){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//jeśli któreś z podanych plików nie istnieją - błąd.
//zwróć nazwy nieistniejących plików.
for(unsigned int i=0; i<message.getParameters().size(); ++i){
if(!serverStore.fileExists(message.getUserId(), message.getParameters()[i])){
mismatchingParameters.push_back(message.getParameters()[i]);
}
}
if(mismatchingParameters.size()>0){
response = createResponse(NO_SUCH_FILE, mismatchingParameters);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//żądanie poprawne, rozpocznij transfer
dataPortAccessMutex.lock();
response = createResponse(OK);
socket->write_some(boost::asio::buffer(response), error);
for(unsigned int i=0; i<message.getParameters().size(); ++i){
cout<<"Użytkownik "<<message.getUserId()<<" pobiera plik "<<message.getParameters()[i]<<endl;
result = fileTransferManager.sendFile(message.getSource(), createFilePath(message.getUserId(), message.getParameters()[i]), true);
if(!result){
cerr<<"Nie przesłano pliku"<<endl;
break;
}
cout<<"Gotowe."<<endl;
}
dataPortAccessMutex.unlock();
break;
case DOWNLOAD_SHARED:
//musi być podany użytkownik oraz min. 1 plik, jeśli nie jest - błąd
if(message.getParameters().size()<2){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//jeśli nie ma takiego użytkownika - błąd
if(!serverStore.userExists(message.getParameters()[0])){
response = createResponse(NO_SUCH_USER);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//jeśli któreś z podanych plików nie istnieją - błąd.
//zwróć nazwy nieistniejących plików.
for(unsigned int i=1; i<message.getParameters().size(); ++i){
if(!serverStore.fileExists(message.getParameters()[0], message.getParameters()[i])){
mismatchingParameters.push_back(message.getParameters()[i]);
}
}
if(mismatchingParameters.size()>0){
response = createResponse(NO_SUCH_FILE, mismatchingParameters);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//jeśli użytkownik nie ma dostępu do któregoś z plików - błąd.
//zwróć nazwy tychże plików.
for(unsigned int i=1; i<message.getParameters().size(); ++i){
if(!serverStore.hasAccess(message.getUserId(), message.getParameters()[0], message.getParameters()[i])){
mismatchingParameters.push_back(message.getParameters()[i]);
}
}
if(mismatchingParameters.size()>0){
response = createResponse(ACCESS_DENIED, mismatchingParameters);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//żądanie poprawne, rozpocznij transfer
dataPortAccessMutex.lock();
response = createResponse(OK);
socket->write_some(boost::asio::buffer(response), error);
for(unsigned int i=1; i<message.getParameters().size(); ++i){
cout<<"Użytkownik "<<message.getUserId()<<" pobiera plik "<<message.getParameters()[i]<<" należący do użytkownika "<<message.getParameters()[0]<<endl;
result = fileTransferManager.sendFile(message.getSource(), createFilePath(message.getParameters()[0], message.getParameters()[i]), true);
if(!result){
cerr<<"Nie przesłano pliku"<<endl;
break;
}
cout<<"Gotowe."<<endl;
}
dataPortAccessMutex.unlock();
break;
case REMOVE:
//jeśli nie podano parametrów - błąd
if(message.getParameters().size()==0){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
//usuń pliki, jeśli istnieją, zapisz nazwy tych, które nie istnieją
int result;
for(unsigned int i=0; i<message.getParameters().size(); ++i){
serverStore.updateHistory(FILE_REMOVED, message.getUserId(), message.getParameters()[i]);
result = serverStore.remove(message.getUserId(), message.getParameters()[i]);
if(result==0){
remove(createFilePath(message.getUserId(), message.getParameters()[i]).c_str());
}else{
mismatchingParameters.push_back(message.getParameters()[i]);
}
}
//wyślij zwrotny komunikat
if(mismatchingParameters.size()>0){
response = createResponse(NO_SUCH_FILE, mismatchingParameters);
}else{
response = createResponse(OK);
}
socket->write_some(boost::asio::buffer(response), error);
break;
case RENAME:
//jeśli liczba parametrów różna od 2 - błąd
if(message.getParameters().size()!=2){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
result = serverStore.rename(message.getUserId(),
message.getParameters()[0], message.getParameters()[1]);
switch(result){
case 0:
serverStore.updateHistory(FILE_RENAMED, message.getUserId(), message.getParameters()[1], message.getParameters()[0]);
rename(createFilePath(message.getUserId(), message.getParameters()[0]).c_str(), createFilePath(message.getUserId(), message.getParameters()[1]).c_str());
response = createResponse(OK);
break;
case -2:
mismatchingParameters.push_back(message.getParameters()[0]);
response = createResponse(NO_SUCH_FILE, mismatchingParameters);
break;
case -3:
mismatchingParameters.push_back(message.getParameters()[1]);
response = createResponse(FILE_EXISTS, mismatchingParameters);
break;
}
socket->write_some(boost::asio::buffer(response), error);
break;
case GIVE_ACCESS:
if(message.getParameters().size()<2){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
for(unsigned int i=1; i<message.getParameters().size(); ++i){
result = serverStore.giveAccess(message.getUserId().c_str(), message.getParameters()[0].c_str(), message.getParameters()[i].c_str());
switch(result){
case 0:
serverStore.updateHistory(ACCESS_GRANTED, message.getUserId(), message.getParameters()[i], message.getParameters()[0]);
response = createResponse(OK);
break;
case -1:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(NO_SUCH_USER, mismatchingParameters);
break;
case -2:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(NO_SUCH_FILE, mismatchingParameters);
break;
case -3:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(NO_SUCH_USER, mismatchingParameters);
break;
case -4:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(ALREADY_HAVE_ACCESS, mismatchingParameters);
break;
case -5:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(OWN_FILE, mismatchingParameters);
break;
}
if(result!=0){
break;
}
}
socket->write_some(boost::asio::buffer(response), error);
break;
case REVOKE_ACCESS:
if(message.getParameters().size()<2){
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
break;
}
for(unsigned int i=1; i<message.getParameters().size(); ++i){
result = serverStore.revokeAccess(message.getUserId().c_str(), message.getParameters()[0].c_str(), message.getParameters()[i].c_str());
switch(result){
case 0:
serverStore.updateHistory(ACCESS_REVOKED, message.getUserId(), message.getParameters()[i], message.getParameters()[0]);
response = createResponse(OK);
break;
case -1:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(NO_SUCH_USER, mismatchingParameters);
break;
case -2:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(NO_SUCH_FILE, mismatchingParameters);
break;
case -3:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(NO_SUCH_USER, mismatchingParameters);
break;
case -4:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(ALREADY_NO_ACCESS, mismatchingParameters);
break;
case -5:
mismatchingParameters.push_back(message.getParameters()[i]);
response = createResponse(OWN_FILE, mismatchingParameters);
break;
}
if(result!=0){
break;
}
}
socket->write_some(boost::asio::buffer(response), error);
break;
default:
response = createResponse(WRONG_SYNTAX);
socket->write_some(boost::asio::buffer(response), error);
}
socket->close();
delete socket;
}
ANDOR885_Camera::ANDOR885_Camera()
{
debugging = false;
initialized = false;
notDestructed = false;
extension = ".tif";
eventMetadata = NULL;
pauseCameraMutex = new omni_mutex();
pauseCameraCondition = new omni_condition(pauseCameraMutex);
stopEventMutex = new omni_mutex();
stopEventCondition = new omni_condition(stopEventMutex);
stopEvent = false;
numAcquiredMutex = new omni_mutex();
numAcquiredCondition = new omni_condition(numAcquiredMutex);
waitForEndOfAcquisitionMutex = new omni_mutex();
waitForEndOfAcquisitionCondition = new omni_condition(waitForEndOfAcquisitionMutex);
waitForCleanupEventMutex = new omni_mutex();
waitForCleanupEventCondition = new omni_condition(waitForCleanupEventMutex);
bool cleanupEvent = false;
//Initialize necessary parameters
readMode_t.name = "Read mode"; //If ever there is more than one read mode, be sure to properly initialize this for playing events!
readMode_t.choices[READMODE_IMAGE] = "Image";
shutterMode_t.name = "Shutter mode";
shutterMode_t.choices[SHUTTERMODE_AUTO] = "Auto";
shutterMode_t.choices[SHUTTERMODE_OPEN] = "Open";
shutterMode_t.choices[SHUTTERMODE_CLOSE] = "Closed";
acquisitionMode_t.name = "**Acquisition mode (RTA)";
acquisitionMode_t.choices[ACQMODE_SINGLE_SCAN] = "Single scan";
acquisitionMode_t.choices[ACQMODE_KINETIC_SERIES] = "Kinetic series";
acquisitionMode_t.choices[ACQMODE_RUN_TILL_ABORT] = "Run 'til abort";
triggerMode_t.name = "**Trigger mode (EE)";
triggerMode_t.choices[TRIGGERMODE_EXTERNAL] = "External";
triggerMode_t.choices[TRIGGERMODE_EXTERNAL_EXPOSURE] = "External exposure";
triggerMode_t.choices[TRIGGERMODE_INTERNAL] = "Internal";
preAmpGain_t.name = "*Preamp Gain";
// preAmpGain_t.choices.push_back("");
// preAmpGain_t.choiceFlags.push_back(PREAMP_BLANK);
preAmpGain = NOT_AVAILABLE;
// preAmpGainPos = PREAMP_BLANK;
verticalShiftSpeed_t.name = "*Vertical Shift Speed (us/px)";
verticalClockVoltage_t.name = "*Vertical Clock Voltage";
horizontalShiftSpeed_t.name = "*Horizontal Shift Speed (us)";
// pImageArray = NULL;
cameraStat = ANDOR_ON;
acquisitionMode = ACQMODE_RUN_TILL_ABORT;
readMode = READMODE_IMAGE;
exposureTime = (float) 0.05; // in seconds
accumulateTime = 0;
kineticTime = 0;
ttl = TTL_OPEN_HIGH;
shutterMode = SHUTTERMODE_OPEN;
closeTime = SHUTTER_CLOSE_TIME;
openTime = SHUTTER_OPEN_TIME;
// triggerMode = TRIGGERMODE_EXTERNAL_EXPOSURE; //will be set by InitializeCamera
frameTransfer = ANDOR_OFF;
// spoolMode = ANDOR_OFF;
coolerSetpt = -90;
coolerStat = ANDOR_ON;
cameraTemp = 20;
EMCCDGain = NOT_AVAILABLE;
verticalShiftSpeed = 0;
verticalClockVoltage = 0;
horizontalShiftSpeed = 0;
readMode_t.initial = readMode_t.choices.find(readMode)->second;
shutterMode_t.initial = shutterMode_t.choices.find(shutterMode)->second;
// triggerMode_t.initial = triggerMode_t.choices.find(triggerMode)->second;
acquisitionMode_t.initial = acquisitionMode_t.choices.find(acquisitionMode)->second;
//Name of path to which files should be saved
filePath = createFilePath();
logPath = "C:\\Documents and Settings\\EP Lab\\Desktop\\";
palPath = "C:\\Documents and Settings\\User\\My Documents\\My Pictures\\Andor_iXon\\GREY.PAL";
initialized = !InitializeCamera();
if (initialized){
notDestructed = true;
omni_thread::create(playCameraWrapper, (void*) this, omni_thread::PRIORITY_HIGH);
try {
setExposureTime(exposureTime);
setTriggerMode(triggerMode);
} catch (ANDOR885_Exception& e){
std::cerr << e.printMessage() << std::endl;
initialized = false;
}
if (debugging) {
try {
setAcquisitionMode(acquisitionMode);
setReadMode(readMode);
} catch (ANDOR885_Exception& e){
std::cerr << e.printMessage() << std::endl;
initialized = false;
}
}
}
}
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;
}
