void UI_AnnotationEditwindow::deleteButtonClicked()
{
edfplus_annotation_delete(&mainwindow->annotationlist[file_num], annot_num);
annotation = edfplus_annotation_item(&mainwindow->annotationlist[file_num], annot_num);
if(annotation!=NULL)
{
annotation->selected = 1;
annotation->jump = 1;
}
modifybutton->setEnabled(false);
deletebutton->setEnabled(false);
mainwindow->annotations_edited = 1;
mainwindow->save_act->setEnabled(true);
mainwindow->annotations_dock[file_num]->updateList();
mainwindow->maincurve->update();
}
void UI_AnnotationEditwindow::set_selected_annotation(int file_nr, int annot_nr)
{
long long l_tmp;
QTime ta;
file_num = file_nr;
annot_num = annot_nr;
annotation = edfplus_annotation_item(&mainwindow->annotationlist[file_num], annot_num);
annot_descript_lineEdit->setText(QString::fromUtf8(annotation->annotation));
l_tmp = annotation->onset - mainwindow->edfheaderlist[annotation->file_num]->starttime_offset;
if(l_tmp < 0LL)
{
onset_daySpinbox->setValue((-(l_tmp)) / TIME_DIMENSION / 86400);
ta.setHMS(((-(l_tmp)) / TIME_DIMENSION / 3600) % 24,
(((-(l_tmp)) / TIME_DIMENSION) % 3600) / 60,
((-(l_tmp)) / TIME_DIMENSION) % 60,
((-(l_tmp)) % TIME_DIMENSION) / 10000);
posNegTimebox->setCurrentIndex(1);
}
else
{
onset_daySpinbox->setValue(l_tmp / TIME_DIMENSION / 86400);
ta.setHMS((l_tmp / TIME_DIMENSION / 3600) % 24,
((l_tmp / TIME_DIMENSION) % 3600) / 60,
(l_tmp / TIME_DIMENSION) % 60,
(l_tmp % TIME_DIMENSION) / 10000);
posNegTimebox->setCurrentIndex(0);
}
onset_timeEdit->setTime(ta);
if(strlen(annotation->duration))
{
duration_spinbox->setValue(atof(annotation->duration));
}
else
{
duration_spinbox->setValue(-1);
}
modifybutton->setEnabled(true);
deletebutton->setEnabled(true);
}
void UI_AnnotationEditwindow::modifyButtonClicked()
{
annotation = edfplus_annotation_item(&mainwindow->annotationlist[file_num], annot_num);
annotation->onset = onset_daySpinbox->value() * 86400 * TIME_DIMENSION;
annotation->onset += onset_timeEdit->time().hour() * 3600 * TIME_DIMENSION;
annotation->onset += onset_timeEdit->time().minute() * 60 * TIME_DIMENSION;
annotation->onset += onset_timeEdit->time().second() * TIME_DIMENSION;
annotation->onset += onset_timeEdit->time().msec() * (TIME_DIMENSION / 1000);
if(posNegTimebox->currentIndex() == 1)
{
annotation->onset = -(annotation->onset);
}
annotation->onset += mainwindow->edfheaderlist[file_num]->starttime_offset;
if(duration_spinbox->value()>0.0)
{
snprintf(annotation->duration, 16, "%f", duration_spinbox->value());
}
else
{
annotation->duration[0] = 0;
}
strncpy(annotation->annotation, annot_descript_lineEdit->text().toUtf8().data(), MAX_ANNOTATION_LEN);
annotation->annotation[MAX_ANNOTATION_LEN] = 0;
annotation->modified = 1;
annotation->selected = 1;
mainwindow->annotations_edited = 1;
mainwindow->annotations_dock[file_num]->updateList();
mainwindow->maincurve->update();
}
void UI_BIOSEMI2BDFPLUSwindow::SelectFileButton()
{
int i, j, k,
error,
hdl_in,
hdl_out,
edfsignals,
status_signal=0,
status_samples_in_datarecord=0,
rising_edge,
set_duration,
status[24],
totalSamplesInDatarecord,
*buf,
buf_offset[EDFLIB_MAXSIGNALS],
sf,
new_sf,
samplerate_divider;
char str[2048],
triggerlabel[24][64],
outputfilename[MAX_PATH_LENGTH];
long long datarecords,
status_sample_duration,
trigger_cnt,
progress_steps;
struct edf_hdr_struct hdr;
struct annotationblock *annotlist=NULL;
struct annotationblock *annotation;
for(i=0; i<16; i++)
{
if(!lineEdit1[i]->text().length())
{
sprintf(str, "Trigger Input label %i is empty!", i + 1);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
return;
}
}
for(i=0; i<16; i++)
{
for(j=0; j<16; j++)
{
if(i != j)
{
if(!strcmp(lineEdit1[i]->text().toLocal8Bit().data(), lineEdit1[j]->text().toLocal8Bit().data()))
{
sprintf(str, "Trigger Input labels %i and %i are the same!", i + 1, j + 1);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
return;
}
}
}
}
str[0] = 0;
strcpy(inputpath, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
if(!strcmp(inputpath, ""))
{
return;
}
get_directory_from_path(recent_opendir, inputpath, MAX_PATH_LENGTH);
error = edfopen_file_readonly(inputpath, &hdr, EDFLIB_DO_NOT_READ_ANNOTATIONS);
if(error < 0)
{
error = hdr.filetype;
switch(error)
{
case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error.");
break;
case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory.");
break;
case EDFLIB_FILE_CONTAINS_FORMAT_ERRORS : strcpy(str, "EDFlib: file contains format errors.\nOpen the file in EDFbrowser to get more info.");
break;
case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum amount of files reached.");
break;
case EDFLIB_FILE_READ_ERROR : strcpy(str, "EDFlib: a file read error occurred.");
break;
case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file is already opened.");
break;
case EDFLIB_FILETYPE_ERROR : strcpy(str, "EDFlib: filetype error.");
break;
case EDFLIB_FILE_WRITE_ERROR : strcpy(str, "EDFlib: file write error.");
break;
case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: invalid number of signals.");
break;
case EDFLIB_FILE_IS_DISCONTINUOUS : strcpy(str, "EDFlib: file is discontinuous.");
break;
case EDFLIB_INVALID_READ_ANNOTS_VALUE : strcpy(str, "EDFlib: invalid read annotations argument.");
break;
default : strcpy(str, "EDFlib: unknown error.");
}
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
return;
}
hdl_in = hdr.handle;
/////////////////// check file /////////////////////////////////////////////
if(hdr.filetype == EDFLIB_FILETYPE_BDFPLUS)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is already a BDF-plus file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
if(hdr.filetype != EDFLIB_FILETYPE_BDF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is not a BDF file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
if(hdr.datarecord_duration != EDFLIB_TIME_DIMENSION)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Datarecord duration of inputfile must be 1 second.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
edfsignals = hdr.edfsignals;
if(edfsignals < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There are no signals in the selected file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
sf = hdr.signalparam[0].smp_in_datarecord;
for(i=1; i<edfsignals; i++)
{
if(hdr.signalparam[i].smp_in_datarecord != sf)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "All signals must have the same samplefrequency.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
}
error = 1;
switch(sf)
{
case 16384 : error = 0;
break;
case 8192 : error = 0;
break;
case 4096 : error = 0;
break;
case 2048 : error = 0;
break;
case 1024 : error = 0;
break;
case 512 : error = 0;
break;
case 256 : error = 0;
break;
case 128 : error = 0;
break;
case 64 : error = 0;
break;
case 32 : error = 0;
break;
}
if(error)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency must be 16384, 8192, 4096, 2048, 1024, 512, 256, 128, 64 or 32 Hz.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
for(i=0; i<edfsignals; i++)
{
if(!(strcmp(hdr.signalparam[i].label, "Status ")))
{
status_signal = i;
break;
}
}
if(i == edfsignals)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There is no Status signal in the selected file.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
totalSamplesInDatarecord = 0;
for(i=0; i<edfsignals; i++)
{
buf_offset[i] = totalSamplesInDatarecord;
if(i == status_signal)
{
status_samples_in_datarecord = hdr.signalparam[i].smp_in_datarecord;
}
totalSamplesInDatarecord += hdr.signalparam[i].smp_in_datarecord;
}
status_sample_duration = EDFLIB_TIME_DIMENSION / (long long)status_samples_in_datarecord;
for(i=0; i<16; i++)
{
strcpy(&triggerlabel[i][0], lineEdit1[i]->text().toUtf8().data());
triggerlabel[i][16] = 0;
}
strcpy(&triggerlabel[16][0], "new epoch");
if(radioButton1->isChecked() == true)
{
rising_edge = 1;
for(i=0; i<16; i++)
{
status[i] = 1;
}
}
else
{
rising_edge = 0;
for(i=0; i<16; i++)
{
status[i] = 0;
}
}
if(checkBox1->isChecked() == true)
{
set_duration = 1;
}
else
{
set_duration = 0;
}
for(i=16; i<24; i++)
{
status[i] = 1;
}
strcpy(outputfilename, inputpath);
remove_extension_from_filename(outputfilename);
strcat(outputfilename, "_+.bdf");
outputpath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(outputpath, recent_savedir);
strcat(outputpath, "/");
}
strcat(outputpath, outputfilename);
strcpy(outputpath, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(outputpath), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
if(!strcmp(outputpath, ""))
{
edfclose_file(hdl_in);
return;
}
get_directory_from_path(recent_savedir, outputpath, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(outputpath))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Outputfile is already opened in EDFbrowser.\nClose the file and try again.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
if(!(strcmp(inputpath, outputpath)))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Inputfile and outputfile are the same.");
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
hdl_out = edfopen_file_writeonly(outputpath, EDFLIB_FILETYPE_BDFPLUS, edfsignals);
if(hdl_out < 0)
{
switch(hdl_out)
{
case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error.");
break;
case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory.");
break;
case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum amount of files reached.");
break;
case EDFLIB_FILE_READ_ERROR : strcpy(str, "EDFlib: a file read error occurred.");
break;
case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file is already opened.");
break;
case EDFLIB_FILETYPE_ERROR : strcpy(str, "EDFlib: filetype error.");
break;
case EDFLIB_FILE_WRITE_ERROR : strcpy(str, "EDFlib: file write error.");
break;
case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: invalid number of signals.");
break;
default : strcpy(str, "EDFlib: unknown error.");
}
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
edfclose_file(hdl_in);
return;
}
/////////////////// copy header /////////////////////////////////////////////
for(i=0; i<edfsignals; i++)
{
edf_set_samplefrequency(hdl_out, i, hdr.signalparam[i].smp_in_datarecord);
edf_set_physical_maximum(hdl_out, i, hdr.signalparam[i].phys_max);
edf_set_physical_minimum(hdl_out, i, hdr.signalparam[i].phys_min);
edf_set_digital_maximum(hdl_out, i, hdr.signalparam[i].dig_max);
edf_set_digital_minimum(hdl_out, i, hdr.signalparam[i].dig_min);
edf_set_label(hdl_out, i, hdr.signalparam[i].label);
edf_set_prefilter(hdl_out, i, hdr.signalparam[i].prefilter);
edf_set_transducer(hdl_out, i, hdr.signalparam[i].transducer);
edf_set_physical_dimension(hdl_out, i, hdr.signalparam[i].physdimension);
}
edf_set_startdatetime(hdl_out, hdr.startdate_year, hdr.startdate_month, hdr.startdate_day, hdr.starttime_hour, hdr.starttime_minute, hdr.starttime_second);
edf_set_patientname(hdl_out, hdr.patient);
edf_set_recording_additional(hdl_out, hdr.recording);
/////////////////// collect triggers /////////////////////////////////////////////
buf = (int *)malloc(sizeof(int) * status_samples_in_datarecord);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
return;
}
QProgressDialog progress("Collecting triggers...", "Abort", 0, (int)hdr.datarecords_in_file);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = hdr.datarecords_in_file / 100LL;
if(progress_steps < 1LL)
{
progress_steps = 1LL;
}
trigger_cnt = 0;
for(datarecords = 0LL; datarecords < hdr.datarecords_in_file; datarecords++)
{
if(trigger_cnt >= ((hdr.datarecords_in_file * 32) - 2))
{
break;
}
if(trigger_cnt >= 100000)
{
break;
}
if(!(datarecords % progress_steps))
{
progress.setValue((int)datarecords);
qApp->processEvents();
if(progress.wasCanceled())
{
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
}
if(edfread_digital_samples(hdl_in, status_signal, status_samples_in_datarecord, buf) < 0)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during the collection of triggers.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
for(i=0; i<status_samples_in_datarecord; i++)
{
for(j=0; j<17; j++)
{
if(((buf[i] & (1 << j)) && !status[j]) || (!(buf[i] & (1 << j)) && status[j])) // rising or falling edge detected
{
if(status[j]) // falling edge detected
{
if((!rising_edge) && (j < 16))
{
annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock));
if(annotation == NULL)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (annotation).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
annotation->onset = (datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration);
annotation->onset += hdr.starttime_subsecond;
strcpy(annotation->annotation, triggerlabel[j]);
edfplus_annotation_add_item(&annotlist, annotation);
trigger_cnt++;
}
else
{
if(set_duration)
{
k = edfplus_annotation_count(&annotlist);
for(; k>0; k--)
{
annotation = edfplus_annotation_item(&annotlist, k - 1);
if(annotation == NULL)
{
break;
}
if(!strcmp(annotation->annotation, triggerlabel[j]))
{
sprintf(str, "%.4f", (double)((datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration) - annotation->onset) / (double)EDFLIB_TIME_DIMENSION);
str[15] = 0;
strcpy(annotation->duration, str);
break;
}
}
}
}
status[j] = 0;
}
else // rising edge detected
{
if(rising_edge || (j == 16))
{
annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock));
if(annotation == NULL)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (annotation).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
edfplus_annotation_delete_list(&annotlist);
return;
}
annotation->onset = (datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration);
annotation->onset += hdr.starttime_subsecond;
strcpy(annotation->annotation, triggerlabel[j]);
edfplus_annotation_add_item(&annotlist, annotation);
trigger_cnt++;
}
else
{
if(set_duration)
{
k = edfplus_annotation_count(&annotlist);
for(; k>0; k--)
{
annotation = edfplus_annotation_item(&annotlist, k - 1);
if(annotation == NULL)
{
break;
}
if(!strcmp(annotation->annotation, triggerlabel[j]))
{
sprintf(str, "%.4f", (double)((datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration) - annotation->onset) / (double)EDFLIB_TIME_DIMENSION);
str[15] = 0;
strcpy(annotation->duration, str);
break;
}
}
}
}
status[j] = 1;
}
}
}
}
}
edfwrite_annotation_latin1(hdl_out, 0LL, -1LL, "Recording starts");
j = edfplus_annotation_count(&annotlist);
for(i=0; i<j; i++)
{
annotation = edfplus_annotation_item(&annotlist, i);
if(annotation->duration[0] == 0)
{
edfwrite_annotation_utf8(hdl_out, annotation->onset / 1000LL, -1LL, annotation->annotation);
}
else
{
edfwrite_annotation_utf8(hdl_out, annotation->onset / 1000LL, (long long)(atof(annotation->duration) * 10000.0), annotation->annotation);
}
}
free(buf);
edfwrite_annotation_latin1(hdl_out, hdr.datarecords_in_file * 10000LL, -1LL, "Recording ends");
/////////////////// choose datarecord duration /////////////////////////////////////////////
samplerate_divider = 1;
i = edfplus_annotation_count(&annotlist);
edfplus_annotation_delete_list(&annotlist);
annotlist = NULL;
if(i % 2)
{
i++;
}
i += 2;
while(i > hdr.datarecords_in_file)
{
samplerate_divider *= 2;
i /= 2;
if(samplerate_divider == 32)
{
break;
}
}
if(samplerate_divider > 1)
{
for(i=0; i<edfsignals; i++)
{
edf_set_samplefrequency(hdl_out, i, hdr.signalparam[i].smp_in_datarecord / samplerate_divider);
}
if(edf_set_datarecord_duration(hdl_out, 100000 / samplerate_divider) == -1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_datarecord_duration() returned an error.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
return;
}
}
new_sf = sf / samplerate_divider;
/////////////////// start conversion /////////////////////////////////////////////
buf = (int *)malloc(sizeof(int) * totalSamplesInDatarecord);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf).");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
return;
}
edfrewind(hdl_in, status_signal);
progress.setLabelText("Converting...");
progress.setValue(0);
for(datarecords = 0LL; datarecords < hdr.datarecords_in_file; datarecords++)
{
if(!(datarecords % progress_steps))
{
progress.setValue((int)datarecords);
qApp->processEvents();
if(progress.wasCanceled())
{
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
return;
}
}
for(i=0; i<edfsignals; i++)
{
if(edfread_digital_samples(hdl_in, i, hdr.signalparam[i].smp_in_datarecord, buf + buf_offset[i]) < 0)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during the conversion.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
return;
}
}
for(j=0; j<samplerate_divider; j++)
{
for(i=0; i<edfsignals; i++)
{
if(edfwrite_digital_samples(hdl_out, buf + buf_offset[i] + (j * new_sf)) < 0)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A write error occurred during the conversion.");
messagewindow.exec();
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
return;
}
}
}
}
QApplication::setOverrideCursor(Qt::WaitCursor);
edfclose_file(hdl_in);
edfclose_file(hdl_out);
free(buf);
QApplication::restoreOverrideCursor();
progress.reset();
#ifdef Q_WS_WIN
snprintf(str, 2048, "Done. Converted %I64d input trigger events to BDF+ annotations.\n"
"\nBDF+ file is located at %s", trigger_cnt, outputpath);
#else
snprintf(str, 2048, "Done. Converted %lli input trigger events to BDF+ annotations.\n"
"\nBDF+ file is located at %s", trigger_cnt, outputpath);
#endif
QMessageBox messagewindow(QMessageBox::Information, "Ready", str);
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
}
void UI_ExportAnnotationswindow::ExportButtonClicked()
{
int i, j, n,
len,
csv_format=0,
hdl,
annot_cnt,
temp,
include_duration;
char path[MAX_PATH_LENGTH],
str[1024],
separator;
FILE *annotationfile=NULL;
struct annotationblock *annot, *annot_list;
struct edfhdrblock *hdr;
struct date_time_struct tm;
if(CSVRadioButton->isChecked() == true)
{
if(asciiSecondsRadioButton->isChecked() == true)
{
csv_format = 1;
}
if(asciiISOtimeRadioButton->isChecked() == true)
{
csv_format = 2;
}
if(asciiISOtimedateRadioButton->isChecked() == true)
{
csv_format = 3;
}
if(asciiISOtimeFractionRadioButton->isChecked() == true)
{
csv_format = 4;
}
if(asciiISOtimedateFractionRadioButton->isChecked() == true)
{
csv_format = 5;
}
}
if(EDFplusRadioButton->isChecked() == true)
{
csv_format = 0;
}
if(XMLRadioButton->isChecked() == true)
{
csv_format = 8;
}
mainwindow->export_annotations_var->format = csv_format;
if(separatorBox->currentIndex() == 0)
{
separator = ',';
mainwindow->export_annotations_var->separator = 0;
}
else
{
separator = '\t';
mainwindow->export_annotations_var->separator = 1;
}
if(durationCheckBox->checkState() == Qt::Checked)
{
include_duration = 1;
mainwindow->export_annotations_var->duration = 1;
}
else
{
include_duration = 0;
mainwindow->export_annotations_var->duration = 0;
}
if(!mainwindow->files_open)
{
ExportAnnotsDialog->close();
return;
}
if(filelist->count() < 1)
{
ExportAnnotsDialog->close();
return;
}
ExportButton->setEnabled(false);
CloseButton->setEnabled(false);
for(i=0; i<mainwindow->files_open; i++)
{
if(!strcmp(mainwindow->edfheaderlist[i]->filename, filelist->item(filelist->currentRow())->text().toLocal8Bit().data()))
{
break;
}
}
if(i==mainwindow->files_open)
{
ExportAnnotsDialog->close();
return;
}
n = i;
if(mergeRadioButton->isChecked() == true)
{
n = mainwindow->sel_viewtime;
}
hdr = mainwindow->edfheaderlist[n];
path[0] = 0;
if(mainwindow->recent_savedir[0]!=0)
{
strcpy(path, mainwindow->recent_savedir);
strcat(path, "/");
}
len = strlen(path);
get_filename_from_path(path + len, mainwindow->edfheaderlist[n]->filename, MAX_PATH_LENGTH - len);
remove_extension_from_filename(path);
if((csv_format > 0) && (csv_format < 6))
{
strcat(path, "_annotations.txt");
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "Text files (*.txt *.TXT *.csv *.CSV)").toLocal8Bit().data());
}
if(csv_format == 8)
{
strcat(path, "_annotations.xml");
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "XML files (*.xml *.XML)").toLocal8Bit().data());
}
if(csv_format == 0)
{
strcat(path, "_annotations.edf");
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
}
if(!strcmp(path, ""))
{
ExportAnnotsDialog->close();
return;
}
get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(path))
{
QMessageBox messagewindow(QMessageBox::Critical, "Export annotations", "Error, selected file is in use.");
messagewindow.exec();
return;
}
annot_list = edfplus_annotation_copy_list(&mainwindow->annotationlist[n]);
if(mergeRadioButton->isChecked() == true)
{
for(i=0; i < mainwindow->files_open; i++)
{
if(i != mainwindow->sel_viewtime)
{
annot_cnt = edfplus_annotation_count(&mainwindow->annotationlist[i]);
for(j=0; j < annot_cnt; j++)
{
edfplus_annotation_add_copy(&annot_list, edfplus_annotation_item(&mainwindow->annotationlist[i], j));
annot = edfplus_annotation_item(&annot_list, edfplus_annotation_count(&annot_list) - 1);
annot->onset -= (mainwindow->edfheaderlist[i]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime);
}
}
}
edfplus_annotation_sort(&annot_list);
}
annot_cnt = edfplus_annotation_count(&annot_list);
///////////////////////////// CSV (text) export //////////////////////////////////////
if((csv_format > 0) && (csv_format < 6))
{
annotationfile = fopeno(path, "wb");
if(annotationfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open annotationfile for writing.");
messagewindow.exec();
ExportAnnotsDialog->close();
edfplus_annotation_delete_list(&annot_list);
return;
}
if(include_duration)
{
fprintf(annotationfile, "Onset%cDuration%cAnnotation\n", separator, separator);
}
else
{
fprintf(annotationfile, "Onset%cAnnotation\n", separator);
}
for(j=0; j < annot_cnt; j++)
{
annot = edfplus_annotation_item(&annot_list, j);
if(annot == NULL)
{
break;
}
strncpy(str, annot->annotation, 1024);
str[1023] = 0;
utf8_to_latin1(str);
len = strlen(str);
for(i=0; i<len; i++)
{
if((((unsigned char *)str)[i] < 32) || (((unsigned char *)str)[i] == ','))
{
str[i] = '.';
}
}
if(csv_format == 1)
{
if(include_duration)
{
fprintf(annotationfile, "%+.7f%c%s%c%s\n", (double)(annot->onset - hdr->starttime_offset) / TIME_DIMENSION, separator, annot->duration, separator, str);
}
else
{
fprintf(annotationfile, "%+.7f%c%s\n", (double)(annot->onset - hdr->starttime_offset) / TIME_DIMENSION, separator, str);
}
}
if(csv_format == 2)
{
temp = annot->onset % TIME_DIMENSION;
if(temp < 0)
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm);
}
else
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm);
}
if(include_duration)
{
fprintf(annotationfile, "%02i:%02i:%02i%c%s%c%s\n", tm.hour, tm.minute, tm.second, separator, annot->duration, separator, str);
}
else
{
fprintf(annotationfile, "%02i:%02i:%02i%c%s\n", tm.hour, tm.minute, tm.second, separator, str);
}
}
if(csv_format == 3)
{
temp = annot->onset % TIME_DIMENSION;
if(temp < 0)
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm);
}
else
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm);
}
if(include_duration)
{
fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i%c%s%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, separator, annot->duration, separator, str);
}
else
{
fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, separator, str);
}
}
if(csv_format == 4)
{
temp = annot->onset % TIME_DIMENSION;
if(temp < 0)
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm);
temp = TIME_DIMENSION + temp;
}
else
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm);
}
if(include_duration)
{
fprintf(annotationfile, "%02i:%02i:%02i.%07i%c%s%c%s\n", tm.hour, tm.minute, tm.second, temp, separator, annot->duration, separator, str);
}
else
{
fprintf(annotationfile, "%02i:%02i:%02i.%07i%c%s\n", tm.hour, tm.minute, tm.second, temp, separator, str);
}
}
if(csv_format == 5)
{
temp = annot->onset % TIME_DIMENSION;
if(temp < 0)
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm);
temp = TIME_DIMENSION + temp;
}
else
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm);
}
if(include_duration)
{
fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i.%07i%c%s%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, temp, separator, annot->duration, separator, str);
}
else
{
fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i.%07i%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, temp, separator, str);
}
}
}
fclose(annotationfile);
edfplus_annotation_delete_list(&annot_list);
QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done.");
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
ExportAnnotsDialog->close();
return;
}
///////////////////////////// XML export //////////////////////////////////////
if(csv_format == 8)
{
annotationfile = fopeno(path, "wb");
if(annotationfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open annotationfile for writing.");
messagewindow.exec();
ExportAnnotsDialog->close();
edfplus_annotation_delete_list(&annot_list);
return;
}
fprintf(annotationfile, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
fprintf(annotationfile, "<!-- Generated by " PROGRAM_NAME " " PROGRAM_VERSION " -->\n");
fprintf(annotationfile, "<annotationlist>\n");
utc_to_date_time(hdr->utc_starttime, &tm);
fprintf(annotationfile, " <recording_start_time>%04i-%02i-%02iT%02i:%02i:%02i.%07i</recording_start_time>\n",
tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, (int)hdr->starttime_offset);
for(j=0; j < annot_cnt; j++)
{
annot = edfplus_annotation_item(&annot_list, j);
if(annot == NULL)
{
break;
}
temp = annot->onset % TIME_DIMENSION;
if(temp < 0)
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm);
temp = TIME_DIMENSION + temp;
}
else
{
utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm);
}
fprintf(annotationfile, " <annotation>\n"
" <onset>%04i-%02i-%02iT%02i:%02i:%02i.%07i</onset>\n"
" <duration>%s</duration>\n"
" <description>",
tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, temp, annot->duration);
xml_fwrite_encode_entity(annotationfile, annot->annotation);
fprintf(annotationfile, "</description>\n"
" </annotation>\n");
}
fprintf(annotationfile, "</annotationlist>\n");
fclose(annotationfile);
edfplus_annotation_delete_list(&annot_list);
QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done.");
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
ExportAnnotsDialog->close();
return;
}
///////////////////////////// EDFplus export //////////////////////////////////////
if(csv_format == 0)
{
hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, 0);
if(hdl < 0)
{
switch(hdl)
{
case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error");
break;
case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory");
break;
case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum files reached");
break;
case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file already opened");
break;
case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: number of signals is invalid");
break;
default : strcpy(str, "EDFlib: unknown error");
break;
}
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
edfplus_annotation_delete_list(&annot_list);
ExportAnnotsDialog->close();
return;
}
utc_to_date_time(hdr->utc_starttime, &tm);
edf_set_startdatetime(hdl, tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
if((hdr->edfplus) || (hdr->bdfplus))
{
edf_set_patientname(hdl, hdr->plus_patient_name);
edf_set_patientcode(hdl, hdr->plus_patientcode);
if(!(strcmp(hdr->plus_gender, "Male")))
{
edf_set_gender(hdl, 1);
}
if(!(strcmp(hdr->plus_gender, "Female")))
{
edf_set_gender(hdl, 0);
}
if(hdr->plus_birthdate[0] != 0)
{
if(!(strncmp(hdr->plus_birthdate + 3, "jan", 3))) n = 1;
if(!(strncmp(hdr->plus_birthdate + 3, "feb", 3))) n = 2;
if(!(strncmp(hdr->plus_birthdate + 3, "mar", 3))) n = 3;
if(!(strncmp(hdr->plus_birthdate + 3, "apr", 3))) n = 4;
if(!(strncmp(hdr->plus_birthdate + 3, "may", 3))) n = 5;
if(!(strncmp(hdr->plus_birthdate + 3, "jun", 3))) n = 6;
if(!(strncmp(hdr->plus_birthdate + 3, "jul", 3))) n = 7;
if(!(strncmp(hdr->plus_birthdate + 3, "aug", 3))) n = 8;
if(!(strncmp(hdr->plus_birthdate + 3, "sep", 3))) n = 9;
if(!(strncmp(hdr->plus_birthdate + 3, "oct", 3))) n = 10;
if(!(strncmp(hdr->plus_birthdate + 3, "nov", 3))) n = 11;
if(!(strncmp(hdr->plus_birthdate + 3, "dec", 3))) n = 12;
edf_set_birthdate(hdl, atoi(hdr->plus_birthdate + 7), n, atoi(hdr->plus_birthdate));
}
edf_set_patient_additional(hdl, hdr->plus_patient_additional);
edf_set_admincode(hdl, hdr->plus_admincode);
edf_set_technician(hdl, hdr->plus_technician);
edf_set_equipment(hdl, hdr->plus_equipment);
edf_set_recording_additional(hdl, hdr->plus_recording_additional);
}
else
{
edf_set_patientname(hdl, hdr->patient);
edf_set_recording_additional(hdl, hdr->recording);
}
int hasdot,
decimals;
for(j=0; j < annot_cnt; j++)
{
annot = edfplus_annotation_item(&annot_list, j);
if(annot == NULL)
{
break;
}
if(annot->duration[0] == 0)
{
edfwrite_annotation_utf8(hdl, annot->onset / 1000LL, -1LL, annot->annotation);
}
else
{
strcpy(str, annot->duration);
len = strlen(str);
hasdot = 0;
for(i=0; i<len; i++)
{
if(str[i] == '.')
{
hasdot = 1;
for(decimals=0; decimals<4; decimals++)
{
str[i] = str[i+1];
if(str[i] == 0)
{
for( ; decimals<4; decimals++)
{
str[i] = '0';
i++;
}
i--;
}
i++;
}
str[i] = 0;
break;
}
}
if(!hasdot)
{
strcat(str, "0000");
}
edfwrite_annotation_utf8(hdl, annot->onset / 1000LL, atoi(str), annot->annotation);
}
}
if(edfclose_file(hdl) != 0)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred: edfclose_file()");
messagewindow.exec();
}
edfplus_annotation_delete_list(&annot_list);
QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done.");
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
ExportAnnotsDialog->close();
}
}
void UI_AveragerWindow::startButtonClicked()
{
int i, j, n,
avg_cnt=0,
samples_on_screen,
trigger_position_ratio=4,
dialoglistnumber,
itemCnt,
progress_steps;
char str[MAX_ANNOTATION_LEN + 1],
scratchpad[1024];
double avg_max_value,
avg_min_value;
long long backup_viewtime,
backup_timescale,
l_time1,
l_time2;
struct annotationblock *annot;
QList<QListWidgetItem *> itemList;
mainwindow->average_period = avg_periodspinbox->value();
mainwindow->average_ratio = ratioBox->currentIndex();
itemList = list->selectedItems();
itemCnt = itemList.size();
if(itemCnt < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "You have to select at least one signal.");
messagewindow.exec();
return;
}
if(itemCnt > MAXAVERAGECURVEDIALOGS)
{
sprintf(scratchpad,"You can not select more than %i signals.", MAXAVERAGECURVEDIALOGS);
QMessageBox messagewindow(QMessageBox::Critical, "Error", scratchpad);
messagewindow.exec();
return;
}
time1 = timeEdit1->time();
time2 = timeEdit2->time();
if(time2.operator<=(time1) == true)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Starttime is higher or equal to stoptime.");
messagewindow.exec();
return;
}
l_time1 = (((time1.hour() * 3600) + (time1.minute() * 60) + (time1.second())) * TIME_DIMENSION) + (time1.msec() * TIME_DIMENSION / 1000LL);
l_time2 = (((time2.hour() * 3600) + (time2.minute() * 60) + (time2.second())) * TIME_DIMENSION) + (time2.msec() * TIME_DIMENSION / 1000LL);
n = ratioBox->currentIndex();
switch(n)
{
case 0 : trigger_position_ratio = 10;
break;
case 1 : trigger_position_ratio = 4;
break;
case 2 : trigger_position_ratio = 2;
break;
}
backup_viewtime = mainwindow->edfheaderlist[0]->viewtime;
backup_timescale = mainwindow->pagetime;
mainwindow->pagetime = avg_periodspinbox->value() * TIME_DIMENSION;
mainwindow->setup_viewbuf();
mainwindow->signal_averaging_active = 1;
n = edfplus_annotation_count(&mainwindow->annotationlist[0]);
avg_cnt = 0;
for(i=0; i<n; i++)
{
annot = edfplus_annotation_item(&mainwindow->annotationlist[0], i);
if(((annot->onset - mainwindow->edfheaderlist[0]->starttime_offset) >= l_time1)
&& ((annot->onset - mainwindow->edfheaderlist[0]->starttime_offset) <= l_time2))
{
strcpy(str, annot->annotation);
remove_trailing_spaces(str);
if(!strcmp(str, annot_str))
{
avg_cnt++;
}
}
}
QProgressDialog progress("Averaging ...", "Abort", 0, avg_cnt, averager_dialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress.reset();
progress_steps = avg_cnt / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
for(j=0; j<itemCnt; j++)
{
for(i=0; i<MAXAVERAGECURVEDIALOGS; i++)
{
if(mainwindow->averagecurvedialog[i] == NULL)
{
dialoglistnumber = i;
break;
}
}
if(i >= MAXAVERAGECURVEDIALOGS)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Too many \"Average\" windows are open.\nClose some first.");
messagewindow.exec();
mainwindow->edfheaderlist[0]->viewtime = backup_viewtime;
mainwindow->pagetime = backup_timescale;
mainwindow->signal_averaging_active = 0;
mainwindow->setup_viewbuf();
return;
}
signal_nr = list->row(itemList.at(j));
if(mainwindow->signalcomp[signal_nr]->samples_on_screen > 2147483646LL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Too many samples in buf.");
messagewindow.exec();
mainwindow->edfheaderlist[0]->viewtime = backup_viewtime;
mainwindow->pagetime = backup_timescale;
mainwindow->signal_averaging_active = 0;
mainwindow->setup_viewbuf();
return;
}
samples_on_screen = mainwindow->signalcomp[signal_nr]->samples_on_screen;
avgbuf = (double *)calloc(1, sizeof(double) * samples_on_screen);
if(avgbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
mainwindow->edfheaderlist[0]->viewtime = backup_viewtime;
mainwindow->pagetime = backup_timescale;
mainwindow->signal_averaging_active = 0;
mainwindow->setup_viewbuf();
return;
}
n = edfplus_annotation_count(&mainwindow->annotationlist[0]);
avg_cnt = 0;
for(i=0; i<n; i++)
{
annot = edfplus_annotation_item(&mainwindow->annotationlist[0], i);
if(((annot->onset - mainwindow->edfheaderlist[0]->starttime_offset) >= l_time1)
&& ((annot->onset - mainwindow->edfheaderlist[0]->starttime_offset) <= l_time2))
{
strcpy(str, annot->annotation);
remove_trailing_spaces(str);
if(!strcmp(str, annot_str))
{
if(!(avg_cnt % progress_steps))
{
progress.setValue(avg_cnt);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
free(avgbuf);
mainwindow->edfheaderlist[0]->viewtime = backup_viewtime;
mainwindow->pagetime = backup_timescale;
mainwindow->signal_averaging_active = 0;
mainwindow->setup_viewbuf();
return;
}
}
mainwindow->edfheaderlist[0]->viewtime = annot->onset;
mainwindow->edfheaderlist[0]->viewtime -= mainwindow->edfheaderlist[0]->starttime_offset;
mainwindow->edfheaderlist[0]->viewtime -= (mainwindow->pagetime / trigger_position_ratio);
mainwindow->setup_viewbuf();
process_avg(mainwindow->signalcomp[signal_nr]);
avg_cnt++;
}
}
}
progress.reset();
if(!avg_cnt)
{
sprintf(scratchpad, "The selected annotation/trigger \"%s\" is not in the selected timewindow\n"
"%i:%02i:%02i - %i:%02i:%02i",
annot_str,
timeEdit1->time().hour(), timeEdit1->time().minute(), timeEdit1->time().second(),
timeEdit2->time().hour(), timeEdit2->time().minute(), timeEdit2->time().second());
QMessageBox messagewindow(QMessageBox::Critical, "Error", scratchpad);
messagewindow.exec();
free(avgbuf);
mainwindow->edfheaderlist[0]->viewtime = backup_viewtime;
mainwindow->pagetime = backup_timescale;
mainwindow->signal_averaging_active = 0;
mainwindow->setup_viewbuf();
return;
}
avg_max_value = -100000000.0;
avg_min_value = 100000000.0;
for(i=0; i<samples_on_screen; i++)
{
avgbuf[i] /= avg_cnt;
if(avgbuf[i] > avg_max_value)
{
avg_max_value = avgbuf[i];
}
if(avgbuf[i] < avg_min_value)
{
avg_min_value = avgbuf[i];
}
}
mainwindow->averagecurvedialog[dialoglistnumber] = new UI_AverageCurveWindow(mainwindow->signalcomp[signal_nr], mainwindow, dialoglistnumber,
avgbuf,
avg_max_value,
avg_min_value,
mainwindow->pagetime,
mainwindow->signalcomp[signal_nr]->samples_on_screen,
avg_cnt,
trigger_position_ratio,
annot_str,
avg_periodspinbox->value());
for(i=0; i<MAXAVERAGECURVEDIALOGS; i++)
{
if(mainwindow->signalcomp[signal_nr]->avg_dialog[i] == 0)
{
mainwindow->signalcomp[signal_nr]->avg_dialog[i] = dialoglistnumber + 1;
break;
}
}
}
mainwindow->edfheaderlist[0]->viewtime = backup_viewtime;
mainwindow->pagetime = backup_timescale;
mainwindow->signal_averaging_active = 0;
mainwindow->setup_viewbuf();
averager_dialog->close();
}
