int main(int argc, char *argv[])
{
struct dj_state *dj_data;
umask(0);
if(argc < 4)
print_usage();
// Create our private data struct
dj_data = malloc(sizeof(struct dj_state));
if(dj_data == NULL)
abort();
// Add the root directory to our data struct
dj_data->encfs_root=realpath(argv[2], NULL);
printf("Mirror Directory: %s\n", dj_data->encfs_root);
// Add the keyphrase to our data struct
strncpy(dj_data->encfs_keyphrase, argv[1], 256);
printf("Keyphrase: %s\n", dj_data->encfs_keyphrase);
// Passphrase and Mirror Dir info can be stripped from the
// fuse_main call
argv[1] = argv[3];
argv[2] = argv[4];
argc -= 2;
printf("Mount Point: %s\n", argv[1]);
char *test = "Makefile";
char test01[PATH_MAX];
tmpFileName(test, test01);
return fuse_main(argc, argv, &encfs_oper, dj_data);
}
/**
* Get the list of midi files directly in the given directory
* return a vector of file names
* note: we don't check if they are valid MIDI files, only if the
* MIDI extension is here
*/
static std::vector<std::string> get_midi_files(const std::string& path) {
const std::string MIDI_EXTENSION(".mid");
std::vector<std::string> midiFileNames;
tinydir_dir midiDir;
tinydir_open_sorted(&midiDir, path.c_str());
for (unsigned i = 0; i < midiDir.n_files; i++) {
tinydir_file file;
tinydir_readfile_n(&midiDir, &file, i);
if (file.is_dir) {
continue;
}
std::string tmpFileName(file.name);
std::cout << tmpFileName << std::endl;
if (!ends_with(tmpFileName, MIDI_EXTENSION)) {
continue ;
}
std::cout << tmpFileName << std::endl;
midiFileNames.push_back(tmpFileName);
}
tinydir_close(&midiDir);
return midiFileNames;
}
void CleanLogFile(char *fileName)
{
std::string tmpFileName(fileName);
if (tmpFileName.rfind(".txt") == std::string::npos)
{
tmpFileName += ".txt";
}
std::ofstream logDat(tmpFileName);
logDat.close();
}
static int encfs_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
int res;
(void) fi;
char *key = DJ_DATA->encfs_keyphrase;
char fpath[PATH_MAX]; // Full buffer to pass to static function
dj_fullpath(fpath, path);
bool is_encrypted = IsEncrypted(fpath);
if (key == NULL)
printf("\n\n **** KEY IS NULL **** \n\n");
printf("\n\n***** FILE ENCRYPTED: %d *****\n\n", is_encrypted);
if(is_encrypted)
{
char tpath[PATH_MAX];
tmpFileName(fpath, tpath);
//int td = open(tpath, O_WRONLY);
FILE* realFile = fopen(fpath, "rb");
FILE* tmpFile = fopen(tpath, "wb");
DecryptFile(realFile, tmpFile, key);
//fflush(tmpFile);
//actual_descriptor = dup(fileno(tmpFile));
fclose(realFile);
fclose(tmpFile);
int fd = open(tpath, O_RDONLY);
res = pread(fd, buf, size, offset);
close(fd);
} else {
int rd = open(fpath, O_RDONLY);
if (rd == -1)
return -errno;
res = pread(rd, buf, size, offset);
if (res == -1)
res = -errno;
close(rd);
}
return res;
}
void Log(char *fileName,const char *text)
{
std::string tmpFileName(fileName);
if (tmpFileName.rfind(".txt") == std::string::npos)
{
tmpFileName += ".txt";
}
std::ofstream logDat;
logDat.open(tmpFileName, std::ios::app);
logDat << text << std::endl;
logDat.close();
}
void ImageOpenThread::run()
{
if (FUrl.scheme()=="file")
{
int dot=FUrl.path().lastIndexOf('.');
if (dot>0)
{
QString ext=FUrl.path().mid(dot+1);
if (!ext.isEmpty())
{
QStringList validExtensions;
validExtensions << "png" << "gif" << "jpg" << "jpeg" << "ico" << "bmp" << "tif" << "tiff" << "svg";
if (validExtensions.contains(ext, Qt::CaseInsensitive))
{
QDesktopServices::openUrl(FUrl.path());
return;
}
}
}
QDir temp = QDir::temp();
if (temp.isReadable())
{
QString fileName=FUrl.toLocalFile();
QImageReader reader(fileName);
if (reader.canRead())
{
QString type(reader.format());
QString tmpFileName(fileName);
tmpFileName.append('.').append(type);
QFile tmpFile(temp.filePath(tmpFileName));
if (!tmpFile.exists() || tmpFile.size()!=reader.device()->size()) // Exists already
QFile::copy(fileName, tmpFileName);
QDesktopServices::openUrl(QUrl::fromLocalFile(tmpFile.fileName()));
}
else
LOG_WARNING("Reader can't' read!");
}
}
else
QDesktopServices::openUrl(FUrl);
}
static int encfs_create(const char* path, mode_t mode, struct fuse_file_info* fi) {
(void) fi;
char fpath[PATH_MAX]; // Full buffer to pass to static function
char tpath[PATH_MAX];
char *key = DJ_DATA->encfs_keyphrase;
dj_fullpath(fpath, path);
tmpFileName(fpath, tpath);
int real, temp;
temp = creat(tpath, mode);
real = creat(fpath, mode);
if(real == -1)
return -errno;
if(temp == -1)
return -errno;
FILE *realFile = fdopen(real, "wb");
FILE *tmpFile = fdopen(temp, "wb");
EncryptFile(tmpFile, realFile, key);
fclose(realFile);
fclose(tmpFile);
remove(tpath);
SetEncryptedFlag(fpath, true);
return 0;
}
static int encfs_write(const char *path, const char *buf, size_t size,
off_t offset, struct fuse_file_info *fi)
{
int res;
(void) fi;
char fpath[PATH_MAX]; // Full buffer to pass to static function
dj_fullpath(fpath, path);
char *key = DJ_DATA->encfs_keyphrase;
bool is_encrypted = IsEncrypted(fpath);
if (is_encrypted) {
// The solution i see for now involves creating a new buf and size
// Write to the tmp file, Encrypt it, and then read the new file
// Finally, pwrite to the original file using the new buffer and size
char tpath[PATH_MAX];
char tpath01[PATH_MAX];
// Write unencrypted file
tmpFileName(fpath, tpath);
FILE* dec_file = fopen(tpath, "wb");
fprintf(dec_file, "%s", buf);
fflush(dec_file);
// Write encrypted file
tmpFileName(fpath, tpath01);
FILE* enc_file = fopen(tpath01, "wb");
EncryptFile(dec_file, enc_file, key);
fclose(dec_file);
fclose(enc_file);
// Set new buf and
remove(tpath);
int td = open(tpath01, O_RDONLY);
off_t new_size;
new_size = lseek(td, 0, SEEK_END);
lseek(td, 0, SEEK_SET);
char* new_buf = malloc(new_size + 1);
read(td, new_buf, new_size);
close(td);
remove(tpath01);
int fd = open(fpath, O_WRONLY);
if(fd == -1)
return -errno;
// This is where its broken :'(
// In order for unencryption to work, we need to maintain entire blocks
// By encrypting the file, reading the encrypted file, the rewriting to the actual file, we lose some block data
// and thus render decryption impossible.
res = pwrite(fd, new_buf, new_size, offset);
if(res == -1)
return -errno;
close(fd);
//~ char tpath[PATH_MAX];
//~ tmpFileName(fpath, tpath);
//~ int td = open(tpath, O_WRONLY);
//~ res = pwrite(td, buf, size, offset);
//~ close(td);
//~ FILE* tmp = fopen(tpath, "w");
//~ fprintf(tmp, "%s", buf);
//~ fflush(tmp);
//FILE* real = fopen(fpath, "w");
//~ EncryptFile(tmp, real, key);
//fclose(real);
//fclose(tmp);
} else {
int fd = open(fpath, O_WRONLY);
if (fd == -1)
return -errno;
res = pwrite(fd, buf, size, offset);
if (res == -1)
res = -errno;
close(fd);
}
return res;
}
//OnConnectCamera-Method; represents one of the main parts of ToFConnectionWidget2.
void QmitkToFConnectionWidget::OnConnectCamera()
{
//After connecting a device
if (m_Controls->m_ConnectCameraButton->text()=="Connect")
{
//Getting the device- and the slectedCamera-variables using the ServiceListWidget as we did it in the CameraSelect-Method
mitk::ToFCameraDevice* device = m_Controls->m_DeviceList->GetSelectedService<mitk::ToFCameraDevice>();
if (device)
{
QString tmpFileName("");
QString fileFilter("");
QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
emit ToFCameraSelected(selectedCamera);
//Feeding it with the Info from ServiceListWidget
this->m_ToFImageGrabber->SetCameraDevice(device);
// Calling Alex FixForKinect, if the Kinect is selected
if (selectedCamera.contains("Kinect") )
{
MITK_INFO<< "Kinect is connected here";
//If the particular property is selected, the suitable data-node will be generated
this->m_ToFImageGrabber->SetBoolProperty("RGB", m_Controls->m_KinectParameterWidget->IsAcquisitionModeRGB());//--------------------------------------------------------
this->m_ToFImageGrabber->SetBoolProperty("IR", m_Controls->m_KinectParameterWidget->IsAcquisitionModeIR());
}
//Activation of "PlayerMode". If the selectedCamera String contains "Player", we start the Player Mode
if (selectedCamera.contains("Player"))
{
//IF PMD-Player selected
if (selectedCamera.contains("PMD"))
{
fileFilter.append("PMD Files (*.pmd)"); //And seting the corresponding fileFilter
}
else
{
fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
}
//open a QFileDialog to chose the corresponding file from the disc
tmpFileName = QFileDialog::getOpenFileName(NULL, "Play Image From...", "", fileFilter);
//If no fileName is returned by the Dialog,Button and Widget have to return to default(disconnected) + Opening a MessageBox
if (tmpFileName.isEmpty())
{
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true); //re-enabling the ConnectCameraButton
m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
this->OnSelectCamera(); //Calling the OnSelctCamera-Method -> Hides all Widget and just activates the needed ones
QMessageBox::information( this, "Template functionality", "Please select a valid image before starting some action.");
return;
}
if(selectedCamera.contains("PMDPlayer")) //If PMD-Player is selected, set ToFImageGrabberProperty correspondingly
{
this->m_ToFImageGrabber->SetStringProperty("PMDFileName", tmpFileName.toStdString().c_str() );
}
else //Default action
{
std::string msg = "";
try
{
//get 3 corresponding file names
std::string dir = itksys::SystemTools::GetFilenamePath( tmpFileName.toStdString() );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( tmpFileName.toStdString() );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( tmpFileName.toStdString() );
//"Incorrect format"-warning while using .nrrd or .pic files
if (extension != ".pic" && extension != ".nrrd")
{
msg = msg + "Invalid file format, please select a \".nrrd\"-file";
throw std::logic_error(msg.c_str());
}
//Checking for npos. If available, check for the Amplitude-, Intensity- and RGBImage
int found = baseFilename.rfind("_DistanceImage"); //Defining "found" variable+checking if baseFilname contains "_DistanceImage". If not, found == npos(0)
if (found == std::string::npos) //If found =0
{
found = baseFilename.rfind("_AmplitudeImage"); //If "_AmplitudeImage" is found, the found variable is 1-> the next if statment is false
}
if (found == std::string::npos)
{
found = baseFilename.rfind("_IntensityImage"); //found = true if baseFilename cotains "_IntesityImage"
}
if (found == std::string::npos)
{
found = baseFilename.rfind("_RGBImage");
}
if (found == std::string::npos) //If none of the Nodes is found, display an error
{
msg = msg + "Input file name must end with \"_DistanceImage\", \"_AmplitudeImage\", \"_IntensityImage\" or \"_RGBImage\"!";
throw std::logic_error(msg.c_str());
}
std::string baseFilenamePrefix = baseFilename.substr(0,found);//Set the baseFilenamePrefix as a substring from baseFilname
//Set corresponding FileNames
std::string distanceImageFileName = dir + "/" + baseFilenamePrefix + "_DistanceImage" + extension; //Set the name as: directory+FilenamePrefix+""+extension
std::string amplitudeImageFileName = dir + "/" + baseFilenamePrefix + "_AmplitudeImage" + extension;
std::string intensityImageFileName = dir + "/" + baseFilenamePrefix + "_IntensityImage" + extension;
std::string rgbImageFileName = dir + "/" + baseFilenamePrefix + "_RGBImage" + extension;
if (!itksys::SystemTools::FileExists(distanceImageFileName.c_str(), true))
{
this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", "");
}
else
{
this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", distanceImageFileName.c_str());
}
if (!itksys::SystemTools::FileExists(amplitudeImageFileName.c_str(), true))
{
}
else
{
this->m_ToFImageGrabber->SetStringProperty("AmplitudeImageFileName", amplitudeImageFileName.c_str());
}
if (!itksys::SystemTools::FileExists(intensityImageFileName.c_str(), true))
{
this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", "");
}
else
{
this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", intensityImageFileName.c_str());
}
if (!itksys::SystemTools::FileExists(rgbImageFileName.c_str(), true))
{
this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", "");
}
else
{
this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", rgbImageFileName.c_str());
}
}
catch (std::exception &e)
{
MITK_ERROR << e.what();
QMessageBox::critical( this, "Error", e.what() );
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
m_Controls->m_DeviceList->setEnabled(true);
this->OnSelectCamera();
return;
}
}
}
//End "PlayerMode"
//Reset the ConnectCameraButton to disconnected
m_Controls->m_ConnectCameraButton->setText("Disconnect");
//if a connection could be established
try
{
if (this->m_ToFImageGrabber->ConnectCamera())
{
this->m_Controls->m_PMDParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
this->m_Controls->m_MESAParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
this->m_Controls->m_KinectParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
//Activating the respective widgets
if (selectedCamera.contains("PMD"))
{
this->m_Controls->m_PMDParameterWidget->ActivateAllParameters();
}
else if (selectedCamera.contains("MESA"))
{
this->m_Controls->m_MESAParameterWidget->ActivateAllParameters();
}
else if (selectedCamera.contains("Kinect"))
{
this->m_Controls->m_KinectParameterWidget->ActivateAllParameters();
}
else
{
this->HideAllParameterWidgets();
}
// send connect signal to the caller functionality
emit ToFCameraConnected();
}
else
//##### TODO: Remove this else part once all controllers are throwing exceptions
//if they cannot to any device!
{
//Throw an error if the Connection failed and reset the Widgets <- better catch an exception!
QMessageBox::critical( this, "Error", "Connection failed. Check if you have installed the latest driver for your system." );
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
m_Controls->m_ConnectCameraButton->setText("Connect");
m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
this->OnSelectCamera();
return;
}
}catch(std::exception &e)
{
//catch exceptions of camera which cannot connect give a better reason
QMessageBox::critical( this, "Connection failed.", e.what() );
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
m_Controls->m_ConnectCameraButton->setText("Connect");
m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
this->OnSelectCamera();
return;
}
m_Controls->m_ConnectCameraButton->setEnabled(true);
// ask wether camera parameters (intrinsics, ...) should be loaded
if (QMessageBox::question(this,"Camera parameters","Do you want to specify your own camera intrinsics?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
{
QString fileName = QFileDialog::getOpenFileName(this,"Open camera intrinsics","/","*.xml");
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
cameraIntrinsics->FromXMLFile(fileName.toStdString());
this->m_ToFImageGrabber->SetProperty("CameraIntrinsics",mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
}
////Reset the status of some GUI-Elements
m_Controls->m_DeviceList->setEnabled(false); //Deactivating the Instance of QmitkServiceListWidget
//repaint the widget
this->repaint();
}
else
{
QMessageBox::information(this,"Camera connection","No camera selected, please select a range camera");
m_Controls->m_ConnectCameraButton->setChecked(false);
}
}
else if (m_Controls->m_ConnectCameraButton->text()=="Disconnect")
{
this->m_ToFImageGrabber->StopCamera();
this->m_ToFImageGrabber->DisconnectCamera();
m_Controls->m_ConnectCameraButton->setText("Connect");
m_Controls->m_DeviceList->setEnabled(true); //Reactivating ServiceListWidget
this->OnSelectCamera();
// send disconnect signal to the caller functionality
emit ToFCameraDisconnected();
}
}
void QmitkToFConnectionWidget::OnConnectCamera()
{
bool playerMode = false;
if (m_Controls->m_ConnectCameraButton->text()=="Connect")
{
//reset the status of the GUI buttons
m_Controls->m_ConnectCameraButton->setEnabled(false);
m_Controls->m_SelectCameraCombobox->setEnabled(false);
//repaint the widget
this->repaint();
QString tmpFileName("");
QString fileFilter("");
//select the camera to connect with
QString selectedCamera = m_Controls->m_SelectCameraCombobox->currentText();
if (selectedCamera == "PMD CamCube 2.0/3.0")
{ //PMD CamCube
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDCamCubeImageGrabber();
}
else if (selectedCamera == "PMD CamCubeRaw 2.0/3.0")
{ //PMD CamCube
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDRawDataCamCubeImageGrabber();
}
else if (selectedCamera == "PMD CamBoard")
{ //PMD CamBoard
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDCamBoardImageGrabber();
}
else if (selectedCamera == "PMD CamBoardRaw")
{ //PMD CamBoard
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDRawDataCamBoardImageGrabber();
}
else if (selectedCamera == "PMD O3D")
{//PMD O3
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDO3ImageGrabber();
}
else if (selectedCamera == "MESA Swissranger 4000")
{//MESA SR4000
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetMESASR4000ImageGrabber();
}
else if (selectedCamera == "PMD Player")
{//PMD player
playerMode = true;
fileFilter.append("PMD Files (*.pmd)");
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDPlayerImageGrabber();
}
else if (selectedCamera == "PMD Raw Data Player")
{//PMD MITK player
playerMode = true;
fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDMITKPlayerImageGrabber();
}
else if (selectedCamera == "MITK Player")
{//MITK player
playerMode = true;
fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetMITKPlayerImageGrabber();
}
// if a player was selected ...
if (playerMode)
{ //... open a QFileDialog to chose the corresponding file from the disc
tmpFileName = QFileDialog::getOpenFileName(NULL, "Play Image From...", "", fileFilter);
if (tmpFileName.isEmpty())
{
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
m_Controls->m_SelectCameraCombobox->setEnabled(true);
this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentText());
QMessageBox::information( this, "Template functionality", "Please select a valid image before starting some action.");
return;
}
if(selectedCamera == "PMD Player")
{ //set the PMD file name
this->m_ToFImageGrabber->SetStringProperty("PMDFileName", tmpFileName.toStdString().c_str() );
}
if (selectedCamera == "PMD Raw Data Player" || selectedCamera == "MITK Player")
{
std::string msg = "";
try
{
//get 3 corresponding file names
std::string dir = itksys::SystemTools::GetFilenamePath( tmpFileName.toStdString() );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( tmpFileName.toStdString() );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( tmpFileName.toStdString() );
if (extension != ".pic" && extension != ".nrrd")
{
msg = msg + "Invalid file format, please select a \".nrrd\"-file";
throw std::logic_error(msg.c_str());
}
int found = baseFilename.rfind("_DistanceImage");
if (found == std::string::npos)
{
found = baseFilename.rfind("_AmplitudeImage");
}
if (found == std::string::npos)
{
found = baseFilename.rfind("_IntensityImage");
}
if (found == std::string::npos)
{
msg = msg + "Input file name must end with \"_DistanceImage.pic\", \"_AmplitudeImage.pic\" or \"_IntensityImage.pic\"!";
throw std::logic_error(msg.c_str());
}
std::string baseFilenamePrefix = baseFilename.substr(0,found);
std::string distanceImageFileName = dir + "/" + baseFilenamePrefix + "_DistanceImage" + extension;
std::string amplitudeImageFileName = dir + "/" + baseFilenamePrefix + "_AmplitudeImage" + extension;
std::string intensityImageFileName = dir + "/" + baseFilenamePrefix + "_IntensityImage" + extension;
if (!itksys::SystemTools::FileExists(distanceImageFileName.c_str(), true))
{
msg = msg + "Inputfile not exist! " + distanceImageFileName;
throw std::logic_error(msg.c_str());
}
if (!itksys::SystemTools::FileExists(amplitudeImageFileName.c_str(), true))
{
msg = msg + "Inputfile not exist! " + amplitudeImageFileName;
throw std::logic_error(msg.c_str());
}
if (!itksys::SystemTools::FileExists(intensityImageFileName.c_str(), true))
{
msg = msg + "Inputfile not exist! " + intensityImageFileName;
throw std::logic_error(msg.c_str());
}
//set the file names
this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", distanceImageFileName.c_str());
this->m_ToFImageGrabber->SetStringProperty("AmplitudeImageFileName", amplitudeImageFileName.c_str());
this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", intensityImageFileName.c_str());
}
catch (std::exception &e)
{
MITK_ERROR << e.what();
QMessageBox::critical( this, "Error", e.what() );
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
m_Controls->m_SelectCameraCombobox->setEnabled(true);
this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentText());
return;
}
}
}
//if a connection could be established
if (this->m_ToFImageGrabber->ConnectCamera())
{
this->m_Controls->m_PMDParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
this->m_Controls->m_MESAParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
if ((selectedCamera == "PMD CamCube 2.0/3.0")||(selectedCamera == "PMD CamBoard")||(selectedCamera=="PMD O3D")||
(selectedCamera=="PMD CamBoardRaw")||(selectedCamera=="PMD CamCubeRaw 2.0/3.0"))
{
this->m_Controls->m_PMDParameterWidget->ActivateAllParameters();
}
else if (selectedCamera=="MESA Swissranger 4000")
{
this->m_Controls->m_MESAParameterWidget->ActivateAllParameters();
}
m_Controls->m_ConnectCameraButton->setText("Disconnect");
// send connect signal to the caller functionality
emit ToFCameraConnected();
}
else
{
QMessageBox::critical( this, "Error", "Connection failed. Check if you have installed the latest driver for your system." );
m_Controls->m_ConnectCameraButton->setChecked(false);
m_Controls->m_ConnectCameraButton->setEnabled(true);
m_Controls->m_SelectCameraCombobox->setEnabled(true);
this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentText());
return;
}
m_Controls->m_ConnectCameraButton->setEnabled(true);
}
else if (m_Controls->m_ConnectCameraButton->text()=="Disconnect")
{
this->m_ToFImageGrabber->StopCamera();
this->m_ToFImageGrabber->DisconnectCamera();
m_Controls->m_ConnectCameraButton->setText("Connect");
m_Controls->m_SelectCameraCombobox->setEnabled(true);
this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentText());
this->m_ToFImageGrabber = NULL;
// send disconnect signal to the caller functionality
emit ToFCameraDisconnected();
}
}
void QmitkToFRecorderWidget::OnStartRecorder()
{
m_Controls->m_StartRecordingButton->setChecked(true);
m_Controls->m_RecorderGroupBox->setEnabled(false);
this->repaint();
int numOfFrames = m_Controls->m_NumOfFramesSpinBox->value();
try
{
bool fileOK = true;
bool distanceImageSelected = true;
bool amplitudeImageSelected = false;
bool intensityImageSelected = false;
bool rgbImageSelected = false;
bool rawDataSelected = false;
//Set check boxes in dialog according to device properties
m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasAmplitudeImage",amplitudeImageSelected);
m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasIntensityImage",intensityImageSelected);
m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasRGBImage",rgbImageSelected);
QString tmpFileName("");
QString selectedFilter("");
QString imageFileName("");
mitk::ToFImageWriter::ToFImageType tofImageType;
tmpFileName = QmitkToFRecorderWidget::getSaveFileName(tofImageType,
distanceImageSelected, amplitudeImageSelected, intensityImageSelected, rgbImageSelected, rawDataSelected,
NULL, "Save Image To...", imageFileName, "NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic);;Text (*.csv)", &selectedFilter);
if (tmpFileName.isEmpty())
{
fileOK = false;
}
else
{
imageFileName = tmpFileName;
}
if (fileOK)
{
std::string dir = itksys::SystemTools::GetFilenamePath( imageFileName.toStdString() );
std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( imageFileName.toStdString() );
std::string extension = itksys::SystemTools::GetFilenameLastExtension( imageFileName.toStdString() );
int integrationTime = this->m_ToFImageGrabber->GetIntegrationTime();
int modulationFreq = this->m_ToFImageGrabber->GetModulationFrequency();
QString integrationTimeStr;
integrationTimeStr.setNum(integrationTime);
QString modulationFreqStr;
modulationFreqStr.setNum(modulationFreq);
QString numOfFramesStr("");
if (this->m_RecordMode == mitk::ToFImageRecorder::PerFrames)
{
numOfFramesStr.setNum(numOfFrames);
}
std::string distImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_DistanceImage");
MITK_INFO << "Save distance data to: " << distImageFileName;
std::string amplImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_AmplitudeImage");
MITK_INFO << "Save amplitude data to: " << amplImageFileName;
std::string intenImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_IntensityImage");
MITK_INFO << "Save intensity data to: " << intenImageFileName;
std::string rgbImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(),
integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_RGBImage");
MITK_INFO << "Save intensity data to: " << rgbImageFileName;
if (selectedFilter.compare("Text (*.csv)") == 0)
{
this->m_ToFImageRecorder->SetFileFormat(".csv");
}
else if (selectedFilter.compare("PIC Images - deprecated (*.pic)") == 0)
{
//default
this->m_ToFImageRecorder->SetFileFormat(".pic");
QMessageBox::warning(NULL, "Deprecated File Format!",
"Please note that *.pic file format is deprecated and not longer supported! The suggested file format for images is *.nrrd!");
}
else if (selectedFilter.compare("NRRD Images (*.nrrd)") == 0)
{
this->m_ToFImageRecorder->SetFileFormat(".nrrd");
}
else
{
QMessageBox::warning(NULL, "Unsupported file format!", "Please specify one of the supported file formats *.nrrd, *.csv!");
return;
}
numOfFrames = m_Controls->m_NumOfFramesSpinBox->value();
this->m_ToFImageRecorder->SetDistanceImageFileName(distImageFileName);
this->m_ToFImageRecorder->SetAmplitudeImageFileName(amplImageFileName);
this->m_ToFImageRecorder->SetIntensityImageFileName(intenImageFileName);
this->m_ToFImageRecorder->SetRGBImageFileName(rgbImageFileName);
this->m_ToFImageRecorder->SetToFImageType(tofImageType);
this->m_ToFImageRecorder->SetDistanceImageSelected(distanceImageSelected);
this->m_ToFImageRecorder->SetAmplitudeImageSelected(amplitudeImageSelected);
this->m_ToFImageRecorder->SetIntensityImageSelected(intensityImageSelected);
this->m_ToFImageRecorder->SetRGBImageSelected(rgbImageSelected);
this->m_ToFImageRecorder->SetRecordMode(this->m_RecordMode);
this->m_ToFImageRecorder->SetNumOfFrames(numOfFrames);
emit RecordingStarted();
this->m_ToFImageRecorder->StartRecording();
}
else
{
this->OnRecordingStopped();
}
}
catch(std::exception& e)
{
QMessageBox::critical(NULL, "Error", QString(e.what()));
this->OnRecordingStopped();
}
}
void Unpacker::extractPackage(std::string packageFile, std::string destination, bool originalNames)
{
std::ifstream *package = new std::ifstream(packageFile.c_str(), std::ios_base::in | std::ios::binary);
if (package->is_open())
{
// get the file size
package->seekg(0, std::ios::end);
std::streamoff packageSize = package->tellg();
package->seekg(0, std::ios::beg);
// get the package header id
char *header_id = new char[4];
package->read(header_id, 4);
// check if is a valid package id
if (strcmp(header_id, "XPK") == 0)
{
while (package->tellg() < packageSize)
{
// get the file name lenght
unsigned int fileNameLength = 0;
package->read(reinterpret_cast<char *>(&fileNameLength), sizeof(fileNameLength));
// get the file name
char *fileName = new char[fileNameLength + 1];
package->read(fileName, fileNameLength);
fileName[fileNameLength] = '\0';
// add the original file name
filesOriginal->push_back(std::string(fileName));
// override the original file name?
if (!originalNames)
{
std::string packageFileName = getFileName(packageFile);
std::string tmpFileName(fileName);
tmpFileName = packageFileName + "." + fileName;
fileNameLength = tmpFileName.length();
delete[] fileName;
fileName = new char[fileNameLength + 1];
strcpy(fileName, tmpFileName.c_str());
fileName[fileNameLength] = '\0';
}
// get file length
int fileSize;
package->read(reinterpret_cast<char *>(&fileSize), sizeof(fileSize));
// read the packed file
char *buffer = new char[fileSize];
package->read(buffer , fileSize);
// get the destination file name
char *finalFileName = new char[destination.length() + fileNameLength + 1];
strcpy(finalFileName, destination.c_str());
strcat(finalFileName, fileName);
finalFileName[destination.length() + fileNameLength] = '\0';
// add this to the extracted list
filesInDisc->push_back(std::string(finalFileName));
// write the packed file to disc
std::ofstream *file = new std::ofstream(finalFileName, std::ios::binary);
file->write(buffer, fileSize);
file->close();
// delete buffers
delete[] finalFileName;
delete[] fileName;
delete[] buffer;
delete file;
}
}
package->close();
delete[] header_id;
}
delete package;
}
