static void check_for_file(bfpath *bfp)
{
int rc;
struct stat sb;
bfp->isdir = bfp->isfile = false;
rc = stat(bfp->filepath, &sb);
if (rc == 0) {
bfp->exists = true;
xfree(bfp->dirname);
xfree(bfp->filename);
if (S_ISDIR(sb.st_mode)) {
bfp->isdir = true;
bfp->dirname = xstrdup(bfp->filepath);
bfp->filename = NULL;
}
if (!S_ISDIR(sb.st_mode)) {
bfp->isfile = true;
bfp->dirname = get_directory_from_path(bfp->filepath);
bfp->filename = get_file_from_path(bfp->filepath);
}
}
return;
}
void UI_SpectrumDockWindow::print_to_txt()
{
int i;
char str[1024],
path[MAX_PATH_LENGTH];
FILE *outputfile;
path[0] = 0;
if(mainwindow->recent_savedir[0]!=0)
{
strcpy(path, mainwindow->recent_savedir);
strcat(path, "/");
}
strcat(path, "spectrum.txt");
strcpy(path, QFileDialog::getSaveFileName(0, "Export to text (ASCII)", QString::fromLocal8Bit(path), "Text files (*.txt *.TXT)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH);
outputfile = fopen(path, "wb");
if(outputfile == NULL)
{
snprintf(str, 1024, "Can not open file %s for writing.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(str));
messagewindow.exec();
return;
}
sprintf(str, "FFT Power Spectral Density (Power/%fHz)\n", freqstep);
remove_trailing_zeros(str);
fprintf(outputfile, "%s", str);
fprintf(outputfile, "Signal: %s\n", signalcomp->signallabel);
sprintf(str, "FFT blocksize: %i\n", mainwindow->maxdftblocksize);
sprintf(str + strlen(str), "FFT resolution: %f Hz\n", freqstep);
sprintf(str + strlen(str), "Data Samples: %i\n", samples);
sprintf(str + strlen(str), "Power Samples: %i\n", steps);
sprintf(str + strlen(str), "Samplefrequency: %f Hz\n", (double)signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record / ((double)signalcomp->edfhdr->long_data_record_duration / TIME_DIMENSION));
remove_trailing_zeros(str);
fprintf(outputfile, "%s", str);
for(i=0; i<steps; i++)
{
fprintf(outputfile, "%.16f\t%.16f\n", freqstep * i, buf2[i]);
}
fclose (outputfile);
}
void UI_Mainwindow::save_memory_waveform()
{
int i, j, k,
n=0,
chn,
chns=0,
hdl=-1,
bytes_rcvd=0,
mempnts,
yref[MAX_CHNS],
yor[MAX_CHNS],
smps_per_record,
datrecs=1,
empty_buf;
char str[128],
opath[MAX_PATHLEN];
short *wavbuf[4];
long long rec_len=0LL;
double yinc[MAX_CHNS];
if(device == NULL)
{
return;
}
scrn_timer->stop();
scrn_thread->wait();
wavbuf[0] = NULL;
wavbuf[1] = NULL;
wavbuf[2] = NULL;
wavbuf[3] = NULL;
mempnts = devparms.acquirememdepth;
smps_per_record = mempnts;
QProgressDialog progress("Downloading data...", "Abort", 0, mempnts, this);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(100);
statusLabel->setText("Downloading data...");
for(i=0; i<MAX_CHNS; i++)
{
if(!devparms.chandisplay[i])
{
continue;
}
chns++;
}
if(!chns)
{
strcpy(str, "No active channels.");
goto OUT_ERROR;
}
while(smps_per_record >= (5000000 / chns))
{
smps_per_record /= 2;
datrecs *= 2;
}
if(mempnts < 1)
{
strcpy(str, "Can not save waveform when memory depth is set to \"Auto\".");
goto OUT_ERROR;
}
rec_len = (EDFLIB_TIME_DIMENSION * (long long)mempnts) / devparms.samplerate;
if(rec_len < 100)
{
strcpy(str, "Can not save waveforms shorter than 10 uSec.\n"
"Set the horizontal timebase to 1 uSec or higher.");
goto OUT_ERROR;
}
for(i=0; i<MAX_CHNS; i++)
{
if(!devparms.chandisplay[i]) // Download data only when channel is switched on
{
continue;
}
wavbuf[i] = (short *)malloc(mempnts * sizeof(short));
if(wavbuf[i] == NULL)
{
sprintf(str, "Malloc error. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
}
tmc_write(":STOP");
usleep(20000);
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn]) // Download data only when channel is switched on
{
continue;
}
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
tmc_write(str);
tmc_write(":WAV:FORM BYTE");
usleep(20000);
tmc_write(":WAV:MODE RAW");
usleep(20000);
tmc_write(":WAV:YINC?");
usleep(20000);
tmc_read();
yinc[chn] = atof(device->buf);
if(yinc[chn] < 1e-6)
{
sprintf(str, "Error, parameter \"YINC\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YREF?");
usleep(20000);
tmc_read();
yref[chn] = atoi(device->buf);
if((yref[chn] < 1) || (yref[chn] > 255))
{
sprintf(str, "Error, parameter \"YREF\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YOR?");
usleep(20000);
tmc_read();
yor[chn] = atoi(device->buf);
if((yor[chn] < -255) || (yor[chn] > 255))
{
sprintf(str, "Error, parameter \"YOR\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
empty_buf = 0;
for(bytes_rcvd=0; bytes_rcvd<mempnts ;)
{
progress.setValue(bytes_rcvd);
qApp->processEvents();
if(progress.wasCanceled())
{
strcpy(str, "Canceled");
goto OUT_ERROR;
}
sprintf(str, ":WAV:STAR %i", bytes_rcvd + 1);
usleep(20000);
tmc_write(str);
if((bytes_rcvd + SAV_MEM_BSZ) > mempnts)
{
sprintf(str, ":WAV:STOP %i", mempnts);
}
else
{
sprintf(str, ":WAV:STOP %i", bytes_rcvd + SAV_MEM_BSZ);
}
usleep(20000);
tmc_write(str);
usleep(20000);
tmc_write(":WAV:DATA?");
n = tmc_read();
if(n < 0)
{
sprintf(str, "Can not read from device. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
printf("received %i bytes, total %i bytes\n", n, n + bytes_rcvd);
if(n > SAV_MEM_BSZ)
{
sprintf(str, "Datablock too big for buffer. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
if(n < 1)
{
if(empty_buf++ > 100)
{
break;
}
}
else
{
empty_buf = 0;
}
for(k=0; k<n; k++)
{
if((bytes_rcvd + k) >= mempnts)
{
break;
}
wavbuf[chn][bytes_rcvd + k] = ((int)(((unsigned char *)device->buf)[k]) - yref[chn] - yor[chn]) << 5;
}
bytes_rcvd += n;
if(bytes_rcvd >= mempnts)
{
break;
}
}
if(bytes_rcvd < mempnts)
{
sprintf(str, "Download error. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
}
progress.reset();
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
usleep(20000);
tmc_write(str);
usleep(20000);
tmc_write(":WAV:MODE NORM");
usleep(20000);
tmc_write(":WAV:STAR 1");
if(devparms.modelserie == 1)
{
usleep(20000);
tmc_write(":WAV:STOP 1200");
}
else
{
usleep(20000);
tmc_write(":WAV:STOP 1400");
usleep(20000);
tmc_write(":WAV:POIN 1400");
}
}
if(bytes_rcvd < mempnts)
{
sprintf(str, "Download error. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
else
{
statusLabel->setText("Downloading finished");
}
opath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(opath, recent_savedir);
strcat(opath, "/");
}
strcat(opath, "waveform.edf");
strcpy(opath, QFileDialog::getSaveFileName(this, "Save file", opath, "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(opath, ""))
{
goto OUT_NORMAL;
}
get_directory_from_path(recent_savedir, opath, MAX_PATHLEN);
hdl = edfopen_file_writeonly(opath, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl < 0)
{
strcpy(str, "Can not create EDF file.");
goto OUT_ERROR;
}
if(edf_set_datarecord_duration(hdl, (rec_len / 100LL) / datrecs))
{
strcpy(str, "Can not set datarecord duration of EDF file.");
goto OUT_ERROR;
}
j = 0;
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
edf_set_samplefrequency(hdl, j, smps_per_record);
edf_set_digital_maximum(hdl, j, 32767);
edf_set_digital_minimum(hdl, j, -32768);
if(devparms.chanscale[chn] > 2)
{
edf_set_physical_maximum(hdl, j, yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "V");
}
else
{
edf_set_physical_maximum(hdl, j, 1000.0 * yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, 1000.0 * yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "mV");
}
sprintf(str, "CHAN%i", chn + 1);
edf_set_label(hdl, j, str);
j++;
}
edf_set_equipment(hdl, devparms.modelname);
for(i=0; i<datrecs; i++)
{
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
if(edfwrite_digital_short_samples(hdl, wavbuf[chn] + (i * smps_per_record)))
{
strcpy(str, "A write error occurred.");
goto OUT_ERROR;
}
}
}
OUT_NORMAL:
if(hdl >= 0)
{
edfclose_file(hdl);
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
return;
OUT_ERROR:
progress.reset();
statusLabel->setText("Downloading aborted");
if(hdl >= 0)
{
edfclose_file(hdl);
}
if(progress.wasCanceled() == false)
{
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Critical);
msgBox.setText(str);
msgBox.exec();
}
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
tmc_write(str);
tmc_write(":WAV:MODE NORM");
tmc_write(":WAV:STAR 1");
if(devparms.modelserie == 1)
{
tmc_write(":WAV:STOP 1200");
}
else
{
tmc_write(":WAV:STOP 1400");
tmc_write(":WAV:POIN 1400");
}
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
}
void UI_ECGExport::Export_RR_intervals()
{
int i,
len,
signal_nr,
type=-1,
beat_cnt,
samples_cnt,
progress_steps,
datarecords,
whole_recording=0,
import_as_annots=0,
filenum=0;
char path[MAX_PATH_LENGTH],
str[2048];
double *beat_interval_list,
*buf;
long long *beat_onset_list,
datrecs,
smpls_left,
l_time=0LL;
struct signalcompblock *signalcomp;
FILE *outputfile;
QList<QListWidgetItem *> selectedlist;
struct annotationblock *annotation;
selectedlist = list->selectedItems();
if(selectedlist.size() < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Select a signal first.");
messagewindow.exec();
return;
}
signal_nr = selectedlist.at(0)->data(Qt::UserRole).toInt();
if((signal_nr < 0) || (signal_nr >= mainwindow->signalcomps))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Invalid signalcomp number");
messagewindow.exec();
return;
}
signalcomp = mainwindow->signalcomp[signal_nr];
if(signalcomp->ecg_filter == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Heart Rate detection is not activated for the selected signal.");
messagewindow.exec();
return;
}
if(checkBox2->checkState() == Qt::Checked)
{
import_as_annots = 1;
}
if(checkBox1->checkState() == Qt::Checked)
{
whole_recording = 1;
class FilteredBlockReadClass blockrd;
buf = blockrd.init_signalcomp(signalcomp, 1, 0);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, can not initialize FilteredBlockReadClass.");
messagewindow.exec();
return;
}
samples_cnt = blockrd.samples_in_buf();
if(samples_cnt < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, samples_cnt is < 1.");
messagewindow.exec();
return;
}
filenum = signalcomp->filenum;
reset_ecg_filter(signalcomp->ecg_filter);
datarecords = signalcomp->edfhdr->datarecords;
QProgressDialog progress("Processing file...", "Abort", 0, datarecords);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = datarecords / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
for(i=0; i<signalcomp->edfhdr->datarecords; i++)
{
if(!(i%progress_steps))
{
progress.setValue(i);
qApp->processEvents();
if(progress.wasCanceled() == TRUE)
{
return;
}
}
if(blockrd.process_signalcomp(i) != 0)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error while reading file.");
messagewindow.exec();
return;
}
}
progress.reset();
}
beat_cnt = ecg_filter_get_beat_cnt(signalcomp->ecg_filter);
beat_onset_list = ecg_filter_get_onset_beatlist(signalcomp->ecg_filter);
beat_interval_list = ecg_filter_get_interval_beatlist(signalcomp->ecg_filter);
if(beat_cnt < 4)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, not enough beats.");
messagewindow.exec();
return;
}
if(import_as_annots)
{
for(i=0; i<beat_cnt; i++)
{
if(whole_recording)
{
l_time = 0LL;
}
else
{
l_time = signalcomp->edfhdr->viewtime;
}
if(l_time < 0LL)
{
l_time = 0LL;
}
datrecs = beat_onset_list[i] / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record;
smpls_left = beat_onset_list[i] % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record;
l_time += (datrecs * signalcomp->edfhdr->long_data_record_duration);
l_time += ((smpls_left * signalcomp->edfhdr->long_data_record_duration) / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record);
if(!whole_recording)
{
l_time += (mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime - signalcomp->edfhdr->viewtime);
}
annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock));
if(annotation == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred (annotation).");
messagewindow.exec();
return;
}
annotation->onset = l_time;
strncpy(annotation->annotation, "R-onset", MAX_ANNOTATION_LEN);
annotation->annotation[MAX_ANNOTATION_LEN] = 0;
edfplus_annotation_add_item(&mainwindow->annotationlist[filenum], annotation);
}
if(mainwindow->annotations_dock[signalcomp->filenum] == NULL)
{
mainwindow->annotations_dock[filenum] = new UI_Annotationswindow(filenum, mainwindow);
mainwindow->addDockWidget(Qt::RightDockWidgetArea, mainwindow->annotations_dock[filenum]->docklist, Qt::Vertical);
if(!mainwindow->annotationlist[filenum])
{
mainwindow->annotations_dock[filenum]->docklist->hide();
}
}
if(mainwindow->annotationlist[filenum])
{
mainwindow->annotations_dock[filenum]->docklist->show();
mainwindow->annotations_edited = 1;
mainwindow->annotations_dock[filenum]->updateList();
mainwindow->save_act->setEnabled(TRUE);
}
}
else
{
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, signalcomp->edfhdr->filename, MAX_PATH_LENGTH - len);
remove_extension_from_filename(path);
strcat(path, "_RR_interval.txt");
strcpy(path, QFileDialog::getSaveFileName(0, "Export RR-interval to ASCII", QString::fromLocal8Bit(path), "Text files (*.txt *.TXT)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH);
outputfile = fopeno(path, "wb");
if(outputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, can not open outputfile for writing.");
messagewindow.exec();
return;
}
if(radioButton1->isChecked() == TRUE)
{
type = 1;
}
if(radioButton2->isChecked() == TRUE)
{
type = 2;
}
if(radioButton3->isChecked() == TRUE)
{
type = 3;
}
if(type == 1)
{
for(i=0; i<beat_cnt; i++)
{
fprintf(outputfile, "%.4f\n", beat_interval_list[i]);
}
}
if((type == 2) || (type == 3))
{
for(i=0; i<beat_cnt; i++)
{
if(whole_recording)
{
l_time = 0LL;
}
else
{
l_time = signalcomp->edfhdr->viewtime;
}
if(l_time < 0LL)
{
l_time = 0LL;
}
datrecs = beat_onset_list[i] / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record;
smpls_left = beat_onset_list[i] % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record;
l_time += (datrecs * signalcomp->edfhdr->long_data_record_duration);
l_time += ((smpls_left * signalcomp->edfhdr->long_data_record_duration) / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record);
if(!whole_recording)
{
l_time += (mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime - signalcomp->edfhdr->viewtime);
}
if(type == 2)
{
fprintf(outputfile, "%.4f\t%.4f\n", ((double)l_time) / TIME_DIMENSION, beat_interval_list[i]);
}
if(type == 3)
{
fprintf(outputfile, "%.4f\n", ((double)l_time) / TIME_DIMENSION);
}
}
}
fclose(outputfile);
}
myobjectDialog->close();
if(!import_as_annots)
{
sprintf(str, "Done. The R-onsets and/or RR-intervals are exported to:\n\n%s", path);
QMessageBox messagewindow(QMessageBox::Information, "Ready", str);
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
}
reset_ecg_filter(signalcomp->ecg_filter);
mainwindow->setup_viewbuf();
}
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_FINO2EDFwindow::SelectFileButton()
{
FILE *inputfile=NULL,
*outputfile=NULL;
int i, j, k, p,
temp,
separator=';',
edfsignals=0,
ok,
timestep,
new_smpl_time=0,
datarecords,
str_start,
column,
line_nr;
char txt_string[2048],
path[512],
outputfilename[MAX_PATH_LENGTH],
line[2048],
scratchpad[128],
labels[MAX_SIGNALS][17],
phys_dim[MAX_SIGNALS][9],
phys_min[MAX_SIGNALS][9],
phys_max[MAX_SIGNALS][9],
patientname[81],
recording[81],
datetime[17];
double sensitivity[MAX_SIGNALS],
new_value[MAX_SIGNALS],
old_value[MAX_SIGNALS];
union{
short two;
char one[2];
} var;
for(j=0; j<MAX_SIGNALS; j++)
{
old_value[j] = 0.0;
}
enable_widgets(false);
if(!(strlen(PatientnameLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subjectname.");
messagewindow.exec();
enable_widgets(true);
return;
}
if(!(strlen(RecordingLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recordingdescription.");
messagewindow.exec();
enable_widgets(true);
return;
}
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "Text files (*.txt *.TXT)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
enable_widgets(true);
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
inputfile = fopeno(path, "rb");
if(inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
enable_widgets(true);
return;
}
/***************** check if the txtfile is valid ******************************/
rewind(inputfile);
if(fread(scratchpad, 5, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading the inputfile.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(strncmp(scratchpad, "\"T\";", 4))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown data in file (1).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
while(1)
{
temp = fgetc(inputfile);
if(temp==EOF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (2).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(temp=='\n') break;
}
if(fread(scratchpad, 2, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading inputfile (3).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(strncmp(scratchpad, "\"s\";", 4))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown data in file (4).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
/***************** collect items *****************************************/
rewind(inputfile);
while(1)
{
temp = fgetc(inputfile);
if(temp==EOF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (5).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(temp==separator)
{
break;
}
}
i = 0;
while(temp!='\n')
{
temp = fgetc(inputfile);
if(temp==EOF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (6).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(temp=='\r')
{
continue;
}
if((temp==separator)||(temp=='\n'))
{
if(edfsignals>=MAX_SIGNALS)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Too many labels/signals (7).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
line[i] = 0;
ok = 0;
if(!strcmp(line, "\" reSYS\""))
{
strcpy(labels[edfsignals], "reSYS ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" fiSYS\""))
{
strcpy(labels[edfsignals], "fiSYS ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" reDIA\""))
{
strcpy(labels[edfsignals], "reDIA ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" fiDIA\""))
{
strcpy(labels[edfsignals], "fiDIA ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" reMAP\""))
{
strcpy(labels[edfsignals], "reMAP ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" fiMAP\""))
{
strcpy(labels[edfsignals], "fiMAP ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" HR\""))
{
strcpy(labels[edfsignals], "HR ");
strcpy(phys_dim[edfsignals], "bpm ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" IBI\""))
{
strcpy(labels[edfsignals], "IBI ");
strcpy(phys_dim[edfsignals], "s ");
strcpy(phys_min[edfsignals], "-31.744 ");
strcpy(phys_max[edfsignals], "31.744 ");
sensitivity[edfsignals] = 1000.0;
ok = 1;
}
if(!strcmp(line, "\" SV\""))
{
strcpy(labels[edfsignals], "SV ");
strcpy(phys_dim[edfsignals], "ml ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" CO\""))
{
strcpy(labels[edfsignals], "CO ");
strcpy(phys_dim[edfsignals], "lpm ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" EJT\""))
{
strcpy(labels[edfsignals], "EJT ");
strcpy(phys_dim[edfsignals], "s ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" TPR\""))
{
strcpy(labels[edfsignals], "TPR ");
strcpy(phys_dim[edfsignals], "MU ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" Artifact\""))
{
strcpy(labels[edfsignals], "Artifact ");
strcpy(phys_dim[edfsignals], "_TPSROD2");
strcpy(phys_min[edfsignals], "0 ");
strcpy(phys_max[edfsignals], "10000000");
sensitivity[edfsignals] = 0.0063488;
ok = 1;
}
if(!strcmp(line, "\" Zao\""))
{
strcpy(labels[edfsignals], "Zao ");
strcpy(phys_dim[edfsignals], "mMU ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" Cwk\""))
{
strcpy(labels[edfsignals], "Cwk ");
strcpy(phys_dim[edfsignals], "MU ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "\" Height\""))
{
strcpy(labels[edfsignals], "Height ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!ok)
{
snprintf(txt_string, 2048, "Found unknown label/signal: %s", line);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
edfsignals++;
i = 0;
}
if(temp==separator)
{
continue;
}
line[i++] = temp;
}
if(!edfsignals)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There are no labels/signals.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
p = sprintf(patientname, "%s", PatientnameLineEdit->text().toLatin1().data());
latin1_to_ascii(patientname, p);
for( ; p<80; p++)
{
patientname[p] = ' ';
}
patientname[80] = 0;
p = sprintf(recording, "%s", RecordingLineEdit->text().toLatin1().data());
latin1_to_ascii(recording, p);
for( ; p<80; p++)
{
recording[p] = ' ';
}
recording[80] = 0;
sprintf(datetime,
"%02i.%02i.%02i%02i.%02i.%02i",
StartDatetimeedit->date().day(),
StartDatetimeedit->date().month(),
StartDatetimeedit->date().year() % 100,
StartDatetimeedit->time().hour(),
StartDatetimeedit->time().minute(),
StartDatetimeedit->time().second());
datetime[16] = 0;
/***************** write header *****************************************/
get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH);
remove_extension_from_filename(outputfilename);
strcat(outputfilename, "_finometer.edf");
path[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(path, recent_savedir);
strcat(path, "/");
}
strcat(path, outputfilename);
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
enable_widgets(true);
fclose(inputfile);
return;
}
get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH);
outputfile = fopeno(path, "wb");
if(outputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for writing.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
enable_widgets(true);
fclose(inputfile);
return;
}
fprintf(outputfile, "0 ");
fprintf(outputfile, "%s", patientname);
fprintf(outputfile, "%s", recording);
fprintf(outputfile, "%s", datetime);
fprintf(outputfile, "%-8i", 256 * edfsignals + 256);
fprintf(outputfile, " ");
fprintf(outputfile, "-1 ");
fprintf(outputfile, "0.01 ");
fprintf(outputfile, "%-4i", edfsignals);
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", labels[i]);
}
for(i=0; i<(80*edfsignals); i++)
{
fputc(' ', outputfile);
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", phys_dim[i]);
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", phys_min[i]);
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", phys_max[i]);
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "-31744 ");
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "31744 ");
}
for(i=0; i<(80*edfsignals); i++)
{
fputc(' ', outputfile);
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "1 ");
}
for(i=0; i<(32*edfsignals); i++)
{
fputc(' ', outputfile);
}
/***************** start conversion **************************************/
rewind(inputfile);
for(i=0; ; )
{
temp = fgetc(inputfile);
if(temp==EOF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (8).");
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
if(temp=='\n') i++;
if(i>1) break;
}
QApplication::setOverrideCursor(Qt::WaitCursor);
for(k=0; k<10; k++) qApp->processEvents();
i = 0;
column = 0;
datarecords = 0;
str_start = 0;
line_nr = 2;
while(1)
{
temp = fgetc(inputfile);
if(temp==EOF)
{
for(k=0; k<edfsignals; k++)
{
temp = (int)(new_value[k] * sensitivity[k]);
if(temp>31744) temp = 31744;
if(temp<-31744) temp = -31744;
var.two = (short)temp;
fputc(var.one[0], outputfile);
fputc(var.one[1], outputfile);
}
datarecords++;
break;
}
line[i] = temp;
/**************************************/
if(line[i]==',')
{
line[i] = '.';
}
if((line[i]==separator)||(line[i]=='\n'))
{
if(column)
{
new_value[column-1] = atof(line + str_start);
}
else
{
new_smpl_time = (int)(atof(line + str_start) * 100.0);
}
if(line[i]=='\n')
{
/**************************************/
line_nr++;
if(column!=edfsignals)
{
QApplication::restoreOverrideCursor();
snprintf(txt_string, 2048, "Number of separators in line %i is wrong.", line_nr);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
timestep = new_smpl_time - datarecords;
if(timestep<=0)
{
QApplication::restoreOverrideCursor();
snprintf(txt_string, 2048, "Timestep <= 0 in line %i.", line_nr);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
for(j=0; j<timestep; j++)
{
for(k=0; k<edfsignals; k++)
{
temp = (int)((old_value[k] + ((new_value[k] - old_value[k]) * ((double)j / (double)timestep))) * sensitivity[k]);
if(temp>31744) temp = 31744;
if(temp<-31744) temp = -31744;
var.two = (short)temp;
fputc(var.one[0], outputfile);
fputc(var.one[1], outputfile);
}
datarecords++;
}
for(j=0; j<edfsignals; j++)
{
old_value[j] = new_value[j];
}
/**************************************/
str_start = 0;
i = 0;
column = 0;
continue;
}
str_start = i + 1;
column++;
}
/**************************************/
i++;
if(i>2046)
{
QApplication::restoreOverrideCursor();
snprintf(txt_string, 2048, "Line %i is too long.", line_nr);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
}
QApplication::restoreOverrideCursor();
fseeko(outputfile, 236LL, SEEK_SET);
fprintf(outputfile, "%-8i", datarecords);
if(fclose(outputfile))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while closing outputfile.");
messagewindow.exec();
enable_widgets(true);
fclose(inputfile);
return;
}
if(fclose(inputfile))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while closing inputfile.");
messagewindow.exec();
}
snprintf(txt_string, 2048, "Done, EDF file is located at %s", path);
QMessageBox messagewindow(QMessageBox::Information, "Ready", txt_string);
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
enable_widgets(true);
}
void ColorOptions::loadColorSchemaButtonClicked()
{
char path[MAX_PATH_LENGTH],
scratchpad[2048],
*result;
struct xml_handle *xml_hdl;
strcpy(path, QFileDialog::getOpenFileName(0, "Load colorschema", QString::fromLocal8Bit(mainwindow->recent_colordir), "Montage files (*.color *.COLOR)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_colordir, path, MAX_PATH_LENGTH);
xml_hdl = xml_get_handle(path);
if(xml_hdl==NULL)
{
sprintf(scratchpad, "Can not open colorschema:\n%s", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(scratchpad));
messagewindow.exec();
return;
}
if(strcmp(xml_hdl->elementname, PROGRAM_NAME "_colorschema"))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this colorschema.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
mainwindow->get_rgbcolor_settings(xml_hdl, "backgroundcolor", 0, &mainwindow->maincurve->backgroundcolor);
mainwindow->get_rgbcolor_settings(xml_hdl, "small_ruler_color", 0, &mainwindow->maincurve->small_ruler_color);
mainwindow->get_rgbcolor_settings(xml_hdl, "big_ruler_color", 0, &mainwindow->maincurve->big_ruler_color);
mainwindow->get_rgbcolor_settings(xml_hdl, "mouse_rect_color", 0, &mainwindow->maincurve->mouse_rect_color);
mainwindow->get_rgbcolor_settings(xml_hdl, "text_color", 0, &mainwindow->maincurve->text_color);
mainwindow->get_rgbcolor_settings(xml_hdl, "baseline_color", 0, &mainwindow->maincurve->baseline_color);
mainwindow->get_rgbcolor_settings(xml_hdl, "annot_marker_color", 0, &mainwindow->maincurve->annot_marker_color);
if(xml_goto_nth_element_inside(xml_hdl, "signal_color", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->maincurve->signal_color = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "floating_ruler_color", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->maincurve->floating_ruler_color = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "blackwhite_printing", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->maincurve->blackwhite_printing = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "show_annot_markers", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->show_annot_markers = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "show_baselines", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->show_baselines = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "clip_to_pane", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->clip_to_pane = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "crosshair_1_color", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->maincurve->crosshair_1.color = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "crosshair_2_color", 0))
{
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
mainwindow->maincurve->crosshair_2.color = atoi(result);
free(result);
xml_close(xml_hdl);
update_interface();
}
void UI_RAW2EDFapp::gobuttonpressed()
{
int i, j, k, r,
hdl,
chns,
sf,
*buf,
datarecords,
tmp,
straightbinary,
samplesize,
skipblocksize,
skipbytes,
skipblockcntr,
bytecntr;
char str[256],
path[MAX_PATH_LENGTH];
double phys_max;
long long d_offset;
FILE *inputfile;
sf = SamplefreqSpinbox->value();
raw2edf_var->sf = sf;
chns = SignalsSpinbox->value();
raw2edf_var->chns = chns;
phys_max = PhysicalMaximumSpinbox->value();
raw2edf_var->phys_max = phys_max;
straightbinary = EncodingCombobox->currentIndex();
raw2edf_var->straightbinary = straightbinary;
samplesize = SampleSizeSpinbox->value();
raw2edf_var->samplesize = samplesize;
d_offset = OffsetSpinbox->value();
raw2edf_var->offset = d_offset;
skipblocksize = skipblocksizeSpinbox->value();
raw2edf_var->skipblocksize = skipblocksize;
skipbytes = skipbytesSpinbox->value();
raw2edf_var->skipbytes = skipbytes;
strcpy(raw2edf_var->phys_dim, PhysicalDimensionLineEdit->text().toLatin1().data());
remove_leading_spaces(raw2edf_var->phys_dim);
remove_trailing_spaces(raw2edf_var->phys_dim);
if(!(strlen(PatientnameLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subjectname.");
messagewindow.exec();
return;
}
if(!(strlen(RecordingLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recording description.");
messagewindow.exec();
return;
}
strcpy(path, QFileDialog::getOpenFileName(0, "Open data file", QString::fromLocal8Bit(recent_opendir), "All files (*)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
inputfile = fopeno(path, "rb");
if(inputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for reading.");
messagewindow.exec();
return;
}
remove_extension_from_filename(path);
strcat(path, ".edf");
hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl<0)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for writing.\nedfopen_file_writeonly()");
messagewindow.exec();
fclose(inputfile);
return;
}
for(i=0; i<chns; i++)
{
if(edf_set_samplefrequency(hdl, i, sf))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_samplefrequency()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
if(samplesize == 2)
{
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 32767))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_maximum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -32768))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_minimum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
}
if(samplesize == 1)
{
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 255))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_maximum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -256))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_minimum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_maximum(hdl, i, phys_max))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_maximum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_minimum(hdl, i, -phys_max))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_minimum()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_dimension(hdl, i, raw2edf_var->phys_dim))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_dimension()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
for(i=0; i<chns; i++)
{
sprintf(str, "ch. %i", i + 1);
if(edf_set_label(hdl, i, str))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_label()");
messagewindow.exec();
fclose(inputfile);
return;
}
}
if(edf_set_startdatetime(hdl, StartDatetimeedit->date().year(), StartDatetimeedit->date().month(), StartDatetimeedit->date().day(),
StartDatetimeedit->time().hour(), StartDatetimeedit->time().minute(), StartDatetimeedit->time().second()))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_startdatetime()");
messagewindow.exec();
fclose(inputfile);
edfclose_file(hdl);
return;
}
buf = (int *)malloc(sizeof(int) * sf * chns);
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "malloc()");
messagewindow.exec();
fclose(inputfile);
edfclose_file(hdl);
return;
}
// printf("samplefrequency: %14i Hz\n"
// "channels: %14i\n"
// "physical maximum: %14.6f uV\n"
// "straightbinary: %14i\n"
// "samplesize: %14i byte(s)\n"
// "offset: %14lli bytes\n"
// "skip blocksize: %14i bytes\n"
// "skip bytes: %14i bytes\n\n",
// sf,
// chns,
// phys_max,
// straightbinary,
// samplesize,
// d_offset,
// skipblocksize,
// skipbytes);
fseeko(inputfile, d_offset, SEEK_SET);
datarecords = 0;
union{
int one[1];
signed short two[2];
char four[4];
} var;
skipblockcntr = 0;
bytecntr = 0;
while(1)
{
for(j=0; j<sf; j++)
{
for(k=0; k<chns; k++)
{
// tmp = fgetc(inputfile);
// if(tmp == EOF)
// {
// edfclose_file(hdl);
// fclose(inputfile);
// free(buf);
// return;
// }
//
// tmp += (fgetc(inputfile) * 256);
//
// buf[j + (k * sf)] = tmp - 32768;
if(samplesize == 2)
{
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
bytecntr++;
// printf("1: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
if(skipblocksize)
{
if(++skipblockcntr > skipblocksize)
{
for(r=0; r<skipbytes; r++)
{
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
// bytecntr++;
// printf("2: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
}
skipblockcntr = 1;
}
}
var.four[0] = tmp;
}
if(samplesize == 1)
{
var.four[0] = 0;
}
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
// bytecntr++;
// printf("3: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
if(skipblocksize)
{
if(++skipblockcntr > skipblocksize)
{
for(r=0; r<skipbytes; r++)
{
tmp = fgetc(inputfile);
if(tmp == EOF)
{
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
bytecntr++;
// printf("4: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr);
}
skipblockcntr = 1;
}
}
var.four[1] = tmp;
if(straightbinary)
{
var.two[0] -= 32768;
}
if(samplesize == 1)
{
var.two[0] >>= 8;
}
buf[j + (k * sf)] = var.two[0];
}
}
if(edf_blockwrite_digital_samples(hdl, buf))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Write error during conversion.\nedf_blockwrite_digital_samples()");
messagewindow.exec();
edfclose_file(hdl);
fclose(inputfile);
free(buf);
return;
}
datarecords++;
// if(datarecords == 1) break;
}
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_MIT2EDFwindow::SelectFileButton()
{
FILE *header_inputfile=NULL,
*data_inputfile=NULL,
*annot_inputfile=NULL;
int i, j, p, len, hdl, *buf;
char header_filename[MAX_PATH_LENGTH],
txt_string[2048],
edf_filename[MAX_PATH_LENGTH],
data_filename[MAX_PATH_LENGTH],
annot_filename[MAX_PATH_LENGTH],
filename_x[MAX_PATH_LENGTH],
scratchpad[4096],
*charpntr;
unsigned char a_buf[128];
long long filesize;
pushButton1->setEnabled(false);
strcpy(header_filename, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "MIT header files (*.hea *.HEA)").toLocal8Bit().data());
if(!strcmp(header_filename, ""))
{
pushButton1->setEnabled(true);
return;
}
get_directory_from_path(recent_opendir, header_filename, MAX_PATH_LENGTH);
header_inputfile = fopeno(header_filename, "rb");
if(header_inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.\n", header_filename);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
return;
}
get_filename_from_path(filename_x, header_filename, MAX_PATH_LENGTH);
snprintf(txt_string, 2048, "Read file: %s", filename_x);
textEdit1->append(QString::fromLocal8Bit(txt_string));
remove_extension_from_filename(filename_x);
charpntr = fgets(scratchpad, 4095, header_inputfile);
if(charpntr == NULL)
{
textEdit1->append("Can not read header file. (error 1)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
len = strlen(charpntr);
if(len < 6)
{
textEdit1->append("Can not read header file. (error 2)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
for(i=0; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == len)
{
textEdit1->append("Can not read header file. (error 3)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(strcmp(charpntr, filename_x))
{
textEdit1->append("Can not read header file. (error 4)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
textEdit1->append("Can not read header file. (error 5)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.chns = atoi(charpntr + p);
if(mit_hdr.chns < 1)
{
textEdit1->append("Error, number of signals is less than one. (error 6)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(mit_hdr.chns > MAXSIGNALS)
{
textEdit1->append("Error, Too many signals in header. (error 7)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
textEdit1->append("Can not read header file. (error 8)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.sf = atoi(charpntr + p);
if(mit_hdr.sf < 1)
{
textEdit1->append("Error, samplefrequency is less than 1 Hz. (error 9)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(mit_hdr.sf > 100000)
{
textEdit1->append("Error, samplefrequency is more than 100000 Hz. (error 10)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.smp_period = 1000000000LL / mit_hdr.sf;
strcat(filename_x, ".dat");
for(j=0; j<mit_hdr.chns; j++)
{
mit_hdr.adc_gain[j] = 200.0;
mit_hdr.adc_resolution[j] = 12;
mit_hdr.adc_zero[j] = 0;
mit_hdr.init_val[j] = 0;
sprintf(mit_hdr.label[j], "chan. %i", j + 1);
charpntr = fgets(scratchpad, 4095, header_inputfile);
if(charpntr == NULL)
{
textEdit1->append("Can not read header file. (error 11)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
len = strlen(charpntr);
if(len < 6)
{
textEdit1->append("Can not read header file. (error 12)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
for(i=0; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == len)
{
textEdit1->append("Can not read header file. (error 13)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(strcmp(charpntr, filename_x))
{
textEdit1->append("Error, filenames are different. (error 14)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == len)
{
textEdit1->append("Can not read header file. (error 15)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.format[j] = atoi(charpntr + p);
if((mit_hdr.format[j] != 212) && (mit_hdr.format[j] != 16))
{
snprintf(txt_string, 2048, "Error, unsupported format: %i (error 16)\n", mit_hdr.format[j]);
textEdit1->append(txt_string);
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
if(j>0)
{
if(mit_hdr.format[j] != mit_hdr.format[0])
{
textEdit1->append("Error, different formats in the same file. (error 17)\n");
fclose(header_inputfile);
pushButton1->setEnabled(true);
return;
}
}
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.adc_gain[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.adc_resolution[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.adc_zero[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
mit_hdr.init_val[j] = atoi(charpntr + p);
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
// skip
p = ++i;
for(; i<len; i++)
{
if(charpntr[i] == ' ')
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
// skip
p = ++i;
for(; i<len; i++)
{
if((charpntr[i] == '\n') || (charpntr[i] == '\r'))
{
charpntr[i] = 0;
break;
}
}
if(i == p)
{
continue;
}
strncpy(mit_hdr.label[j], charpntr + p, 16);
mit_hdr.label[j][16] = 0;
}
fclose(header_inputfile);
strcpy(data_filename, header_filename);
remove_extension_from_filename(data_filename);
strcpy(edf_filename, data_filename);
strcpy(annot_filename, data_filename);
strcat(data_filename, ".dat");
strcat(edf_filename, ".edf");
strcat(annot_filename, ".atr");
data_inputfile = fopeno(data_filename, "rb");
if(data_inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.\n", data_filename);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
return;
}
fseeko(data_inputfile, 0LL, SEEK_END);
filesize = ftello(data_inputfile);
if(filesize < (mit_hdr.chns * mit_hdr.sf * 45 / 10))
{
textEdit1->append("Error, .dat filesize is too small.\n");
fclose(data_inputfile);
pushButton1->setEnabled(true);
return;
}
mit_hdr.sf_div = 1;
mit_hdr.sf_block = mit_hdr.sf;
if(!(mit_hdr.sf % 10))
{
mit_hdr.sf_div = 10;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
else if(!(mit_hdr.sf % 8))
{
mit_hdr.sf_div = 8;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
else if(!(mit_hdr.sf % 4))
{
mit_hdr.sf_div = 4;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
else if(!(mit_hdr.sf % 2))
{
mit_hdr.sf_div = 2;
mit_hdr.sf_block /= mit_hdr.sf_div;
}
hdl = edfopen_file_writeonly(edf_filename, EDFLIB_FILETYPE_EDFPLUS, mit_hdr.chns);
if(hdl<0)
{
snprintf(txt_string, 2048, "Can not open file %s for writing.\n", edf_filename);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fclose(data_inputfile);
pushButton1->setEnabled(true);
return;
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_samplefrequency(hdl, i, mit_hdr.sf_block))
{
textEdit1->append("Error: edf_set_samplefrequency()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -32768))
{
textEdit1->append("Error: edf_set_digital_minimum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 32767))
{
textEdit1->append("Error: edf_set_digital_maximum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_label(hdl, i, mit_hdr.label[i]))
{
textEdit1->append("Error: edf_set_label()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.chns; i++)
{
if(edf_set_physical_dimension(hdl, i, "uV"))
{
textEdit1->append("Error: edf_set_physical_dimension()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
if(edf_set_physical_maximum(hdl, i, (double)((32767 - mit_hdr.adc_zero[i]) * 1000) / mit_hdr.adc_gain[i]))
{
textEdit1->append("Error: edf_set_physical_maximum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
if(edf_set_physical_minimum(hdl, i, (double)((-32768 - mit_hdr.adc_zero[i]) * 1000) / mit_hdr.adc_gain[i]))
{
textEdit1->append("Error: edf_set_physical_minimum()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
}
if(edf_set_datarecord_duration(hdl, 100000 / mit_hdr.sf_div))
{
textEdit1->append("Error: edf_set_datarecord_duration()\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
buf = (int *)malloc(mit_hdr.sf_block * mit_hdr.chns * sizeof(int));
if(buf == NULL)
{
textEdit1->append("Malloc() error (buf)\n");
fclose(data_inputfile);
edfclose_file(hdl);
pushButton1->setEnabled(true);
return;
}
/////////////////// Start conversion //////////////////////////////////////////
int k, blocks, tmp1, tmp2;
fseeko(data_inputfile, 0LL, SEEK_SET);
blocks = filesize / (mit_hdr.sf_block * mit_hdr.chns);
QProgressDialog progress("Converting digitized signals ...", "Abort", 0, blocks);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
if(mit_hdr.format[0] == 212)
{
blocks *= 10;
blocks /= 15;
progress.setMaximum(blocks);
for(k=0; k<blocks; k++)
{
if(!(k % 100))
{
progress.setValue(k);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
textEdit1->append("Conversion aborted by user.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.sf_block; i++)
{
for(j=0; j<mit_hdr.chns; j++)
{
if(j % 2)
{
tmp1 = fgetc(data_inputfile);
tmp2 = fgetc(data_inputfile);
if(tmp2 == EOF)
{
goto OUT;
}
buf[j * mit_hdr.sf_block + i] = (tmp1 & 0xf0) << 4;
buf[j * mit_hdr.sf_block + i] += tmp2;
if(buf[j * mit_hdr.sf_block + i] & 0x800)
{
buf[j * mit_hdr.sf_block + i] |= 0xfffff000;
}
}
else
{
tmp1 = fgetc(data_inputfile);
tmp2 = fgetc(data_inputfile);
buf[j * mit_hdr.sf_block + i] = (tmp2 & 0x0f) << 8;
buf[j * mit_hdr.sf_block + i] += tmp1;
if(buf[j * mit_hdr.sf_block + i] & 0x800)
{
buf[j * mit_hdr.sf_block + i] |= 0xfffff000;
}
fseeko(data_inputfile, -1LL, SEEK_CUR);
}
}
}
if(edf_blockwrite_digital_samples(hdl, buf))
{
progress.reset();
textEdit1->append("A write error occurred during conversion.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
}
if(mit_hdr.format[0] == 16)
{
blocks /= 2;
progress.setMaximum(blocks);
for(k=0; k<blocks; k++)
{
if(!(k % 100))
{
progress.setValue(k);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
textEdit1->append("Conversion aborted by user.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
for(i=0; i<mit_hdr.sf_block; i++)
{
for(j=0; j<mit_hdr.chns; j++)
{
tmp1 = fgetc(data_inputfile);
if(tmp1 == EOF)
{
goto OUT;
}
tmp1 += (fgetc(data_inputfile) << 8);
if(tmp1 & 0x8000)
{
tmp1 |= 0xffff0000;
}
buf[j * mit_hdr.sf_block + i] = tmp1;
}
}
if(edf_blockwrite_digital_samples(hdl, buf))
{
progress.reset();
textEdit1->append("A write error occurred during conversion.\n");
fclose(data_inputfile);
edfclose_file(hdl);
free(buf);
pushButton1->setEnabled(true);
return;
}
}
}
OUT:
progress.reset();
qApp->processEvents();
/////////////////// End conversion //////////////////////////////////////////
fclose(data_inputfile);
free(buf);
int annot_code, tc=0, skip;
long long bytes_read;
get_filename_from_path(filename_x, annot_filename, MAX_PATH_LENGTH);
annot_inputfile = fopeno(annot_filename, "rb");
if(annot_inputfile==NULL)
{
remove_extension_from_filename(annot_filename);
strcat(annot_filename, ".ari");
annot_inputfile = fopeno(annot_filename, "rb");
}
if(annot_inputfile==NULL)
{
remove_extension_from_filename(annot_filename);
strcat(annot_filename, ".ecg");
annot_inputfile = fopeno(annot_filename, "rb");
}
if(annot_inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.\n"
"Annotations can not be included.", filename_x);
textEdit1->append(QString::fromLocal8Bit(txt_string));
}
else
{
snprintf(txt_string, 2048, "Read file: %s", filename_x);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fseeko(annot_inputfile, 0LL, SEEK_END);
filesize = ftello(annot_inputfile);
progress.setLabelText("Converting annotations ...");
progress.setMinimum(0);
progress.setMaximum(filesize);
fseeko(annot_inputfile, 0LL, SEEK_SET);
for(bytes_read=0LL; bytes_read < filesize; bytes_read += 2LL)
{
if(!(bytes_read % 100))
{
progress.setValue(bytes_read);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
textEdit1->append("Conversion aborted by user.\n");
break;
}
}
skip = 0;
if(fread(a_buf, 2, 1, annot_inputfile) != 1)
{
break;
}
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
if(*((unsigned short *)a_buf) == 0) // end of file
{
break;
}
annot_code = a_buf[1] >> 2;
if(annot_code == 59)
{
if(fread(a_buf, 4, 1, annot_inputfile) != 1)
{
break;
}
tc += (*((unsigned short *)a_buf) << 16);
tc += *((unsigned short *)(a_buf + 2));
}
else if(annot_code == 63)
{
skip = *((unsigned short *)a_buf) & 0x3ff;
if(skip % 2) skip++;
}
else if((annot_code >= 0) && (annot_code <= ACMAX))
{
tc += *((unsigned short *)a_buf) & 0x3ff;
#pragma GCC diagnostic warning "-Wstrict-aliasing"
if(annot_code < 42)
{
edfwrite_annotation_latin1(hdl, ((long long)tc * mit_hdr.smp_period) / 100000LL, -1, annotdescrlist[annot_code]);
}
else
{
edfwrite_annotation_latin1(hdl, ((long long)tc * mit_hdr.smp_period) / 100000LL, -1, "user-defined");
}
}
if(skip)
{
if(fseek(annot_inputfile, skip, SEEK_CUR) < 0)
{
break;
}
bytes_read += skip;
}
}
fclose(annot_inputfile);
}
progress.reset();
edfclose_file(hdl);
textEdit1->append("Ready.\n");
pushButton1->setEnabled(true);
}
// Next parts of code are tested with VLC media player 2.1.2 and later with 2.1.5 Rincewind on Linux.
// On windows it's disabled because the console interface of VLC on windows is broken.
// Once they (videolan.org) has fixed this, we can test it and hopefully enable it on windows too.
void UI_Mainwindow::start_stop_video()
{
if(video_player->status != VIDEO_STATUS_STOPPED)
{
stop_video_generic();
return;
}
if(playback_realtime_active)
{
return;
}
if(live_stream_active)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open a video during a live stream.");
messagewindow.exec();
return;
}
if(video_player->status != VIDEO_STATUS_STOPPED)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There is already a video running.");
messagewindow.exec();
return;
}
if(signalcomps < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Put some signals on the screen first.");
messagewindow.exec();
return;
}
if(annot_editor_active)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Close the annotation editor first.");
messagewindow.exec();
return;
}
strcpy(videopath, QFileDialog::getOpenFileName(this, "Select video", QString::fromLocal8Bit(recent_opendir),
"Video files (*.ogv *.OGV *.ogg *.OGG *.mkv *.MKV *.avi *.AVI"
" *.mp4 *.MP4 *.mpeg *.MPEG *.mpg *.MPG *.wmv *.WMV)").toLocal8Bit().data());
if(!strcmp(videopath, ""))
{
return;
}
get_directory_from_path(recent_opendir, videopath, MAX_PATH_LENGTH);
video_player->utc_starttime = parse_date_time_stamp(videopath);
if(video_player->utc_starttime < 0LL)
{
QMessageBox messagewindow(QMessageBox::Warning, "Warning", "Unable to get startdate and starttime from video filename.\n"
" \nAssume video starttime equals EDF/BDF starttime?\n ");
messagewindow.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
messagewindow.setDefaultButton(QMessageBox::Yes);
if(messagewindow.exec() == QMessageBox::Cancel) return;
video_player->utc_starttime = edfheaderlist[sel_viewtime]->utc_starttime;
}
video_player->stop_det_counter = 0;
video_player->fpos = 0;
video_player->starttime_diff = (int)(edfheaderlist[sel_viewtime]->utc_starttime - video_player->utc_starttime);
if((edfheaderlist[sel_viewtime]->utc_starttime + edfheaderlist[sel_viewtime]->recording_len_sec) < video_player->utc_starttime)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The video registration and the EDF/BDF registration do not overlap (in time)!");
messagewindow.exec();
return;
}
if((video_player->utc_starttime + 259200LL) < edfheaderlist[sel_viewtime]->utc_starttime)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The video registration and the EDF/BDF registration do not overlap (in time)!");
messagewindow.exec();
return;
}
video_process = new QProcess(this);
#ifdef Q_OS_WIN32
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("PATH", env.value("PATH") + ";C:\\Program Files\\VideoLAN\\VLC");
video_process->setProcessEnvironment(env);
#endif
connect(video_process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(video_process_error(QProcess::ProcessError)));
QStringList arguments;
arguments << "--video-on-top" << "-I" << "rc";
video_process->start("vlc", arguments);
if(video_process->waitForStarted(5000) == false)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unable to start VLC mediaplayer.\n"
"Check your installation of VLC.\n"
"Also, check if VLC is present in the PATH evironment variable.");
messagewindow.exec();
return;
}
#ifdef DEBUG_VIDEOPLAYER
debug_vpr = fopen("debug_vpr.txt", "wb");
#endif
video_player->status = VIDEO_STATUS_STARTUP_1;
video_player->poll_timer = 100;
video_player->cntdwn_timer = 5000;
video_poll_timer->start(video_player->poll_timer);
video_act->setText("Stop video");
}
void UI_ViewMontagewindow::SelectButtonClicked()
{
int signalcomps_read=0,
signals_read,
signal_cnt,
filters_read,
color,
filter_cnt=0,
spike_filter_cnt=0,
ravg_filter_cnt=0,
fidfilter_cnt=0,
islpf,
factor[MAXSIGNALS],
signalcomps,
screen_offset,
order,
model,
type,
size,
polarity=1,
holdoff=100;
char result[XML_STRBUFLEN],
composition_txt[2048],
label[256];
double frequency,
frequency2,
voltpercm,
ripple,
timescale,
d_tmp,
velocity;
QStandardItem *parentItem,
*signalItem,
*filterItem;
struct xml_handle *xml_hdl;
strcpy(mtg_path, QFileDialog::getOpenFileName(0, "Choose a montage", QString::fromLocal8Bit(mtg_dir), "Montage files (*.mtg *.MTG)").toLocal8Bit().data());
if(!strcmp(mtg_path, ""))
{
return;
}
get_directory_from_path(mtg_dir, mtg_path, MAX_PATH_LENGTH);
xml_hdl = xml_get_handle(mtg_path);
if(xml_hdl==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for reading.");
messagewindow.exec();
return;
}
if(strcmp(xml_hdl->elementname[xml_hdl->level], PROGRAM_NAME "_montage"))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
ViewMontageDialog->setWindowTitle(mtg_path);
t_model->clear();
parentItem = t_model->invisibleRootItem();
for(signalcomps=0; ; signalcomps++)
{
xml_goto_root(xml_hdl);
signals_read = 0;
filter_cnt = 0;
ravg_filter_cnt = 0;
fidfilter_cnt = 0;
if(xml_goto_nth_element_inside(xml_hdl, "signalcomposition", signalcomps_read))
{
break;
}
if(xml_goto_nth_element_inside(xml_hdl, "num_of_signals", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
signal_cnt = atoi(result);
if((signal_cnt<1)||(signal_cnt>256))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "voltpercm", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
voltpercm = atof(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "screen_offset", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
screen_offset = atoi(result);
xml_go_up(xml_hdl);
if(!(xml_goto_nth_element_inside(xml_hdl, "polarity", 0)))
{
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
polarity = atoi(result);
if(polarity != -1)
{
polarity = 1;
}
xml_go_up(xml_hdl);
}
if(xml_goto_nth_element_inside(xml_hdl, "color", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
color = atoi(result);
xml_go_up(xml_hdl);
if(!(xml_goto_nth_element_inside(xml_hdl, "spike_filter_cnt", 0)))
{
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
spike_filter_cnt = atoi(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "filter_cnt", 0)))
{
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
filter_cnt = atoi(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "ravg_filter_cnt", 0)))
{
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
ravg_filter_cnt = atoi(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "fidfilter_cnt", 0)))
{
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
fidfilter_cnt = atoi(result);
xml_go_up(xml_hdl);
}
composition_txt[0] = 0;
if(!(xml_goto_nth_element_inside(xml_hdl, "alias", 0)))
{
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(result[0] != 0)
{
strcpy(composition_txt, "alias: ");
strcat(composition_txt, result);
strcat(composition_txt, " ");
}
xml_go_up(xml_hdl);
}
for(signals_read=0; signals_read<signal_cnt; signals_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "signal", signals_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "factor", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
factor[signals_read] = atoi(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "label", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
strcpy(label, result);
sprintf(composition_txt + strlen(composition_txt), "%+ix %s", factor[signals_read], label);
remove_trailing_spaces(composition_txt);
strcat(composition_txt, " ");
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
if(polarity == -1)
{
strcat(composition_txt, "inverted: yes");
}
signalItem = new QStandardItem(composition_txt);
parentItem->appendRow(signalItem);
sprintf(composition_txt, "amplitude: %f", voltpercm);
remove_trailing_zeros(composition_txt);
sprintf(composition_txt + strlen(composition_txt), "/cm offset: %f", (double)screen_offset * mainwindow->pixelsizefactor * voltpercm);
remove_trailing_zeros(composition_txt);
strcat(composition_txt, " color: ");
switch(color)
{
case Qt::white : strcat(composition_txt, "white");
break;
case Qt::black : strcat(composition_txt, "black");
break;
case Qt::red : strcat(composition_txt, "red");
break;
case Qt::darkRed : strcat(composition_txt, "dark red");
break;
case Qt::green : strcat(composition_txt, "green");
break;
case Qt::darkGreen : strcat(composition_txt, "dark green");
break;
case Qt::blue : strcat(composition_txt, "blue");
break;
case Qt::darkBlue : strcat(composition_txt, "dark blue");
break;
case Qt::cyan : strcat(composition_txt, "cyan");
break;
case Qt::darkCyan : strcat(composition_txt, "dark cyan");
break;
case Qt::magenta : strcat(composition_txt, "magenta");
break;
case Qt::darkMagenta : strcat(composition_txt, "dark magenta");
break;
case Qt::yellow : strcat(composition_txt, "yellow");
break;
case Qt::darkYellow : strcat(composition_txt, "dark yellow");
break;
case Qt::gray : strcat(composition_txt, "gray");
break;
case Qt::darkGray : strcat(composition_txt, "dark gray");
break;
case Qt::lightGray : strcat(composition_txt, "light gray");
break;
}
signalItem->appendRow(new QStandardItem(composition_txt));
filterItem = new QStandardItem("Filters");
signalItem->appendRow(filterItem);
for(filters_read=0; filters_read<spike_filter_cnt; filters_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "spike_filter", filters_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (filter)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "velocity", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (velocity)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
velocity = atof(result);
if(velocity < 0.0001) velocity = 0.0001;
if(velocity > 10E9) velocity = 10E9;
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "holdoff", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (holdoff)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
holdoff = atoi(result);
if(holdoff < 10) holdoff = 10;
if(holdoff > 1000) holdoff = 1000;
sprintf(composition_txt, "Spike: Velocity: %.8f", velocity);
remove_trailing_zeros(composition_txt);
sprintf(composition_txt + strlen(composition_txt), " Hold-off: %i milli-Sec.", holdoff);
filterItem->appendRow(new QStandardItem(composition_txt));
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
for(filters_read=0; filters_read<filter_cnt; filters_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "filter", filters_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (filter)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "LPF", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (LPF)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
islpf = atoi(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "frequency", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (frequency)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
frequency = atof(result);
if(islpf)
{
sprintf(composition_txt, "LPF: %fHz", frequency);
}
else
{
sprintf(composition_txt, "HPF: %fHz", frequency);
}
remove_trailing_zeros(composition_txt);
filterItem->appendRow(new QStandardItem(composition_txt));
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
for(filters_read=0; filters_read<ravg_filter_cnt; filters_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "ravg_filter", filters_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (filter)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (type)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
type = atoi(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "size", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (size)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
size = atoi(result);
if(type == 0)
{
sprintf(composition_txt, "highpass moving average %ismpls", size);
}
if(type == 1)
{
sprintf(composition_txt, "lowpass moving average %ismpls", size);
}
filterItem->appendRow(new QStandardItem(composition_txt));
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
for(filters_read=0; filters_read<fidfilter_cnt; filters_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "fidfilter", filters_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (fidfilter)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (type)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
type = atoi(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "frequency", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (frequency)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
frequency = atof(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "frequency2", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (frequency2)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
frequency2 = atof(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "ripple", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (ripple)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
ripple = atof(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "order", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (order)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
order = atoi(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "model", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (model)");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
model = atoi(result);
if(type == 0)
{
if(model == 0)
{
sprintf(composition_txt, "highpass Butterworth %fHz %ith order ", frequency, order);
}
if(model == 1)
{
sprintf(composition_txt, "highpass Chebyshev %fHz %ith order %fdB ripple ", frequency, order, ripple);
}
if(model == 2)
{
sprintf(composition_txt, "highpass Bessel %fHz %ith order ", frequency, order);
}
}
if(type == 1)
{
if(model == 0)
{
sprintf(composition_txt, "lowpass Butterworth %fHz %ith order ", frequency, order);
}
if(model == 1)
{
sprintf(composition_txt, "lowpass Chebyshev %fHz %ith order %fdB ripple ", frequency, order, ripple);
}
if(model == 2)
{
sprintf(composition_txt, "lowpass Bessel %fHz %ith order ", frequency, order);
}
}
if(type == 2)
{
sprintf(composition_txt, "notch %fHz Q-factor %i ", frequency, order);
}
if(type == 3)
{
if(model == 0)
{
sprintf(composition_txt, "bandpass Butterworth %f-%fHz %ith order ", frequency, frequency2, order);
}
if(model == 1)
{
sprintf(composition_txt, "bandpass Chebyshev %f-%fHz %ith order %fdB ripple ", frequency, frequency2, order, ripple);
}
if(model == 2)
{
sprintf(composition_txt, "bandpass Bessel %f-%fHz %ith order ", frequency, frequency2, order);
}
}
if(type == 4)
{
if(model == 0)
{
sprintf(composition_txt, "bandstop Butterworth %f-%fHz %ith order ", frequency, frequency2, order);
}
if(model == 1)
{
sprintf(composition_txt, "bandstop Chebyshev %f-%fHz %ith order %fdB ripple ", frequency, frequency2, order, ripple);
}
if(model == 2)
{
sprintf(composition_txt, "bandstop Bessel %f-%fHz %ith order ", frequency, frequency2, order);
}
}
remove_trailing_zeros(composition_txt);
filterItem->appendRow(new QStandardItem(composition_txt));
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
if(!xml_goto_nth_element_inside(xml_hdl, "ecg_filter", 0))
{
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
type = atoi(result);
if(type == 1)
{
sprintf(composition_txt, "ECG heartrate detection");
}
filterItem->appendRow(new QStandardItem(composition_txt));
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
if(!xml_goto_nth_element_inside(xml_hdl, "zratio_filter", 0))
{
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
type = atoi(result);
xml_go_up(xml_hdl);
if(type == 1)
{
if(xml_goto_nth_element_inside(xml_hdl, "crossoverfreq", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
d_tmp = atof(result);
sprintf(composition_txt, "Z-ratio cross-over frequency is %.1f", d_tmp);
}
filterItem->appendRow(new QStandardItem(composition_txt));
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
signalcomps_read++;
}
xml_goto_root(xml_hdl);
if(!(xml_goto_nth_element_inside(xml_hdl, "pagetime", 0)))
{
if(xml_get_content_of_element(xml_hdl, result, XML_STRBUFLEN))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
timescale = atof(result);
timescale /= TIME_DIMENSION;
sprintf(composition_txt, "timescale: %f seconds", timescale);
remove_trailing_zeros(composition_txt);
parentItem->appendRow(new QStandardItem(composition_txt));
}
xml_close(xml_hdl);
tree->expandAll();
}
void UI_ReduceSignalsWindow::StartConversion()
{
int i, j, k, n,
new_edfsignals,
datarecords=0,
annot_smp_per_record,
annot_recordsize,
timestamp_digits=0,
timestamp_decimals=0,
annot_len,
tallen=0,
len,
annot_cnt,
annots_per_datrec=0,
smplrt,
tmp,
val,
progress_steps,
datrecs_processed;
char *readbuf=NULL,
scratchpad[256];
long long new_starttime,
time_diff,
onset_diff,
taltime,
l_temp,
endtime=0,
l_tmp;
struct date_time_struct dts;
struct annotationblock *new_annot_list=NULL,
*root_new_annot_list=NULL,
*annot_list=NULL;
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
QProgressDialog progress("Processing file...", "Abort", 0, 1);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
pushButton3->setEnabled(false);
pushButton4->setEnabled(false);
pushButton5->setEnabled(false);
pushButton6->setEnabled(false);
spinBox1->setEnabled(false);
spinBox2->setEnabled(false);
spinBox3->setEnabled(false);
spinBox4->setEnabled(false);
radioButton1->setEnabled(false);
radioButton2->setEnabled(false);
label2->setEnabled(false);
label3->setEnabled(false);
if(edfhdr==NULL)
{
return;
}
if(file_num < 0)
{
return;
}
new_edfsignals = 0;
annot_smp_per_record = 0;
annot_cnt = 0;
aa_filter_order = spinBox4->value() - 1;
time_diff = (long long)(spinBox1->value() - 1) * edfhdr->long_data_record_duration;
taltime = (time_diff + edfhdr->starttime_offset) % TIME_DIMENSION;
endtime = (long long)(spinBox2->value() - (spinBox1->value() - 1)) * edfhdr->long_data_record_duration + taltime;
for(i=0; i<edfhdr->edfsignals; i++)
{
if(!edfhdr->edfparam[i].annotation)
{
if(((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->checkState()==Qt::Checked)
{
signalslist[new_edfsignals] = i;
dividerlist[new_edfsignals] = ((QComboBox *)(SignalsTablewidget->cellWidget(i, 1)))->itemData(((QComboBox *)(SignalsTablewidget->cellWidget(i, 1)))->currentIndex()).toInt();
new_edfsignals++;
}
}
}
datarecords = spinBox2->value() - spinBox1->value() + 1;
if(edfhdr->edfplus || edfhdr->bdfplus)
{
timestamp_decimals = get_tal_timestamp_decimal_cnt(edfhdr);
if(timestamp_decimals < 0)
{
showpopupmessage("Error", "Internal error, get_tal_timestamp_decimal_cnt(");
goto END_1;
}
timestamp_digits = get_tal_timestamp_digit_cnt(edfhdr);
if(timestamp_digits < 0)
{
showpopupmessage("Error", "Internal error, get_tal_timestamp_digit_cnt(");
goto END_1;
}
annot_list = mainwindow->annotationlist[file_num];
while(annot_list != NULL)
{
l_temp = annot_list->onset - time_diff;
if((l_temp >= 0LL) && (l_temp <= endtime))
{
annot_cnt++;
edfplus_annotation_add_copy(&new_annot_list, annot_list);
}
annot_list = annot_list->next_annotation;
}
annot_list = new_annot_list;
root_new_annot_list = new_annot_list;
new_starttime = edfhdr->utc_starttime + ((time_diff + edfhdr->starttime_offset) / TIME_DIMENSION);
onset_diff = (new_starttime - edfhdr->utc_starttime) * TIME_DIMENSION;
while(annot_list != NULL)
{
annot_list->onset -= onset_diff;
annot_list = annot_list->next_annotation;
}
edfplus_annotation_sort(&new_annot_list);
annots_per_datrec = annot_cnt / datarecords;
if(annot_cnt % datarecords)
{
annots_per_datrec++;
}
annot_len = get_max_annotation_strlen(&new_annot_list);
if(!annot_cnt)
{
annots_per_datrec = 0;
}
annot_recordsize = (annot_len * annots_per_datrec) + timestamp_digits + timestamp_decimals + 4;
if(timestamp_decimals)
{
annot_recordsize++;
}
if(edfhdr->edf)
{
annot_smp_per_record = annot_recordsize / 2;
if(annot_recordsize % annot_smp_per_record)
{
annot_smp_per_record++;
annot_recordsize = annot_smp_per_record * 2;
}
}
else
{
annot_smp_per_record = annot_recordsize / 3;
if(annot_recordsize % annot_smp_per_record)
{
annot_smp_per_record++;
annot_recordsize = annot_smp_per_record * 3;
}
}
}
else
{
annot_smp_per_record = 0;
annot_recordsize = 0;
}
readbuf = (char *)malloc(edfhdr->recordsize);
if(readbuf==NULL)
{
showpopupmessage("Error", "Malloc error, (readbuf).");
goto END_2;
}
///////////////////////////////////////////////////////////////////
for(i=0; i<new_edfsignals; i++)
{
if(dividerlist[i] > 1)
{
for(j=0; j<aa_filter_order; j++)
{
filterlist[i][j] = create_ravg_filter(1, dividerlist[i]);
if(filterlist[i][j] == NULL)
{
showpopupmessage("Error", "Malloc error, (create_ravg_filter()).");
goto END_3;
}
}
}
}
///////////////////////////////////////////////////////////////////
outputpath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(outputpath, recent_savedir);
strcat(outputpath, "/");
}
len = strlen(outputpath);
get_filename_from_path(outputpath + len, inputpath, MAX_PATH_LENGTH - len);
remove_extension_from_filename(outputpath);
if(edfhdr->edf)
{
strcat(outputpath, "_reduced.edf");
strcpy(outputpath, QFileDialog::getSaveFileName(0, "Save file", QString::fromLocal8Bit(outputpath), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
}
else
{
strcat(outputpath, "_reduced.bdf");
strcpy(outputpath, QFileDialog::getSaveFileName(0, "Save file", QString::fromLocal8Bit(outputpath), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
}
if(!strcmp(outputpath, ""))
{
goto END_3;
}
get_directory_from_path(recent_savedir, outputpath, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(outputpath))
{
showpopupmessage("Reduce signals", "Error, selected file is in use.");
goto END_3;
}
outputfile = fopeno(outputpath, "wb");
if(outputfile==NULL)
{
showpopupmessage("Error", "Can not open outputfile for writing.");
goto END_3;
}
new_starttime = edfhdr->utc_starttime + ((time_diff + edfhdr->starttime_offset) / TIME_DIMENSION);
utc_to_date_time(new_starttime, &dts);
rewind(inputfile);
if(fread(scratchpad, 168, 1, inputfile)!=1)
{
showpopupmessage("Error", "Read error (1).");
goto END_4;
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
if(scratchpad[98] != 'X')
{
sprintf(scratchpad + 98, "%02i-%s-%04i", dts.day, dts.month_str, dts.year);
scratchpad[109] = ' ';
}
}
if(fwrite(scratchpad, 168, 1, outputfile)!=1)
{
showpopupmessage("Error", "Write error (1).");
goto END_4;
}
fprintf(outputfile, "%02i.%02i.%02i%02i.%02i.%02i",
dts.day,
dts.month,
dts.year % 100,
dts.hour,
dts.minute,
dts.second);
if(edfhdr->edfplus || edfhdr->bdfplus)
{
fprintf(outputfile, "%-8i", new_edfsignals * 256 + 512);
}
else
{
fprintf(outputfile, "%-8i", new_edfsignals * 256 + 256);
}
if(edfhdr->edfplus)
{
fprintf(outputfile, "EDF+C");
for(i=0; i<39; i++)
{
fputc(' ', outputfile);
}
}
if(edfhdr->bdfplus)
{
fprintf(outputfile, "BDF+C");
for(i=0; i<39; i++)
{
fputc(' ', outputfile);
}
}
if((!edfhdr->edfplus) && (!edfhdr->bdfplus))
{
for(i=0; i<44; i++)
{
fputc(' ', outputfile);
}
}
fprintf(outputfile, "%-8i", datarecords);
snprintf(scratchpad, 256, "%f", edfhdr->data_record_duration);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
if(edfhdr->edfplus || edfhdr->bdfplus)
{
fprintf(outputfile, "%-4i", new_edfsignals + 1);
}
else
{
fprintf(outputfile, "%-4i", new_edfsignals);
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].label);
}
if(edfhdr->edfplus)
{
fprintf(outputfile, "EDF Annotations ");
}
if(edfhdr->bdfplus)
{
fprintf(outputfile, "BDF Annotations ");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].transducer);
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
for(i=0; i<80; i++)
{
fputc(' ', outputfile);
}
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].physdimension);
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
for(i=0; i<8; i++)
{
fputc(' ', outputfile);
}
}
for(i=0; i<new_edfsignals; i++)
{
snprintf(scratchpad, 256, "%f", edfhdr->edfparam[signalslist[i]].phys_min);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
fprintf(outputfile, "-1 ");
}
for(i=0; i<new_edfsignals; i++)
{
snprintf(scratchpad, 256, "%f", edfhdr->edfparam[signalslist[i]].phys_max);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
fprintf(outputfile, "1 ");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%-8i", edfhdr->edfparam[signalslist[i]].dig_min);
}
if(edfhdr->edfplus)
{
fprintf(outputfile, "-32768 ");
}
if(edfhdr->bdfplus)
{
fprintf(outputfile, "-8388608");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%-8i", edfhdr->edfparam[signalslist[i]].dig_max);
}
if(edfhdr->edfplus)
{
fprintf(outputfile, "32767 ");
}
if(edfhdr->bdfplus)
{
fprintf(outputfile, "8388607 ");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].prefilter);
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
for(i=0; i<80; i++)
{
fputc(' ', outputfile);
}
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%-8i", edfhdr->edfparam[signalslist[i]].smp_per_record / dividerlist[i]);
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
fprintf(outputfile, "%-8i", annot_smp_per_record);
}
for(i=0; i<(new_edfsignals * 32); i++)
{
fputc(' ', outputfile);
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
for(i=0; i<32; i++)
{
fputc(' ', outputfile);
}
}
///////////////////////////////////////////////////////////////////
progress.setRange(0, datarecords);
progress.setValue(0);
progress_steps = datarecords / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
fseeko(inputfile, (long long)edfhdr->hdrsize + ((long long)(spinBox1->value() - 1) * (long long)edfhdr->recordsize), SEEK_SET);
for(datrecs_processed=0; datrecs_processed<datarecords; datrecs_processed++)
{
if(!(datrecs_processed % progress_steps))
{
progress.setValue(datrecs_processed);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
goto END_4;
}
}
if(fread(readbuf, edfhdr->recordsize, 1, inputfile) != 1)
{
progress.reset();
showpopupmessage("Error", "Read error (2).");
goto END_4;
}
if(edfhdr->edf)
{
for(i=0; i<new_edfsignals; i++)
{
if(dividerlist[i] == 1)
{
smplrt = edfhdr->edfparam[signalslist[i]].smp_per_record;
for(j=0; j<smplrt; j++)
{
fputc(readbuf[edfhdr->edfparam[signalslist[i]].buf_offset + (j * 2)], outputfile);
if(fputc(readbuf[edfhdr->edfparam[signalslist[i]].buf_offset + (j * 2) + 1], outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (4).");
goto END_4;
}
}
}
else
{
smplrt = edfhdr->edfparam[signalslist[i]].smp_per_record / dividerlist[i];
for(j=0; j<smplrt; j++)
{
tmp = 0;
for(k=0; k<dividerlist[i]; k++)
{
val = *(((signed short *)(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset)) + (dividerlist[i] * j) + k);
for(n=0; n<aa_filter_order; n++)
{
val = run_ravg_filter(val, filterlist[i][n]);
}
tmp += val;
}
tmp /= dividerlist[i];
fputc(tmp & 0xff, outputfile);
if(fputc((tmp >> 8) & 0xff, outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (4).");
goto END_4;
}
}
}
}
}
else
{
for(i=0; i<new_edfsignals; i++)
{
if(dividerlist[i] == 1)
{
smplrt = edfhdr->edfparam[signalslist[i]].smp_per_record;
for(j=0; j<smplrt; j++)
{
fputc(readbuf[edfhdr->edfparam[signalslist[i]].buf_offset + (j * 3)], outputfile);
fputc(readbuf[edfhdr->edfparam[signalslist[i]].buf_offset + (j * 3) + 1], outputfile);
if(fputc(readbuf[edfhdr->edfparam[signalslist[i]].buf_offset + (j * 3) + 2], outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (4).");
goto END_4;
}
}
}
else
{
smplrt = edfhdr->edfparam[signalslist[i]].smp_per_record / dividerlist[i];
for(j=0; j<smplrt; j++)
{
l_tmp = 0LL;
for(k=0; k<dividerlist[i]; k++)
{
var.two[0] = *((unsigned short *)(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset + (dividerlist[i] * j * 3) + (k * 3)));
var.four[2] = *((unsigned char *)(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset + (dividerlist[i] * j * 3) + (k * 3) + 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
for(n=0; n<aa_filter_order; n++)
{
var.one_signed = run_ravg_filter(var.one_signed, filterlist[i][n]);
}
l_tmp += var.one_signed;
}
l_tmp /= dividerlist[i];
fputc(l_tmp & 0xff, outputfile);
fputc((l_tmp >> 8) & 0xff, outputfile);
if(fputc((l_tmp >> 16) & 0xff, outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (4).");
goto END_4;
}
}
}
}
}
if(edfhdr->edfplus || edfhdr->bdfplus)
{
switch(timestamp_decimals)
{
case 0 : tallen = fprintf(outputfile, "+%i", (int)(taltime / TIME_DIMENSION));
break;
case 1 : tallen = fprintf(outputfile, "+%i.%01i", (int)(taltime / TIME_DIMENSION), (int)((taltime % TIME_DIMENSION) / 1000000LL));
break;
case 2 : tallen = fprintf(outputfile, "+%i.%02i", (int)(taltime / TIME_DIMENSION), (int)((taltime % TIME_DIMENSION) / 100000LL));
break;
case 3 : tallen = fprintf(outputfile, "+%i.%03i", (int)(taltime / TIME_DIMENSION), (int)((taltime % TIME_DIMENSION) / 10000LL));
break;
case 4 : tallen = fprintf(outputfile, "+%i.%04i", (int)(taltime / TIME_DIMENSION), (int)((taltime % TIME_DIMENSION) / 1000LL));
break;
case 5 : tallen = fprintf(outputfile, "+%i.%05i", (int)(taltime / TIME_DIMENSION), (int)((taltime % TIME_DIMENSION) / 100LL));
break;
case 6 : tallen = fprintf(outputfile, "+%i.%06i", (int)(taltime / TIME_DIMENSION), (int)((taltime % TIME_DIMENSION) / 10LL));
break;
case 7 : tallen = fprintf(outputfile, "+%i.%07i", (int)(taltime / TIME_DIMENSION), (int)(taltime % TIME_DIMENSION));
break;
}
fputc(20, outputfile);
fputc(20, outputfile);
fputc(0, outputfile);
tallen += 3;
if(new_annot_list != NULL)
{
for(i=0; i<annots_per_datrec; i++)
{
if(new_annot_list != NULL)
{
len = snprintf(scratchpad, 256, "%+i.%07i",
(int)(new_annot_list->onset / TIME_DIMENSION),
(int)(new_annot_list->onset % TIME_DIMENSION));
for(j=0; j<7; j++)
{
if(scratchpad[len - j - 1] != '0')
{
break;
}
}
if(j)
{
len -= j;
if(j == 7)
{
len--;
}
}
if(fwrite(scratchpad, len, 1, outputfile) != 1)
{
progress.reset();
showpopupmessage("Error", "Write error (5).");
goto END_4;
}
tallen += len;
if(new_annot_list->duration[0]!=0)
{
fputc(21, outputfile);
tallen++;
tallen += fprintf(outputfile, "%s", new_annot_list->duration);
}
fputc(20, outputfile);
tallen++;
tallen += fprintf(outputfile, "%s", new_annot_list->annotation);
fputc(20, outputfile);
fputc(0, outputfile);
tallen += 2;
new_annot_list = new_annot_list->next_annotation;
}
}
}
for(k=tallen; k<annot_recordsize; k++)
{
fputc(0, outputfile);
}
taltime += edfhdr->long_data_record_duration;
}
}
void UI_Mainwindow::save_screen_waveform()
{
int i, j,
n=0,
chn,
chns=0,
hdl=-1,
yref[MAX_CHNS],
yor[MAX_CHNS];
char str[128],
opath[MAX_PATHLEN];
short *wavbuf[4];
long long rec_len=0LL;
double yinc[MAX_CHNS];
if(device == NULL)
{
return;
}
wavbuf[0] = NULL;
wavbuf[1] = NULL;
wavbuf[2] = NULL;
wavbuf[3] = NULL;
scrn_timer->stop();
scrn_thread->wait();
if(devparms.timebasedelayenable)
{
rec_len = EDFLIB_TIME_DIMENSION * devparms.timebasedelayscale * devparms.hordivisions;
}
else
{
rec_len = EDFLIB_TIME_DIMENSION * devparms.timebasescale * devparms.hordivisions;
}
if(rec_len < 10LL)
{
strcpy(str, "Can not save waveforms when timebase < 1uSec.");
goto OUT_ERROR;
}
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn]) // Download data only when channel is switched on
{
continue;
}
wavbuf[chn] = (short *)malloc(WAVFRM_MAX_BUFSZ * sizeof(short));
if(wavbuf[chn] == NULL)
{
strcpy(str, "Malloc error.");
goto OUT_ERROR;
}
chns++;
}
if(!chns)
{
strcpy(str, "No active channels.");
goto OUT_ERROR;
}
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn]) // Download data only when channel is switched on
{
continue;
}
usleep(20000);
sprintf(str, ":WAV:SOUR CHAN%i", chn + 1);
tmc_write(str);
usleep(20000);
tmc_write(":WAV:FORM BYTE");
usleep(20000);
tmc_write(":WAV:MODE NORM");
usleep(20000);
tmc_write(":WAV:YINC?");
usleep(20000);
tmc_read();
yinc[chn] = atof(device->buf);
if(yinc[chn] < 1e-6)
{
sprintf(str, "Error, parameter \"YINC\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YREF?");
usleep(20000);
tmc_read();
yref[chn] = atoi(device->buf);
if((yref[chn] < 1) || (yref[chn] > 255))
{
sprintf(str, "Error, parameter \"YREF\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:YOR?");
usleep(20000);
tmc_read();
yor[chn] = atoi(device->buf);
if((yor[chn] < -255) || (yor[chn] > 255))
{
sprintf(str, "Error, parameter \"YOR\" out of range. line %i file %s", __LINE__, __FILE__);
goto OUT_ERROR;
}
usleep(20000);
tmc_write(":WAV:DATA?");
QApplication::setOverrideCursor(Qt::WaitCursor);
qApp->processEvents();
n = tmc_read();
QApplication::restoreOverrideCursor();
if(n < 0)
{
strcpy(str, "Can not read from device.");
goto OUT_ERROR;
}
if(n > WAVFRM_MAX_BUFSZ)
{
strcpy(str, "Datablock too big for buffer.");
goto OUT_ERROR;
}
if(n < 16)
{
strcpy(str, "Not enough data in buffer.");
goto OUT_ERROR;
}
for(i=0; i<n; i++)
{
wavbuf[chn][i] = ((int)(((unsigned char *)device->buf)[i]) - yref[chn] - yor[chn]) << 5;
}
}
opath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(opath, recent_savedir);
strcat(opath, "/");
}
strcat(opath, "waveform.edf");
strcpy(opath, QFileDialog::getSaveFileName(this, "Save file", opath, "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(opath, ""))
{
goto OUT_NORMAL;
}
get_directory_from_path(recent_savedir, opath, MAX_PATHLEN);
hdl = edfopen_file_writeonly(opath, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl < 0)
{
strcpy(str, "Can not create EDF file.");
goto OUT_ERROR;
}
if(edf_set_datarecord_duration(hdl, rec_len / 100LL))
{
strcpy(str, "Can not set datarecord duration of EDF file.");
goto OUT_ERROR;
}
j = 0;
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
edf_set_samplefrequency(hdl, j, n);
edf_set_digital_maximum(hdl, j, 32767);
edf_set_digital_minimum(hdl, j, -32768);
if(devparms.chanscale[chn] > 2)
{
edf_set_physical_maximum(hdl, j, yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "V");
}
else
{
edf_set_physical_maximum(hdl, j, 1000.0 * yinc[chn] * 32767.0 / 32.0);
edf_set_physical_minimum(hdl, j, 1000.0 * yinc[chn] * -32768.0 / 32.0);
edf_set_physical_dimension(hdl, j, "mV");
}
sprintf(str, "CHAN%i", chn + 1);
edf_set_label(hdl, j, str);
j++;
}
edf_set_equipment(hdl, devparms.modelname);
for(chn=0; chn<MAX_CHNS; chn++)
{
if(!devparms.chandisplay[chn])
{
continue;
}
if(edfwrite_digital_short_samples(hdl, wavbuf[chn]))
{
strcpy(str, "A write error occurred.");
goto OUT_ERROR;
}
}
OUT_NORMAL:
if(hdl >= 0)
{
edfclose_file(hdl);
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
return;
OUT_ERROR:
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Critical);
msgBox.setText(str);
msgBox.exec();
if(hdl >= 0)
{
edfclose_file(hdl);
}
for(chn=0; chn<MAX_CHNS; chn++)
{
free(wavbuf[chn]);
}
scrn_timer->start(devparms.screentimerival);
}
void UI_Mainwindow::save_screenshot()
{
int n;
char str[128],
opath[MAX_PATHLEN];
QPainter painter;
#if QT_VERSION >= 0x050000
painter.setRenderHint(QPainter::Qt4CompatiblePainting, true);
#endif
QPainterPath path;
if(device == NULL)
{
return;
}
scrn_timer->stop();
scrn_thread->wait();
tmc_write(":DISP:DATA?");
QApplication::setOverrideCursor(Qt::WaitCursor);
qApp->processEvents();
n = tmc_read();
QApplication::restoreOverrideCursor();
if(n < 0)
{
strcpy(str, "Can not read from device.");
goto OUT_ERROR;
}
if(device->sz != SCRN_SHOT_BMP_SZ)
{
strcpy(str, "Error, bitmap has wrong filesize\n");
goto OUT_ERROR;
}
if(strncmp(device->buf, "BM", 2))
{
strcpy(str, "Error, file is not a bitmap\n");
goto OUT_ERROR;
}
memcpy(devparms.screenshot_buf, device->buf, SCRN_SHOT_BMP_SZ);
screenXpm.loadFromData((uchar *)(devparms.screenshot_buf), SCRN_SHOT_BMP_SZ);
if(devparms.modelserie == 1)
{
painter.begin(&screenXpm);
painter.fillRect(0, 0, 80, 29, Qt::black);
painter.setPen(Qt::white);
painter.drawText(5, 8, 65, 20, Qt::AlignCenter, devparms.modelname);
painter.end();
}
else if(devparms.modelserie == 6)
{
painter.begin(&screenXpm);
painter.fillRect(0, 0, 95, 29, QColor(48, 48, 48));
path.addRoundedRect(5, 5, 85, 20, 3, 3);
painter.fillPath(path, Qt::black);
painter.setPen(Qt::white);
painter.drawText(5, 5, 85, 20, Qt::AlignCenter, devparms.modelname);
painter.end();
}
if(devparms.screenshot_inv)
{
screenXpm.invertPixels(QImage::InvertRgb);
}
opath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(opath, recent_savedir);
strcat(opath, "/");
}
strcat(opath, "screenshot.png");
strcpy(opath, QFileDialog::getSaveFileName(this, "Save file", opath, "PNG files (*.png *.PNG)").toLocal8Bit().data());
if(!strcmp(opath, ""))
{
scrn_timer->start(devparms.screentimerival);
return;
}
get_directory_from_path(recent_savedir, opath, MAX_PATHLEN);
if(screenXpm.save(QString::fromLocal8Bit(opath), "PNG", 50) == false)
{
strcpy(str, "Could not save file (unknown error)");
goto OUT_ERROR;
}
scrn_timer->start(devparms.screentimerival);
return;
OUT_ERROR:
scrn_timer->start(devparms.screentimerival);
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Critical);
msgBox.setText(str);
msgBox.exec();
}
void UI_LoadMontagewindow::LoadButtonClicked()
{
int i, k, n, p,
tmp,
skip,
found,
signalcomps_read=0,
signals_read,
signal_cnt,
filters_read,
filter_cnt=0,
ravg_filter_cnt=0,
fidfilter_cnt=0,
len,
order=1,
type=0,
model=0,
size=0,
amp_cat[3],
f_ruler_cnt=0;
char *result,
scratchpad[2048],
str[128],
*err,
*filter_spec,
spec_str[256];
double frequency=1.0,
frequency2=2.0,
ripple=1.0;
struct xml_handle *xml_hdl;
struct signalcompblock *newsignalcomp;
if(mainwindow->files_open==1) n = 0;
else n = filelist->currentRow();
if(mtg_path[0]==0)
{
strcpy(mtg_path, QFileDialog::getOpenFileName(0, "Load montage", QString::fromLocal8Bit(mainwindow->recent_montagedir), "Montage files (*.mtg *.MTG)").toLocal8Bit().data());
if(!strcmp(mtg_path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_montagedir, mtg_path, MAX_PATH_LENGTH);
}
xml_hdl = xml_get_handle(mtg_path);
if(xml_hdl==NULL)
{
sprintf(scratchpad, "Can not open montage file:\n%s", mtg_path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(scratchpad));
messagewindow.exec();
mainwindow->remove_recent_file_mtg_path(mtg_path);
return;
}
if(strcmp(xml_hdl->elementname, PROGRAM_NAME "_montage"))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
////////////////////////////////////////////
for(k=0; k<mainwindow->signalcomps; )
{
if(mainwindow->signalcomp[k]->filenum==n)
{
if(mainwindow->spectrumdock->signalcomp == mainwindow->signalcomp[k])
{
mainwindow->spectrumdock->clear();
mainwindow->spectrumdock->dock->hide();
}
for(i=0; i<MAXSPECTRUMDIALOGS; i++)
{
p = mainwindow->signalcomp[k]->spectr_dialog[i];
if(p != 0)
{
delete mainwindow->spectrumdialog[p - 1];
mainwindow->spectrumdialog[p - 1] = NULL;
}
}
for(i=0; i<MAXAVERAGECURVEDIALOGS; i++)
{
p = mainwindow->signalcomp[k]->avg_dialog[i];
if(p != 0)
{
delete mainwindow->averagecurvedialog[p - 1];
mainwindow->averagecurvedialog[p - 1] = NULL;
}
}
if(mainwindow->signalcomp[k]->hascursor2)
{
/* crosshair_2_active = 0;
crosshair_2_moving = 0;*/
}
if(mainwindow->signalcomp[k]->hascursor1)
{
// crosshair_1_active = 0;
// crosshair_2_active = 0;
// crosshair_1_moving = 0;
// crosshair_2_moving = 0;
for(i=0; i<mainwindow->signalcomps; i++)
{
mainwindow->signalcomp[i]->hascursor2 = 0;
}
}
for(i=0; i<mainwindow->signalcomp[k]->filter_cnt; i++)
{
free(mainwindow->signalcomp[k]->filter[i]);
}
mainwindow->signalcomp[k]->filter_cnt = 0;
for(i=0; i<mainwindow->signalcomp[k]->ravg_filter_cnt; i++)
{
free_ravg_filter(mainwindow->signalcomp[k]->ravg_filter[i]);
}
mainwindow->signalcomp[k]->ravg_filter_cnt = 0;
for(i=0; i<mainwindow->signalcomp[k]->fidfilter_cnt; i++)
{
free(mainwindow->signalcomp[k]->fidfilter[i]);
fid_run_free(mainwindow->signalcomp[k]->fid_run[i]);
fid_run_freebuf(mainwindow->signalcomp[k]->fidbuf[i]);
fid_run_freebuf(mainwindow->signalcomp[k]->fidbuf2[i]);
}
mainwindow->signalcomp[k]->fidfilter_cnt = 0;
if(mainwindow->signalcomp[k]->ecg_filter != NULL)
{
free_ecg_filter(mainwindow->signalcomp[k]->ecg_filter);
mainwindow->signalcomp[k]->ecg_filter = NULL;
strcpy(mainwindow->signalcomp[k]->signallabel, mainwindow->signalcomp[k]->signallabel_bu);
mainwindow->signalcomp[k]->signallabellen = mainwindow->signalcomp[k]->signallabellen_bu;
}
free(mainwindow->signalcomp[k]);
for(i=k; i<mainwindow->signalcomps - 1; i++)
{
mainwindow->signalcomp[i] = mainwindow->signalcomp[i + 1];
}
mainwindow->signalcomps--;
k = 0;
}
else
{
k++;
}
}
////////////////////////////////////////////
while(1)
{
skip = 0;
xml_goto_root(xml_hdl);
signals_read = 0;
if(xml_goto_nth_element_inside(xml_hdl, "signalcomposition", signalcomps_read))
{
break;
}
newsignalcomp = (struct signalcompblock *)calloc(1, sizeof(struct signalcompblock));
if(newsignalcomp==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Internal error: Memory allocation error:\n\"new signal composition\"");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "num_of_signals", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
signal_cnt = atoi(result);
free(result);
if((signal_cnt<1)||(signal_cnt>MAXSIGNALS))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
newsignalcomp->edfhdr = mainwindow->edfheaderlist[n];
newsignalcomp->filenum = n;
newsignalcomp->num_of_signals = signal_cnt;
newsignalcomp->hascursor1 = 0;
newsignalcomp->hascursor2 = 0;
newsignalcomp->hasoffsettracking = 0;
newsignalcomp->hasgaintracking = 0;
newsignalcomp->screen_offset = 0;
newsignalcomp->filter_cnt = 0;
newsignalcomp->ravg_filter_cnt = 0;
newsignalcomp->ecg_filter = NULL;
newsignalcomp->fidfilter_cnt = 0;
newsignalcomp->hasruler = 0;
newsignalcomp->polarity = 1;
newsignalcomp->type = -1;
xml_go_up(xml_hdl);
if(!(xml_goto_nth_element_inside(xml_hdl, "alias", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result[0] != 0)
{
strncpy(newsignalcomp->alias, result, 16);
newsignalcomp->alias[16] = 0;
latin1_to_ascii(newsignalcomp->alias, 16);
remove_trailing_spaces(newsignalcomp->alias);
remove_leading_spaces(newsignalcomp->alias);
}
free(result);
xml_go_up(xml_hdl);
}
if(xml_goto_nth_element_inside(xml_hdl, "voltpercm", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
newsignalcomp->voltpercm = atof(result);
if(newsignalcomp->voltpercm==0.0) newsignalcomp->voltpercm = 0.000000001;
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "screen_offset", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
newsignalcomp->screen_offset = atof(result);
free(result);
xml_go_up(xml_hdl);
if(!(xml_goto_nth_element_inside(xml_hdl, "polarity", 0)))
{
result = xml_get_content_of_element(xml_hdl);
newsignalcomp->polarity = atoi(result);
if(newsignalcomp->polarity != -1)
{
newsignalcomp->polarity = 1;
}
free(result);
xml_go_up(xml_hdl);
}
if(xml_goto_nth_element_inside(xml_hdl, "color", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
newsignalcomp->color = atoi(result);
if((newsignalcomp->color < 2) || (newsignalcomp->color > 18))
{
newsignalcomp->color = 2;
}
free(result);
xml_go_up(xml_hdl);
if(!(xml_goto_nth_element_inside(xml_hdl, "filter_cnt", 0)))
{
result = xml_get_content_of_element(xml_hdl);
filter_cnt = atoi(result);
if(filter_cnt < 0) filter_cnt = 0;
if(filter_cnt > MAXFILTERS) filter_cnt = MAXFILTERS;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "ravg_filter_cnt", 0)))
{
result = xml_get_content_of_element(xml_hdl);
ravg_filter_cnt = atoi(result);
if(ravg_filter_cnt < 0) filter_cnt = 0;
if(ravg_filter_cnt > MAXFILTERS) ravg_filter_cnt = MAXFILTERS;
free(result);
xml_go_up(xml_hdl);
}
if(filter_cnt)
{
fidfilter_cnt = 0;
}
else
{
if(!(xml_goto_nth_element_inside(xml_hdl, "fidfilter_cnt", 0)))
{
result = xml_get_content_of_element(xml_hdl);
fidfilter_cnt = atoi(result);
if(fidfilter_cnt < 0) fidfilter_cnt = 0;
if(fidfilter_cnt > MAXFILTERS) fidfilter_cnt = MAXFILTERS;
free(result);
xml_go_up(xml_hdl);
}
}
for(signals_read=0; signals_read<signal_cnt; signals_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "signal", signals_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "factor", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
newsignalcomp->factor[signals_read] = atoi(result);
if(newsignalcomp->factor[signals_read] < -128)
{
newsignalcomp->factor[signals_read] = -128;
}
if(newsignalcomp->factor[signals_read] > 128)
{
newsignalcomp->factor[signals_read] = 128;
}
if(newsignalcomp->factor[signals_read] == 0)
{
newsignalcomp->factor[signals_read] = 1;
}
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "edfindex", 0))
{
if(xml_goto_nth_element_inside(xml_hdl, "label", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
remove_trailing_spaces(result);
found = 0;
for(i=0; i<newsignalcomp->edfhdr->edfsignals; i++)
{
strcpy(scratchpad, newsignalcomp->edfhdr->edfparam[i].label);
remove_trailing_spaces(scratchpad);
if(!strcmp(scratchpad, result))
{
newsignalcomp->edfsignal[signals_read] = i;
if(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].annotation)
{
found = 0;
}
else
{
found = 1;
}
break;
}
}
}
else
{
result = xml_get_content_of_element(xml_hdl);
newsignalcomp->edfsignal[signals_read] = atoi(result);
if((newsignalcomp->edfsignal[signals_read] < 0) || (newsignalcomp->edfsignal[signals_read] >= newsignalcomp->edfhdr->edfsignals))
{
found = 0;
}
else
{
if(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].annotation)
{
found = 0;
}
else
{
found = 1;
}
}
}
free(result);
if(!found)
{
free(newsignalcomp);
skip = 1;
signalcomps_read++;
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
break;
}
if(signals_read)
{
if(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].smp_per_record
!= newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record)
{
free(newsignalcomp);
skip = 1;
signalcomps_read++;
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
break;
}
}
newsignalcomp->sensitivity[signals_read] = newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].bitvalue / (newsignalcomp->voltpercm * mainwindow->pixelsizefactor);
if(!signals_read)
{
newsignalcomp->signallabel[0] = 0;
}
if(signal_cnt>1)
{
if(newsignalcomp->factor[signals_read]<0)
{
strcat(newsignalcomp->signallabel, "- ");
}
else
{
if(signals_read)
{
strcat(newsignalcomp->signallabel, "+ ");
}
}
}
strcpy(str, newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].label);
strip_types_from_label(str);
strcat(newsignalcomp->signallabel, str);
strcat(newsignalcomp->signallabel, " ");
len = strlen(newsignalcomp->signallabel);
for(k=(len-1); k>0; k--)
{
if(newsignalcomp->signallabel[k]!=' ') break;
}
newsignalcomp->signallabel[k+2] = 0;
newsignalcomp->file_duration = newsignalcomp->edfhdr->long_data_record_duration * newsignalcomp->edfhdr->datarecords;
newsignalcomp->signallabellen = strlen(newsignalcomp->signallabel);
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
if(skip) continue;
strcpy(newsignalcomp->physdimension, newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].physdimension);
remove_trailing_spaces(newsignalcomp->physdimension);
for(filters_read=0; filters_read<filter_cnt; filters_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "filter", filters_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "LPF", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
type = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "frequency", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
frequency = atof(result);
free(result);
if((type < 0) || (type > 1) || (frequency < 0.0001))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (filter values)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(frequency >= ((newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record
/ newsignalcomp->edfhdr->data_record_duration)
/ 2.0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The frequency of the filter(s) must be less than: samplerate / 2");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(type == 0)
{
sprintf(spec_str, "HpBu1/%f", frequency);
}
if(type == 1)
{
sprintf(spec_str, "LpBu1/%f", frequency);
}
filter_spec = spec_str;
err = fid_parse(((double)(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record)) / newsignalcomp->edfhdr->data_record_duration,
&filter_spec,
&newsignalcomp->fidfilter[filters_read]);
if(err != NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", err);
messagewindow.exec();
free(err);
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
newsignalcomp->fid_run[filters_read] = fid_run_new(newsignalcomp->fidfilter[filters_read],
&newsignalcomp->fidfuncp[filters_read]);
newsignalcomp->fidbuf[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]);
newsignalcomp->fidbuf2[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]);
newsignalcomp->fidfilter_freq[filters_read] = frequency;
newsignalcomp->fidfilter_freq2[filters_read] = frequency * 1.12;
newsignalcomp->fidfilter_ripple[filters_read] = -1.0;
newsignalcomp->fidfilter_order[filters_read] = 1;
newsignalcomp->fidfilter_type[filters_read] = type;
newsignalcomp->fidfilter_model[filters_read] = 0;
newsignalcomp->fidfilter_setup[filters_read] = 1;
newsignalcomp->fidfilter_cnt = filters_read + 1;
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
for(filters_read=0; filters_read<ravg_filter_cnt; filters_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "ravg_filter", filters_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
type = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "size", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
size = atoi(result);
free(result);
if((type < 0) || (type > 1) || (size < 2) || (size > 10000))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (ravg_filter values)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
newsignalcomp->ravg_filter[filters_read] = create_ravg_filter(type, size);
if(newsignalcomp->ravg_filter[filters_read] == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred when creating an ravg filter.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
newsignalcomp->ravg_filter_size[filters_read] = size;
newsignalcomp->ravg_filter_type[filters_read] = type;
newsignalcomp->ravg_filter_cnt = filters_read + 1;
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
for(filters_read=0; filters_read<fidfilter_cnt; filters_read++)
{
if(xml_goto_nth_element_inside(xml_hdl, "fidfilter", filters_read))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (fidfilter)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (type)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
type = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "model", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (model)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
model = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "frequency", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (frequency)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
frequency = atof(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "frequency2", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (frequency2)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
frequency2 = atof(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "ripple", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (ripple)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
ripple = atof(result);
free(result);
xml_go_up(xml_hdl);
if(xml_goto_nth_element_inside(xml_hdl, "order", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (order)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
order = atoi(result);
free(result);
if((model < 0) || (model > 2) ||
(order < 1) || (order > 100) ||
(type < 0) || (type > 4) ||
(ripple < (-6.0)) || (ripple > (-0.1)) ||
(frequency < 0.0001) || (frequency2 < 0.0001))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (fidfilter values)");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(frequency >= ((newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record
/ newsignalcomp->edfhdr->data_record_duration)
/ 2.0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The frequency of the filter(s) must be less than: samplerate / 2");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
if(type > 2)
{
if(frequency2 >= ((newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record
/ newsignalcomp->edfhdr->data_record_duration)
/ 2.0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The frequency of the filter(s) must be less than: samplerate / 2");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
}
if((type == 0) || (type == 1))
{
if(order > 8)
{
order = 8;
}
}
if(type == 0)
{
if(model == 0)
{
sprintf(spec_str, "HpBu%i/%f", order, frequency);
}
if(model == 1)
{
sprintf(spec_str, "HpCh%i/%f/%f", order, ripple, frequency);
}
if(model == 2)
{
sprintf(spec_str, "HpBe%i/%f", order, frequency);
}
}
if(type == 1)
{
if(model == 0)
{
sprintf(spec_str, "LpBu%i/%f", order, frequency);
}
if(model == 1)
{
sprintf(spec_str, "LpCh%i/%f/%f", order, ripple, frequency);
}
if(model == 2)
{
sprintf(spec_str, "LpBe%i/%f", order, frequency);
}
}
if(type == 2)
{
if(order > 100)
{
order = 100;
}
if(order < 3)
{
order = 3;
}
if(model == 0)
{
sprintf(spec_str, "BsRe/%i/%f", order, frequency);
}
}
if((type == 3) || (type == 4))
{
if(order < 2)
{
order = 2;
}
if(order % 2)
{
order++;
}
if(order > 16)
{
order = 16;
}
}
if(type == 3)
{
if(model == 0)
{
sprintf(spec_str, "BpBu%i/%f-%f", order, frequency, frequency2);
}
if(model == 1)
{
sprintf(spec_str, "BpCh%i/%f/%f-%f", order, ripple, frequency, frequency2);
}
if(model == 2)
{
sprintf(spec_str, "BpBe%i/%f-%f", order, frequency, frequency2);
}
}
if(type == 4)
{
if(model == 0)
{
sprintf(spec_str, "BsBu%i/%f-%f", order, frequency, frequency2);
}
if(model == 1)
{
sprintf(spec_str, "BsCh%i/%f/%f-%f", order, ripple, frequency, frequency2);
}
if(model == 2)
{
sprintf(spec_str, "BsBe%i/%f-%f", order, frequency, frequency2);
}
}
filter_spec = spec_str;
err = fid_parse(((double)(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record)) / newsignalcomp->edfhdr->data_record_duration,
&filter_spec,
&newsignalcomp->fidfilter[filters_read]);
if(err != NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", err);
messagewindow.exec();
free(err);
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
newsignalcomp->fid_run[filters_read] = fid_run_new(newsignalcomp->fidfilter[filters_read],
&newsignalcomp->fidfuncp[filters_read]);
newsignalcomp->fidbuf[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]);
newsignalcomp->fidbuf2[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]);
newsignalcomp->fidfilter_freq[filters_read] = frequency;
newsignalcomp->fidfilter_freq2[filters_read] = frequency2;
newsignalcomp->fidfilter_ripple[filters_read] = ripple;
newsignalcomp->fidfilter_order[filters_read] = order;
newsignalcomp->fidfilter_type[filters_read] = type;
newsignalcomp->fidfilter_model[filters_read] = model;
newsignalcomp->fidfilter_setup[filters_read] = 1;
newsignalcomp->fidfilter_cnt = filters_read + 1;
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
if(!xml_goto_nth_element_inside(xml_hdl, "ecg_filter", 0))
{
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
type = atoi(result);
free(result);
if(type == 1)
{
newsignalcomp->ecg_filter = create_ecg_filter(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record /
newsignalcomp->edfhdr->data_record_duration,
newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].bitvalue,
mainwindow->powerlinefreq);
if(newsignalcomp->ecg_filter == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred when creating an ECG filter.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
strcpy(newsignalcomp->signallabel_bu, newsignalcomp->signallabel);
newsignalcomp->signallabellen_bu = newsignalcomp->signallabellen;
strcpy(newsignalcomp->signallabel, "HR");
newsignalcomp->signallabellen = strlen(newsignalcomp->signallabel);
strcpy(newsignalcomp->physdimension_bu, newsignalcomp->physdimension);
strcpy(newsignalcomp->physdimension, "bpm");
}
xml_go_up(xml_hdl);
xml_go_up(xml_hdl);
}
if(newsignalcomp->ecg_filter == NULL)
{
if(!xml_goto_nth_element_inside(xml_hdl, "zratio_filter", 0))
{
if(xml_goto_nth_element_inside(xml_hdl, "type", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
type = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(type == 1)
{
if(xml_goto_nth_element_inside(xml_hdl, "crossoverfreq", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
newsignalcomp->zratio_crossoverfreq = atof(result);
free(result);
if((newsignalcomp->zratio_crossoverfreq < 5.0) || (newsignalcomp->zratio_crossoverfreq > 9.5))
{
newsignalcomp->zratio_crossoverfreq = 7.5;
}
newsignalcomp->zratio_filter = create_zratio_filter(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record,
newsignalcomp->edfhdr->long_data_record_duration,
newsignalcomp->zratio_crossoverfreq,
newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].bitvalue);
if(newsignalcomp->zratio_filter == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred when creating a Z-ratio filter.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
strcpy(newsignalcomp->signallabel_bu, newsignalcomp->signallabel);
newsignalcomp->signallabellen_bu = newsignalcomp->signallabellen;
strcpy(newsignalcomp->signallabel, "Z-ratio ");
strcat(newsignalcomp->signallabel, newsignalcomp->signallabel_bu);
newsignalcomp->signallabellen = strlen(newsignalcomp->signallabel);
strcpy(newsignalcomp->physdimension_bu, newsignalcomp->physdimension);
strcpy(newsignalcomp->physdimension, "");
xml_go_up(xml_hdl);
}
xml_go_up(xml_hdl);
}
}
if(f_ruler_cnt == 0)
{
if(!xml_goto_nth_element_inside(xml_hdl, "floating_ruler", 0))
{
if(xml_goto_nth_element_inside(xml_hdl, "hasruler", 0))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file.");
messagewindow.exec();
free(newsignalcomp);
xml_close(xml_hdl);
return;
}
result = xml_get_content_of_element(xml_hdl);
tmp = atoi(result);
free(result);
xml_go_up(xml_hdl);
if(tmp == 1)
{
f_ruler_cnt = 1;
mainwindow->maincurve->ruler_x_position = 200;
mainwindow->maincurve->ruler_y_position = 200;
mainwindow->maincurve->floating_ruler_value = 0;
if(!xml_goto_nth_element_inside(xml_hdl, "ruler_x_position", 0))
{
result = xml_get_content_of_element(xml_hdl);
tmp = atoi(result);
free(result);
if((tmp >= 0) && (tmp < 5000))
{
mainwindow->maincurve->ruler_x_position = tmp;
}
xml_go_up(xml_hdl);
}
if(!xml_goto_nth_element_inside(xml_hdl, "ruler_y_position", 0))
{
result = xml_get_content_of_element(xml_hdl);
tmp = atoi(result);
free(result);
if((tmp >= 0) && (tmp < 5000))
{
mainwindow->maincurve->ruler_y_position = tmp;
}
xml_go_up(xml_hdl);
}
if(!xml_goto_nth_element_inside(xml_hdl, "floating_ruler_value", 0))
{
result = xml_get_content_of_element(xml_hdl);
tmp = atoi(result);
free(result);
if((tmp >= 0) && (tmp < 2))
{
mainwindow->maincurve->floating_ruler_value = tmp;
}
xml_go_up(xml_hdl);
}
newsignalcomp->hasruler = 1;
}
xml_go_up(xml_hdl);
}
}
mainwindow->signalcomp[mainwindow->signalcomps] = newsignalcomp;
mainwindow->signalcomps++;
signalcomps_read++;
}
xml_goto_root(xml_hdl);
if(!(xml_goto_nth_element_inside(xml_hdl, "pagetime", 0)))
{
result = xml_get_content_of_element(xml_hdl);
mainwindow->pagetime = atoll(result);
if(mainwindow->pagetime < 10000LL)
{
mainwindow->pagetime = 10000LL;
}
free(result);
}
xml_close(xml_hdl);
if(LoadMontageDialog!=NULL) LoadMontageDialog->close();
mainwindow->setMainwindowTitle(mainwindow->edfheaderlist[mainwindow->sel_viewtime]);
if(mainwindow->files_open == 1)
{
strcpy(&mainwindow->recent_file_mtg_path[0][0], mtg_path);
}
for(i=0; i<3; i++)
{
amp_cat[i] = 0;
}
for(i=0; i<mainwindow->signalcomps; i++)
{
tmp = round_125_cat(mainwindow->signalcomp[i]->voltpercm);
switch(tmp)
{
case 10 : amp_cat[0]++;
break;
case 20 : amp_cat[1]++;
break;
case 50 : amp_cat[2]++;
break;
}
}
mainwindow->amplitude_doubler = 10;
if((amp_cat[1] > amp_cat[0]) && (amp_cat[1] >= amp_cat[2]))
{
mainwindow->amplitude_doubler = 20;
}
if((amp_cat[2] > amp_cat[0]) && (amp_cat[2] > amp_cat[1]))
{
mainwindow->amplitude_doubler = 50;
}
if(f_ruler_cnt == 1)
{
mainwindow->maincurve->ruler_active = 1;
}
mainwindow->setup_viewbuf();
}
void UI_SCPECG2EDFwindow::SelectFileButton()
{
FILE *inputfile=NULL;
int i, j, k, n, hdl, chns, sf, avm, blocks, *buf, encoding, compression, offset,
abs_val_a[256],
abs_val_b[256],
var_tmp;
unsigned short sh_tmp;
long long filesize, ll_tmp, bits;
char input_filename[MAX_PATH_LENGTH],
txt_string[2048],
edf_filename[MAX_PATH_LENGTH],
scratchpad[MAX_PATH_LENGTH],
*block,
ch_tmp;
union{
unsigned long long ll_int;
unsigned int one[2];
unsigned short two[4];
unsigned char four[8];
} var;
pushButton1->setEnabled(false);
for(i=0; i<256; i++)
{
abs_val_a[i] = 0;
abs_val_b[i] = 0;
}
strcpy(input_filename, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "SCP files (*.scp *.SCP)").toLocal8Bit().data());
if(!strcmp(input_filename, ""))
{
pushButton1->setEnabled(true);
return;
}
get_directory_from_path(recent_opendir, input_filename, MAX_PATH_LENGTH);
inputfile = fopeno(input_filename, "rb");
if(inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.\n", input_filename);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
return;
}
get_filename_from_path(scratchpad, input_filename, MAX_PATH_LENGTH);
snprintf(txt_string, 2048, "Read file: %s", scratchpad);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fseeko(inputfile, 0LL, SEEK_END);
filesize = ftello(inputfile);
if(filesize<126)
{
textEdit1->append("Error, filesize is too small.\n");
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
ll_tmp = 0LL;
fseeko(inputfile, 2LL, SEEK_SET);
if(fread(&ll_tmp, 4, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (1)\n");
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
if(ll_tmp != filesize)
{
textEdit1->append("Error, filesize does not match with header.\n");
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
block = (char *)malloc(SPCECGBUFSIZE);
if(block == NULL)
{
textEdit1->append("Malloc error (block 1)\n");
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
rewind(inputfile);
if(fread(&sh_tmp, 2, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (2)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(check_crc(inputfile, 2LL, filesize - 2LL, sh_tmp, block))
{
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
memset(&sp, 0, sizeof(struct section_prop_struct[12]));
if(read_section_header(0, inputfile, 6LL, block))
{
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(strncmp(sp[0].reserved, "SCPECG", 6))
{
textEdit1->append("Error, reserved field of section header 0 does not contain string \"SCPECG\".\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
sp[0].file_offset = 6LL;
// printf("\nsection ID is %i\n"
// "section file offset is %lli\n"
// "section CRC is 0x%04X\n"
// "section length is %i\n"
// "section version is %i\n"
// "section protocol version is %i\n",
// sp[0].section_id,
// sp[0].file_offset,
// (int)sp[0].crc,
// sp[0].section_length,
// sp[0].section_version,
// sp[0].section_protocol_version);
if(read_data_section_zero(inputfile, block, filesize))
{
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
fseeko(inputfile, sp[6].file_offset + 16LL, SEEK_SET);
if(fread(block, 6, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
avm = *((unsigned short *)block);
sf = 1000000 / *((unsigned short *)(block + 2));
encoding = *((unsigned char *)(block + 4));
compression = *((unsigned char *)(block + 5));
if(compression != 0)
{
textEdit1->append("File contains bimodal compressed data which is not supported by this converter.\n ");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
fseeko(inputfile, sp[3].file_offset + 16LL, SEEK_SET);
if(fread(scratchpad, 2, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (40)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
chns = *((unsigned char *)scratchpad);
if(chns < 1)
{
textEdit1->append("Error, number of signals is less than one.\n ");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(chns > 256)
{
textEdit1->append("Error, number of signals is more than 256.\n ");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(scratchpad[1] & 1)
{
textEdit1->append("Reference beat subtraction used for compression which is not supported by this converter.\n ");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(!(scratchpad[1] & 4))
{
textEdit1->append("Leads are not simultaneously recorded which is not supported by this converter. (1)\n ");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
// printf("chns is %u AVM is %u sf is %u encoding is %u compression is %u\n",
// chns, avm, sf, encoding, compression);
memset(&lp, 0, sizeof(struct lead_prop_struct[256]));
fseeko(inputfile, sp[3].file_offset + 18LL, SEEK_SET);
for(i=0; i<chns; i++)
{
if(fread(&(lp[i].start), 4, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (30)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(fread(&(lp[i].end), 4, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (31)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(fread(&(lp[i].label), 1, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (32)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
}
// for(i=0; i<chns; i++)
// {
// printf("lp[i].start is %i lp[i].end is %i\n", lp[i].start, lp[i].end);
// }
if(chns > 1)
{
for(i=1; i<chns; i++)
{
if(lp[i].start != lp[0].start)
{
textEdit1->append("Error, leads are not simultaneously recorded. (2)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(lp[i].end != lp[0].end)
{
textEdit1->append("Error, leads are not simultaneously recorded. (3)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
}
}
for(i=0; i<chns; i++)
{
if(lp[i].start < 1)
{
textEdit1->append("Error, start sample number in section 3 is less than 1.\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(lp[i].end <= lp[i].start)
{
textEdit1->append("Error (56) (lp[i].end <= lp[i].start)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
if(lp[i].start != 1)
{
textEdit1->append("Error (57) (lp[i].start != 1)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
lp[i].start--;
if((lp[i].end - lp[i].start) < sf)
{
textEdit1->append("Error, recording length is less than one second.\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
lp[i].samples = lp[i].end - lp[i].start;
}
fseeko(inputfile, sp[6].file_offset + 22LL, SEEK_SET);
n = 0;
for(i=0; i<chns; i++)
{
if(fread(block, 2, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (41)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
lp[i].bytes = *((unsigned short *)block);
n += lp[i].bytes;
// printf("lead samples is %i bytes is %i\n", lp[i].samples, lp[i].bytes);
if(sp[2].present != 1) // huffmantable
{
if(lp[i].bytes < (lp[i].samples * 2))
{
textEdit1->append("Error, lead samples is less than lead bytes.\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
}
}
if(n > (sp[6].section_length - 22 - (chns * 2)))
{
textEdit1->append("Error, total databytes is more than section size.\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
//////////////////////////////// Huffman tables ////////////////////
if(sp[2].present == 1) // huffmantable
{
fseeko(inputfile, sp[2].file_offset + 16LL, SEEK_SET);
if(fread(block, 13, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred (50)\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
ht.h_tables_cnt = *((unsigned short *)block);
ht.code_structs_cnt = *((unsigned short *)(block + 2));
ht.prefix_bits = *((unsigned char *)(block + 4));
ht.total_bits = *((unsigned char *)(block + 5));
ht.table_mode_switch = *((unsigned char *)(block + 6));
ht.base_value = *((unsigned short *)(block + 7));
ht.base_code = *((unsigned int *)(block + 9));
// printf("ht.h_tables_cnt is %i ht.code_structs_cnt is %i ht.prefix_bits is %i ht.total_bits is %i\n",
// ht.h_tables_cnt, ht.code_structs_cnt, ht.prefix_bits, ht.total_bits);
if(ht.h_tables_cnt != 19999)
{
textEdit1->append("Aborted, this converter does not support customized Huffmantables.\n");
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
}
//////////////////////////////// patient data ////////////////////
memset(&pat_dat, 0, sizeof(struct patient_data_struct));
if(get_patient_data(inputfile))
{
fclose(inputfile);
free(block);
pushButton1->setEnabled(true);
return;
}
// printf("patient ID: %s\n"
// "patient lastname: %s\n"
// "patient firstname: %s\n"
// "patient sex: %i\n"
// "startdate year: %i\n"
// "startdate month: %i\n"
// "startdate day: %i\n"
// "starttime hour: %i\n"
// "starttime minute: %i\n"
// "starttime second: %i\n"
// "birthdate year: %i\n"
// "birthdate month: %i\n"
// "birthdate day: %i\n"
// "device model: %s\n"
// "language code: %u\n"
// "manufacturer: %s\n",
// pat_dat.pat_id,
// pat_dat.last_name,
// pat_dat.first_name,
// pat_dat.sex,
// pat_dat.startdate_year,
// pat_dat.startdate_month,
// pat_dat.startdate_day,
// pat_dat.starttime_hour,
// pat_dat.starttime_minute,
// pat_dat.starttime_second,
// pat_dat.birthdate_year,
// pat_dat.birthdate_month,
// pat_dat.birthdate_day,
// pat_dat.device_model,
// pat_dat.lang_code,
// pat_dat.manufacturer);
////////////////////////// start conversion ///////////////////////////////
free(block);
buf = (int *)malloc(((lp[0].samples / sf) + 1) * chns * sf * sizeof(int));
if(buf == NULL)
{
textEdit1->append("Malloc error (buf)\n");
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
n = 0;
for(i=0; i<chns; i++)
{
n += lp[i].bytes;
}
block = (char *)calloc(1, n + 64);
if(block == NULL)
{
textEdit1->append("Malloc error (block 3)\n");
fclose(inputfile);
free(buf);
pushButton1->setEnabled(true);
return;
}
fseeko(inputfile, sp[6].file_offset + 22LL + (chns * 2LL), SEEK_SET); // rhythm data
if(fread(block, n, 1, inputfile) != 1)
{
textEdit1->append("A read-error occurred during conversion (70)\n");
fclose(inputfile);
free(buf);
free(block);
pushButton1->setEnabled(true);
return;
}
offset = 0;
for(j=0; j<chns; j++)
{
if(j > 0)
{
offset += lp[j - 1].bytes;
}
bits = 0LL;
for(i=0; i<lp[j].samples; i++)
{
if(sp[2].present == 1) // huffmantable present
{
if((bits / 8LL) > lp[j].bytes)
{
textEdit1->append("Error, (bits / 8) >= lp[j].bytes (71)\n");
fclose(inputfile);
free(buf);
free(block);
pushButton1->setEnabled(true);
return;
}
memcpy(&var, block + offset + ((int)(bits / 8LL)), 5);
for(k=0; k<5; k++)
{
var.four[k] = reverse_bitorder(var.four[k]);
}
var.ll_int >>= (int)(bits % 8LL);
if((var.four[0] & 1) == 0) // b00000001
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 0;
bits++;
} else
if((var.four[0] & 7) == 1) // b00000111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 1;
bits += 3LL;
} else
if((var.four[0] & 7) == 5) // b00000111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -1;
bits += 3LL;
} else
if((var.four[0] & 15) == 3) // b00001111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 2;
bits += 4LL;
} else
if((var.four[0] & 15) == 11) // b00001111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -2;
bits += 4LL;
} else
if((var.four[0] & 31) == 7) // b00011111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 3;
bits += 5LL;
} else
if((var.four[0] & 31) == 23) // b00011111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -3;
bits += 5LL;
} else
if((var.four[0] & 63) == 15) // b00111111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 4;
bits += 6LL;
} else
if((var.four[0] & 63) == 47) // b00111111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -4;
bits += 6LL;
} else
if((var.four[0] & 127) == 31) // b01111111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 5;
bits += 7LL;
} else
if((var.four[0] & 127) == 95) // b01111111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -5;
bits += 7LL;
} else
if(var.four[0] == 63) // b11111111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 6;
bits += 8LL;
} else
if(var.four[0] == 191) // b11111111
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -6;
bits += 8LL;
} else
if(var.four[0] == 127) // b11111111
{
if((var.four[1] & 1) == 0) // b00000001
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 7;
bits += 9LL;
}
else
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -7;
bits += 9LL;
}
} else
if(var.four[0] == 255) // b11111111
{
if((var.four[1] & 3) == 0) // b00000011
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = 8;
bits += 10LL;
} else
if((var.four[1] & 3) == 2) // b00000011
{
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = -8;
bits += 10LL;
} else
if((var.four[1] & 3) == 1) // b00000011
{
var.ll_int >>= 2;
var.four[1] = reverse_bitorder(var.four[1]);
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = *((signed char *)&(var.four[1])); // 8-bit original
bits += 18LL;
} else
if((var.four[1] & 3) == 3) // b00000011
{
var.ll_int >>= 10;
ch_tmp = reverse_bitorder(var.four[0]);
var.four[0] = reverse_bitorder(var.four[1]);
var.four[1] = ch_tmp;
buf[((i / sf) * (sf * chns)) + (j * sf) + (i % sf)] = *((signed short *)&(var.two[0])); // 16-bit original
bits += 26LL;
}
}
}
void UI_NEXFIN2EDFwindow::SelectFileButton()
{
FILE *inputfile=NULL,
*outputfile=NULL;
int i, j, k, p,
temp,
separator=';',
edfsignals=0,
ok,
timestep,
new_smpl_time=0,
str_start,
column,
line_nr;
long long datarecords=-1LL,
file_size;
char txt_string[2048],
path[512],
outputfilename[MAX_PATH_LENGTH],
line[2048],
scratchpad[128],
labels[MAX_SIGNALS][17],
phys_dim[MAX_SIGNALS][9],
phys_min[MAX_SIGNALS][9],
phys_max[MAX_SIGNALS][9],
patientname[81],
recording[81],
datetime[17];
double sensitivity[MAX_SIGNALS],
new_value[MAX_SIGNALS],
old_value[MAX_SIGNALS];
union{
short two;
char one[2];
} var;
if(radio100button->isChecked()==true)
{
file_type = 100;
}
if(radio103button->isChecked()==true)
{
file_type = 103;
}
if(radio032button->isChecked()==true)
{
file_type = 32;
}
for(j=0; j<MAX_SIGNALS; j++)
{
old_value[j] = 0.0;
}
enable_widgets(false);
if(!(strlen(PatientnameLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subject name.");
messagewindow.exec();
enable_widgets(true);
return;
}
if(!(strlen(RecordingLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recordingdescription.");
messagewindow.exec();
enable_widgets(true);
return;
}
if(file_type==100)
{
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "CSV files (*_100.csv *_100.CSV)").toLocal8Bit().data());
}
if(file_type==103)
{
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "BIN files (*_103.bin *_103.BIN)").toLocal8Bit().data());
}
if(file_type==32)
{
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "BIN files (*_032.bin *_032.BIN)").toLocal8Bit().data());
}
if(!strcmp(path, ""))
{
enable_widgets(true);
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
inputfile = fopeno(path, "rb");
if(inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(txt_string));
messagewindow.exec();
enable_widgets(true);
return;
}
if(file_type==100)
{
/***************** check if the txtfile is valid ******************************/
rewind(inputfile);
if(fread(scratchpad, 32, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not read from file.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(strncmp(scratchpad, "Time;IBI;HR;LVET;HRS;Sys;Dia;MAP", 32))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown data in file (1).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
/***************** collect items *****************************************/
rewind(inputfile);
while(1)
{
temp = fgetc(inputfile);
if(temp==EOF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (5).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(temp==separator)
{
break;
}
}
i = 0;
while(temp!='\n')
{
temp = fgetc(inputfile);
if(temp==EOF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (6).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(temp=='\r')
{
continue;
}
if(((temp==separator)||(temp=='\n'))&&(edfsignals<7))
{
if(edfsignals>=MAX_SIGNALS)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Too many labels/signals (7).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
line[i] = 0;
ok = 0;
if(!strcmp(line, "IBI"))
{
strcpy(labels[edfsignals], "IBI ");
strcpy(phys_dim[edfsignals], "s ");
strcpy(phys_min[edfsignals], "-31.744 ");
strcpy(phys_max[edfsignals], "31.744 ");
sensitivity[edfsignals] = 1000.0;
ok = 1;
}
if(!strcmp(line, "HR"))
{
strcpy(labels[edfsignals], "HR ");
strcpy(phys_dim[edfsignals], "bpm ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "LVET"))
{
strcpy(labels[edfsignals], "LVET ");
strcpy(phys_dim[edfsignals], "s ");
strcpy(phys_min[edfsignals], "-10 ");
strcpy(phys_max[edfsignals], "10 ");
sensitivity[edfsignals] = 3174.4;
ok = 1;
}
if(!strcmp(line, "HRS"))
{
strcpy(labels[edfsignals], "HRS ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "Sys"))
{
strcpy(labels[edfsignals], "Sys ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "Dia"))
{
strcpy(labels[edfsignals], "Dia ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!strcmp(line, "MAP"))
{
strcpy(labels[edfsignals], "MAP ");
strcpy(phys_dim[edfsignals], "mmHg ");
strcpy(phys_min[edfsignals], "-1024 ");
strcpy(phys_max[edfsignals], "1024 ");
sensitivity[edfsignals] = 31.0;
ok = 1;
}
if(!ok)
{
snprintf(txt_string, 2048, "Found unknown label/signal: %s", line);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
edfsignals++;
i = 0;
}
if(temp==separator)
{
continue;
}
line[i++] = temp;
}
if(!edfsignals)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There are no labels/signals.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
} /********** end if(file_type==100) ********************/
if(file_type==103)
{
edfsignals = 1;
}
if(file_type==32)
{
if(analoginputscombobox->currentIndex()==1)
{
edfsignals = 4;
}
else
{
edfsignals = 1;
}
}
p = sprintf(patientname, "%s", PatientnameLineEdit->text().toLatin1().data());
latin1_to_ascii(patientname, p);
for( ; p<80; p++)
{
patientname[p] = ' ';
}
patientname[80] = 0;
p = sprintf(recording, "%s", RecordingLineEdit->text().toLatin1().data());
latin1_to_ascii(recording, p);
for( ; p<80; p++)
{
recording[p] = ' ';
}
recording[80] = 0;
sprintf(datetime,
"%02i.%02i.%02i%02i.%02i.%02i",
StartDatetimeedit->date().day(),
StartDatetimeedit->date().month(),
StartDatetimeedit->date().year() % 100,
StartDatetimeedit->time().hour(),
StartDatetimeedit->time().minute(),
StartDatetimeedit->time().second());
datetime[16] = 0;
/***************** write header *****************************************/
get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH);
remove_extension_from_filename(outputfilename);
strcat(outputfilename, ".edf");
path[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(path, recent_savedir);
strcat(path, "/");
}
strcat(path, outputfilename);
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
enable_widgets(true);
fclose(inputfile);
return;
}
get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH);
outputfile = fopeno(path, "wb");
if(outputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for writing.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
enable_widgets(true);
fclose(inputfile);
return;
}
fprintf(outputfile, "0 ");
fprintf(outputfile, "%s", patientname);
fprintf(outputfile, "%s", recording);
fprintf(outputfile, "%s", datetime);
fprintf(outputfile, "%-8i", 256 * edfsignals + 256);
fprintf(outputfile, " ");
fprintf(outputfile, "-1 ");
if(file_type==100)
{
fprintf(outputfile, "0.01 ");
}
if(file_type==103)
{
fprintf(outputfile, "0.005 ");
}
if(file_type==32)
{
fprintf(outputfile, "0.005 ");
}
fprintf(outputfile, "%-4i", edfsignals);
if(file_type==100)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", labels[i]);
}
}
if(file_type==103)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "Blood pressure ");
}
}
if(file_type==32)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "AD-%i ", i + 1);
}
}
for(i=0; i<(80*edfsignals); i++)
{
fputc(' ', outputfile);
}
if(file_type==100)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", phys_dim[i]);
}
}
if(file_type==103)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "mmHg ");
}
}
if(file_type==32)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "mV ");
}
}
if(file_type==100)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", phys_min[i]);
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "%s", phys_max[i]);
}
}
if(file_type==103)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "-8192 ");
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "8191.75 ");
}
}
if(file_type==32)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "-81920 ");
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "81917.5 ");
}
}
if(file_type==100)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "-31744 ");
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "31744 ");
}
}
if(file_type==103)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "-32768 ");
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "32767 ");
}
}
if(file_type==32)
{
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "-32768 ");
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "32767 ");
}
}
for(i=0; i<(80*edfsignals); i++)
{
fputc(' ', outputfile);
}
for(i=0; i<edfsignals; i++)
{
fprintf(outputfile, "1 ");
}
for(i=0; i<(32*edfsignals); i++)
{
fputc(' ', outputfile);
}
/***************** start conversion **************************************/
rewind(inputfile);
if(file_type==100) /*** filetype is 100 **********/
{
for(i=0; ; )
{
temp = fgetc(inputfile);
if(temp==EOF)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (8).");
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
if(temp=='\n') i++;
if(i>0) break;
}
QApplication::setOverrideCursor(Qt::WaitCursor);
for(k=0; k<10; k++) qApp->processEvents();
i = 0;
column = 0;
datarecords = 0LL;
str_start = 0;
line_nr = 1;
while(1)
{
temp = fgetc(inputfile);
if(temp==EOF)
{
for(k=0; k<edfsignals; k++)
{
temp = (int)(new_value[k] * sensitivity[k]);
if(temp>31744) temp = 31744;
if(temp<-31744) temp = -31744;
var.two = (short)temp;
fputc(var.one[0], outputfile);
fputc(var.one[1], outputfile);
}
datarecords++;
break;
}
line[i] = temp;
/**************************************/
if(line[i]==',')
{
line[i] = '.';
}
if((line[i]==separator)||(line[i]=='\n'))
{
if(column)
{
new_value[column-1] = atof(line + str_start);
}
else
{
new_smpl_time = (int)(atof(line + str_start) * 100.0);
}
if(line[i]=='\n')
{
/**************************************/
line_nr++;
if(column!=edfsignals)
{
QApplication::restoreOverrideCursor();
snprintf(txt_string, 2048, "Number of separators in line %i is wrong.", line_nr);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
timestep = new_smpl_time - datarecords;
if(timestep<=0)
{
QApplication::restoreOverrideCursor();
snprintf(txt_string, 2048, "Timestep <= 0 in line %i.", line_nr);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
for(j=0; j<timestep; j++)
{
for(k=0; k<edfsignals; k++)
{
temp = (int)((old_value[k] + ((new_value[k] - old_value[k]) * ((double)j / (double)timestep))) * sensitivity[k]);
if(temp>31744) temp = 31744;
if(temp<-31744) temp = -31744;
var.two = (short)temp;
fputc(var.one[0], outputfile);
fputc(var.one[1], outputfile);
}
datarecords++;
}
for(j=0; j<edfsignals; j++)
{
old_value[j] = new_value[j];
}
/**************************************/
str_start = 0;
i = 0;
column = 0;
continue;
}
str_start = i + 1;
column++;
}
/**************************************/
i++;
if(i>2046)
{
QApplication::restoreOverrideCursor();
snprintf(txt_string, 2048, "Line %i is too long.", line_nr);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
}
} /********** end if(file_type==100) ********************/
if((file_type==103) || (file_type==32))
{
fseeko(inputfile, 0LL, SEEK_END);
file_size = ftello(inputfile);
file_size /= 2LL;
file_size /= edfsignals;
rewind(inputfile);
QApplication::setOverrideCursor(Qt::WaitCursor);
for(k=0; k<10; k++) qApp->processEvents();
if(file_type==103)
{
for(datarecords=0LL; datarecords<file_size; datarecords++)
{
temp = fgetc(inputfile);
fputc(temp, outputfile);
temp = fgetc(inputfile);
if(temp==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (18).");
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
fputc(temp, outputfile);
}
}
if(file_type==32)
{
k = edfsignals * 2 - 1;
for(datarecords=0LL; datarecords<file_size; datarecords++)
{
for(i=0; i<k; i++)
{
temp = fgetc(inputfile);
fputc(temp, outputfile);
}
temp = fgetc(inputfile);
if(temp==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (28).");
messagewindow.exec();
fclose(inputfile);
fclose(outputfile);
enable_widgets(true);
return;
}
fputc(temp, outputfile);
}
}
}
QApplication::restoreOverrideCursor();
fseeko(outputfile, 236LL, SEEK_SET);
#ifdef Q_OS_WIN32
__mingw_fprintf(outputfile, "%-8lli", datarecords);
#else
fprintf(outputfile, "%-8lli", datarecords);
#endif
if(fclose(outputfile))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while closing outputfile.");
messagewindow.exec();
enable_widgets(true);
fclose(inputfile);
return;
}
if(fclose(inputfile))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while closing inputfile.");
messagewindow.exec();
}
snprintf(txt_string, 2048, "Done, EDF file is located at %s", path);
QMessageBox messagewindow(QMessageBox::Information, "Ready", QString::fromLocal8Bit(txt_string));
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
enable_widgets(true);
}
void UI_EDFDwindow::SelectFileButton()
{
FILE *inputfile=NULL,
*outputfile=NULL;
int i,
file_number,
offset,
offset_2,
datarecords,
datarecords_read,
datarecords_written,
cnt,
annot_signal_size,
annot_signal_size_2,
annot_signal_nr,
annot_signal_nr_2,
annots_written,
len,
progress_steps;
long long former_timestamp,
next_timestamp,
new_hdr_timestamp,
chunk_starttime,
chunk_endtime;
char txt_string[2048],
inputpath[MAX_PATH_LENGTH],
output_path[MAX_PATH_LENGTH],
*fileheader,
*readbuf,
*tal;
struct annotationblock *annotationlist[1],
*annotblock;
struct edfhdrblock *edfhdr=NULL;
pushButton1->setEnabled(false);
strcpy(inputpath, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "EDF/BDF files (*.edf *.EDF *.bdf *.BDF *.rec *.REC)").toLocal8Bit().data());
if(!strcmp(inputpath, ""))
{
pushButton1->setEnabled(true);
return;
}
get_directory_from_path(recent_opendir, inputpath, MAX_PATH_LENGTH);
inputfile = fopeno(inputpath, "rb");
if(inputfile==NULL)
{
snprintf(txt_string, 2048, "Error, can not open file %s for reading.\n", inputpath);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
return;
}
snprintf(txt_string, 2048, "Processing file %s", inputpath);
textEdit1->append(txt_string);
/***************** check if the file is valid ******************************/
EDFfileCheck EDFfilechecker;
edfhdr = EDFfilechecker.check_edf_file(inputfile, txt_string);
if(edfhdr==NULL)
{
fclose(inputfile);
textEdit1->append("Error, file is not a valid EDF or BDF file.\n");
pushButton1->setEnabled(true);
return;
}
if(((!edfhdr->edfplus)&&(!edfhdr->bdfplus))||(!edfhdr->discontinuous))
{
free(edfhdr->edfparam);
free(edfhdr);
fclose(inputfile);
textEdit1->append("Error, file is not an EDF+D or BDF+D file.\n");
pushButton1->setEnabled(true);
return;
}
/****************** get annotations ******************************/
edfhdr->file_hdl = inputfile;
EDF_annotations annotations_func;
annotationlist[0] = NULL;
if(annotations_func.get_annotations(0, edfhdr, &annotationlist[0], 0))
{
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
fclose(inputfile);
textEdit1->append("Error, there is an incompatibility with the annotations.\n");
pushButton1->setEnabled(true);
return;
}
if(edfhdr->annots_not_read)
{
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
fclose(inputfile);
textEdit1->append("Aborted.\n");
pushButton1->setEnabled(true);
return;
}
annotblock = annotationlist[0];
/***************** start conversion ******************************/
datarecords = edfhdr->datarecords;
annot_signal_nr = edfhdr->annot_ch[0];
offset = edfhdr->edfparam[annot_signal_nr].buf_offset;
if(edfhdr->edfplus)
{
annot_signal_size = edfhdr->edfparam[annot_signal_nr].smp_per_record * 2;
}
else
{
annot_signal_size = edfhdr->edfparam[annot_signal_nr].smp_per_record * 3;
}
fileheader = (char *)calloc(1, edfhdr->hdrsize);
if(fileheader==NULL)
{
textEdit1->append("Malloc error, (fileheader).\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
readbuf = (char *)calloc(1, edfhdr->recordsize);
if(readbuf==NULL)
{
textEdit1->append("Malloc error, (readbuf).\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
rewind(inputfile);
if(fread(fileheader, edfhdr->hdrsize, 1, inputfile) != 1)
{
textEdit1->append("Read error.\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
///////////////////////////////////////////////////////////////////
file_number = 1;
strcpy(output_path, inputpath);
remove_extension_from_filename(output_path);
if(edfhdr->edfplus)
{
sprintf(output_path + strlen(output_path), "_%04i.edf", file_number);
}
else
{
sprintf(output_path + strlen(output_path), "_%04i.bdf", file_number);
}
strcpy(txt_string, "Creating file ");
len = strlen(txt_string);
get_filename_from_path(txt_string + len, output_path, MAX_PATH_LENGTH - len);
textEdit1->append(QString::fromLocal8Bit(txt_string));
outputfile = fopeno(output_path, "w+b");
if(outputfile==NULL)
{
textEdit1->append("Error, can not open outputfile for writing.\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
if(fwrite(fileheader, edfhdr->hdrsize, 1, outputfile) != 1)
{
textEdit1->append("Write error.\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
fclose(outputfile);
pushButton1->setEnabled(true);
return;
}
QProgressDialog progress("Processing file...", "Abort", 0, datarecords);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = datarecords / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
datarecords_written = 0;
new_hdr_timestamp = 0LL;
former_timestamp = 0LL;
next_timestamp = 0LL;
chunk_starttime = 0LL;
chunk_endtime = 0LL;
tal = readbuf + offset;
fseeko(inputfile, (long long)(edfhdr->hdrsize), SEEK_SET);
for(datarecords_read=0; datarecords_read<datarecords; datarecords_read++)
{
if(!(datarecords_read%progress_steps))
{
progress.setValue(datarecords_read);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
textEdit1->append("Aborted.\n");
break;
}
}
if(fread(readbuf, edfhdr->recordsize, 1, inputfile) != 1)
{
progress.reset();
textEdit1->append("Read error.\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
fclose(outputfile);
pushButton1->setEnabled(true);
return;
}
if(edfhdr->nr_annot_chns>1)
{
for(i=1; i<edfhdr->nr_annot_chns; i++)
{
annot_signal_nr_2 = edfhdr->annot_ch[i];
offset_2 = edfhdr->edfparam[annot_signal_nr_2].buf_offset;
if(edfhdr->edfplus)
{
annot_signal_size_2 = edfhdr->edfparam[annot_signal_nr_2].smp_per_record * 2;
}
else
{
annot_signal_size_2 = edfhdr->edfparam[annot_signal_nr_2].smp_per_record * 3;
}
memset(readbuf + offset_2, 0, annot_signal_size_2);
}
}
next_timestamp = get_datarecord_timestamp(tal);
if(!datarecords_read)
{
former_timestamp = next_timestamp - edfhdr->long_data_record_duration;
}
if(next_timestamp!=(former_timestamp + edfhdr->long_data_record_duration))
{
chunk_endtime = next_timestamp;
write_values_to_hdr(outputfile, new_hdr_timestamp, datarecords_written, edfhdr);
annotblock = annotationlist[0];
annots_written = 0;
if(annotblock!=NULL)
{
while(annotblock!=NULL)
{
if(((annotblock->onset>=chunk_starttime)||(file_number==1))
&&(annotblock->onset<chunk_endtime)
&&(annots_written<datarecords_written))
{
fseeko(outputfile, (long long)(edfhdr->hdrsize + (annots_written * edfhdr->recordsize) + offset), SEEK_SET);
for(cnt=1; ; cnt++)
{
if(fgetc(outputfile)==0) break;
}
fseeko(outputfile, 0LL, SEEK_CUR);
cnt += fprintf(outputfile, "+%i", (int)((annotblock->onset - new_hdr_timestamp) / TIME_DIMENSION));
if(annotblock->onset%TIME_DIMENSION)
{
cnt += fprintf(outputfile, ".%07i", (int)((annotblock->onset - new_hdr_timestamp) % TIME_DIMENSION));
fseeko(outputfile, -1LL, SEEK_CUR);
while(fgetc(outputfile)=='0')
{
fseeko(outputfile, -2LL, SEEK_CUR);
cnt--;
}
}
fseeko(outputfile, 0LL, SEEK_CUR);
if(annotblock->duration[0]!=0)
{
fputc(21, outputfile);
cnt++;
cnt += fprintf(outputfile, "%s", annotblock->duration);
}
fputc(20, outputfile);
cnt++;
for(i = 0; i < (annot_signal_size - cnt - 2); i++)
{
if(annotblock->annotation[i]==0) break;
fputc(annotblock->annotation[i], outputfile);
cnt++;
}
fputc(20, outputfile);
cnt++;
for(i = cnt; i < annot_signal_size; i++)
{
fputc(0, outputfile);
}
annots_written++;
}
annotblock = annotblock->next_annotation;
}
}
fclose(outputfile);
datarecords_written = 0;
new_hdr_timestamp = next_timestamp;
new_hdr_timestamp -= next_timestamp % TIME_DIMENSION;
chunk_starttime = next_timestamp;
file_number++;
strcpy(output_path, inputpath);
remove_extension_from_filename(output_path);
if(edfhdr->edfplus)
{
sprintf(output_path + strlen(output_path), "_%04i.edf", file_number);
}
else
{
sprintf(output_path + strlen(output_path), "_%04i.bdf", file_number);
}
strcpy(txt_string, "Creating file ");
len = strlen(txt_string);
get_filename_from_path(txt_string + len, output_path, MAX_PATH_LENGTH - len);
textEdit1->append(txt_string);
outputfile = fopeno(output_path, "w+b");
if(outputfile==NULL)
{
textEdit1->append("Error, can not open outputfile for writing.\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
if(fwrite(fileheader, edfhdr->hdrsize, 1, outputfile) != 1)
{
textEdit1->append("Write error.\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
fclose(outputfile);
pushButton1->setEnabled(true);
return;
}
}
cnt = sprintf(tal, "+%i", (int)((next_timestamp - new_hdr_timestamp) / TIME_DIMENSION));
if((next_timestamp - new_hdr_timestamp)%TIME_DIMENSION)
{
cnt += sprintf(tal + cnt, ".%07i", (int)((next_timestamp - new_hdr_timestamp) % TIME_DIMENSION));
for(i=cnt-1; i>0; i--)
{
if(tal[i]!='0') break;
cnt--;
}
}
tal[cnt++] = 20;
tal[cnt++] = 20;
for(i=cnt; i<annot_signal_size; i++)
{
tal[i] = 0;
}
if(fwrite(readbuf, edfhdr->recordsize, 1, outputfile) != 1)
{
progress.reset();
textEdit1->append("Write error.\n");
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
fclose(outputfile);
pushButton1->setEnabled(true);
return;
}
datarecords_written++;
former_timestamp = next_timestamp;
}
write_values_to_hdr(outputfile, new_hdr_timestamp, datarecords_written, edfhdr);
annotblock = annotationlist[0];
annots_written = 0;
if(annotblock!=NULL)
{
while(annotblock!=NULL)
{
if((annotblock->onset>=chunk_starttime)&&(annots_written<datarecords_written))
{
fseeko(outputfile, (long long)(edfhdr->hdrsize + (annots_written * edfhdr->recordsize) + offset), SEEK_SET);
for(cnt=1; ; cnt++)
{
if(fgetc(outputfile)==0) break;
}
fseeko(outputfile, 0LL, SEEK_CUR);
cnt += fprintf(outputfile, "+%i", (int)((annotblock->onset - new_hdr_timestamp) / TIME_DIMENSION));
if(annotblock->onset%TIME_DIMENSION)
{
cnt += fprintf(outputfile, ".%07i", (int)((annotblock->onset - new_hdr_timestamp) % TIME_DIMENSION));
fseeko(outputfile, -1LL, SEEK_CUR);
while(fgetc(outputfile)=='0')
{
fseeko(outputfile, -2LL, SEEK_CUR);
cnt--;
}
}
fseeko(outputfile, 0LL, SEEK_CUR);
if(annotblock->duration[0]!=0)
{
fputc(21, outputfile);
cnt++;
cnt += fprintf(outputfile, "%s", annotblock->duration);
}
fputc(20, outputfile);
cnt++;
for(i = 0; i < (annot_signal_size - cnt - 2); i++)
{
if(annotblock->annotation[i]==0) break;
fputc(annotblock->annotation[i], outputfile);
cnt++;
}
fputc(20, outputfile);
cnt++;
for(i = cnt; i < annot_signal_size; i++)
{
fputc(0, outputfile);
}
annots_written++;
}
annotblock = annotblock->next_annotation;
}
}
free_annotations(annotationlist[0]);
free(edfhdr->edfparam);
free(edfhdr);
free(fileheader);
free(readbuf);
fclose(inputfile);
fclose(outputfile);
progress.reset();
textEdit1->append("Done\n");
pushButton1->setEnabled(true);
}
void UI_RAW2EDFapp::savebuttonpressed()
{
char path[MAX_PATH_LENGTH],
str[128];
FILE *outputfile;
raw2edf_var->sf = SamplefreqSpinbox->value();
raw2edf_var->chns = SignalsSpinbox->value();
raw2edf_var->phys_max = PhysicalMaximumSpinbox->value();
raw2edf_var->straightbinary = EncodingCombobox->currentIndex();
raw2edf_var->endianness = EndiannessCombobox->currentIndex();
raw2edf_var->samplesize = SampleSizeSpinbox->value();
raw2edf_var->offset = OffsetSpinbox->value();
raw2edf_var->skipblocksize = skipblocksizeSpinbox->value();
raw2edf_var->skipbytes = skipbytesSpinbox->value();
strcpy(raw2edf_var->phys_dim, PhysicalDimensionLineEdit->text().toLatin1().data());
remove_leading_spaces(raw2edf_var->phys_dim);
remove_trailing_spaces(raw2edf_var->phys_dim);
path[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(path, recent_savedir);
strcat(path, "/");
}
strcat(path, "binary_to_edf.template");
strcpy(path, QFileDialog::getSaveFileName(0, "Save parameters", QString::fromLocal8Bit(path), "Template files (*.template *.TEMPLATE)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH);
outputfile = fopeno(path, "wb");
if(outputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for writing.");
messagewindow.exec();
return;
}
fprintf(outputfile, "<?xml version=\"1.0\"?>\n<" PROGRAM_NAME "_raw2edf_template>\n");
fprintf(outputfile, " <sf>%i</sf>\n", raw2edf_var->sf);
fprintf(outputfile, " <chns>%i</chns>\n", raw2edf_var->chns);
fprintf(outputfile, " <phys_max>%i</phys_max>\n", raw2edf_var->phys_max);
fprintf(outputfile, " <straightbinary>%i</straightbinary>\n", raw2edf_var->straightbinary);
fprintf(outputfile, " <endianness>%i</endianness>\n", raw2edf_var->endianness);
fprintf(outputfile, " <samplesize>%i</samplesize>\n", raw2edf_var->samplesize);
fprintf(outputfile, " <offset>%i</offset>\n", raw2edf_var->offset);
fprintf(outputfile, " <skipblocksize>%i</skipblocksize>\n", raw2edf_var->skipblocksize);
fprintf(outputfile, " <skipbytes>%i</skipbytes>\n", raw2edf_var->skipbytes);
xml_strcpy_encode_entity(str, raw2edf_var->phys_dim);
fprintf(outputfile, " <phys_dim>%s</phys_dim>\n", str);
fprintf(outputfile, "</" PROGRAM_NAME "_raw2edf_template>\n");
fclose(outputfile);
}
void ColorOptions::saveColorSchemaButtonClicked()
{
char path[MAX_PATH_LENGTH];
FILE *colorfile;
strcpy(path, mainwindow->recent_colordir);
strcat(path, "/my_colorscheme.color");
strcpy(path, QFileDialog::getSaveFileName(0, "Save color scheme", QString::fromLocal8Bit(path), "Color scheme files (*.color *.COLOR)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
if(strlen(path) > 4)
{
if(strcmp(path + strlen(path) - 6, ".color")) // check if the ending is '.color'
{
strcat(path, ".color"); // if not : append it to the string.
}
}
get_directory_from_path(mainwindow->recent_colordir, path, MAX_PATH_LENGTH);
colorfile = fopen(path, "wb");
if(colorfile == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for writing.");
messagewindow.exec();
return;
}
fprintf(colorfile, "<?xml version=\"1.0\"?>\n<" PROGRAM_NAME "_colorschema>\n");
fprintf(colorfile, " <backgroundcolor>\n"
" <red>%i</red>\n"
" <green>%i</green>\n"
" <blue>%i</blue>\n"
" </backgroundcolor>\n",
mainwindow->maincurve->backgroundcolor.red(),
mainwindow->maincurve->backgroundcolor.green(),
mainwindow->maincurve->backgroundcolor.blue());
fprintf(colorfile, " <small_ruler_color>\n"
" <red>%i</red>\n"
" <green>%i</green>\n"
" <blue>%i</blue>\n"
" </small_ruler_color>\n",
mainwindow->maincurve->small_ruler_color.red(),
mainwindow->maincurve->small_ruler_color.green(),
mainwindow->maincurve->small_ruler_color.blue());
fprintf(colorfile, " <big_ruler_color>\n"
" <red>%i</red>\n"
" <green>%i</green>\n"
" <blue>%i</blue>\n"
" </big_ruler_color>\n",
mainwindow->maincurve->big_ruler_color.red(),
mainwindow->maincurve->big_ruler_color.green(),
mainwindow->maincurve->big_ruler_color.blue());
fprintf(colorfile, " <mouse_rect_color>\n"
" <red>%i</red>\n"
" <green>%i</green>\n"
" <blue>%i</blue>\n"
" </mouse_rect_color>\n",
mainwindow->maincurve->mouse_rect_color.red(),
mainwindow->maincurve->mouse_rect_color.green(),
mainwindow->maincurve->mouse_rect_color.blue());
fprintf(colorfile, " <text_color>\n"
" <red>%i</red>\n"
" <green>%i</green>\n"
" <blue>%i</blue>\n"
" </text_color>\n",
mainwindow->maincurve->text_color.red(),
mainwindow->maincurve->text_color.green(),
mainwindow->maincurve->text_color.blue());
fprintf(colorfile, " <baseline_color>\n"
" <red>%i</red>\n"
" <green>%i</green>\n"
" <blue>%i</blue>\n"
" </baseline_color>\n",
mainwindow->maincurve->baseline_color.red(),
mainwindow->maincurve->baseline_color.green(),
mainwindow->maincurve->baseline_color.blue());
fprintf(colorfile, " <annot_marker_color>\n"
" <red>%i</red>\n"
" <green>%i</green>\n"
" <blue>%i</blue>\n"
" </annot_marker_color>\n",
mainwindow->maincurve->annot_marker_color.red(),
mainwindow->maincurve->annot_marker_color.green(),
mainwindow->maincurve->annot_marker_color.blue());
fprintf(colorfile, " <signal_color>%i</signal_color>\n",
mainwindow->maincurve->signal_color);
fprintf(colorfile, " <crosshair_1_color>%i</crosshair_1_color>\n",
mainwindow->maincurve->crosshair_1.color);
fprintf(colorfile, " <crosshair_2_color>%i</crosshair_2_color>\n",
mainwindow->maincurve->crosshair_2.color);
fprintf(colorfile, " <floating_ruler_color>%i</floating_ruler_color>\n",
mainwindow->maincurve->floating_ruler_color);
fprintf(colorfile, " <blackwhite_printing>%i</blackwhite_printing>\n",
mainwindow->maincurve->blackwhite_printing);
fprintf(colorfile, " <show_annot_markers>%i</show_annot_markers>\n",
mainwindow->show_annot_markers);
fprintf(colorfile, " <show_baselines>%i</show_baselines>\n",
mainwindow->show_baselines);
fprintf(colorfile, " <clip_to_pane>%i</clip_to_pane>\n",
mainwindow->clip_to_pane);
fprintf(colorfile, "</" PROGRAM_NAME "_colorschema>\n");
fclose(colorfile);
}
void UI_RAW2EDFapp::loadbuttonpressed()
{
char path[MAX_PATH_LENGTH],
*result;
struct xml_handle *xml_hdl;
strcpy(path, QFileDialog::getOpenFileName(0, "Load parameters", QString::fromLocal8Bit(recent_opendir), "Template files (*.template *.TEMPLATE)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
xml_hdl = xml_get_handle(path);
if(xml_hdl==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for reading.");
messagewindow.exec();
return;
}
if(strcmp(xml_hdl->elementname, PROGRAM_NAME "_raw2edf_template"))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this template.");
messagewindow.exec();
xml_close(xml_hdl);
return;
}
if(!(xml_goto_nth_element_inside(xml_hdl, "sf", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->sf = atoi(result);
if(raw2edf_var->sf < 1) raw2edf_var->sf = 1;
if(raw2edf_var->sf > 1000000) raw2edf_var->sf = 1000000;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "chns", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->chns = atoi(result);
if(raw2edf_var->chns < 1) raw2edf_var->chns = 1;
if(raw2edf_var->chns > 256) raw2edf_var->chns = 256;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "phys_max", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->phys_max = atoi(result);
if(raw2edf_var->phys_max < 1) raw2edf_var->phys_max = 1;
if(raw2edf_var->phys_max > 10000000) raw2edf_var->phys_max = 10000000;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "straightbinary", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->straightbinary = atoi(result);
if(raw2edf_var->straightbinary < 0) raw2edf_var->straightbinary = 0;
if(raw2edf_var->straightbinary > 1) raw2edf_var->straightbinary = 1;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "endianness", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->endianness = atoi(result);
if(raw2edf_var->endianness < 0) raw2edf_var->endianness = 0;
if(raw2edf_var->endianness > 1) raw2edf_var->endianness = 1;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "samplesize", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->samplesize = atoi(result);
if(raw2edf_var->samplesize < 1) raw2edf_var->samplesize = 1;
if(raw2edf_var->samplesize > 2) raw2edf_var->samplesize = 2;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "offset", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->offset = atoi(result);
if(raw2edf_var->offset < 0) raw2edf_var->offset = 0;
if(raw2edf_var->offset > 1000000) raw2edf_var->offset = 1000000;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "skipblocksize", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->skipblocksize = atoi(result);
if(raw2edf_var->skipblocksize < 0) raw2edf_var->skipblocksize = 0;
if(raw2edf_var->skipblocksize > 1000000) raw2edf_var->skipblocksize = 1000000;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "skipbytes", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
raw2edf_var->skipbytes = atoi(result);
if(raw2edf_var->skipbytes < 1) raw2edf_var->skipbytes = 1;
if(raw2edf_var->skipbytes > 1000000) raw2edf_var->skipbytes = 1000000;
free(result);
xml_go_up(xml_hdl);
}
if(!(xml_goto_nth_element_inside(xml_hdl, "phys_dim", 0)))
{
result = xml_get_content_of_element(xml_hdl);
if(result==NULL)
{
xml_close(xml_hdl);
return;
}
strncpy(raw2edf_var->phys_dim, result, 16);
raw2edf_var->phys_dim[15] = 0;
latin1_to_ascii(raw2edf_var->phys_dim, 16);
remove_leading_spaces(raw2edf_var->phys_dim);
remove_trailing_spaces(raw2edf_var->phys_dim);
free(result);
xml_go_up(xml_hdl);
}
xml_close(xml_hdl);
SamplefreqSpinbox->setValue(raw2edf_var->sf);
SignalsSpinbox->setValue(raw2edf_var->chns);
PhysicalMaximumSpinbox->setValue(raw2edf_var->phys_max);
EncodingCombobox->setCurrentIndex(raw2edf_var->straightbinary);
EndiannessCombobox->setCurrentIndex(raw2edf_var->endianness);
SampleSizeSpinbox->setValue(raw2edf_var->samplesize);
OffsetSpinbox->setValue(raw2edf_var->offset);
skipblocksizeSpinbox->setValue(raw2edf_var->skipblocksize);
skipbytesSpinbox->setValue(raw2edf_var->skipbytes);
}
void UI_headerEditorWindow::open_file()
{
long long filesize;
if(file != NULL)
{
fclose(file);
file = NULL;
}
edf = 0;
bdf = 0;
edfplus = 0;
bdfplus = 0;
edfsignals = 0;
disconnect(lineEdit3, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &)));
disconnect(lineEdit4, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &)));
disconnect(lineEdit5, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &)));
disconnect(lineEdit6, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &)));
disconnect(lineEdit7, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &)));
disconnect(lineEdit8, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &)));
disconnect(lineEdit9, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &)));
lineEdit3->setMaxLength(80);
lineEdit4->setMaxLength(80);
lineEdit5->setMaxLength(80);
lineEdit6->setMaxLength(80);
lineEdit7->setMaxLength(80);
lineEdit8->setMaxLength(80);
lineEdit9->setMaxLength(80);
lineEdit1->clear();
lineEdit2->clear();
lineEdit3->clear();
lineEdit4->clear();
lineEdit5->clear();
lineEdit6->clear();
lineEdit7->clear();
lineEdit8->clear();
lineEdit9->clear();
signallist->setRowCount(0);
fileNameLabel->clear();
if(hdr==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred. (hdr)");
messagewindow.exec();
return;
}
strcpy(path, QFileDialog::getOpenFileName(0, "Open file", QString::fromLocal8Bit(mainwindow->recent_opendir), "EDF/BDF files (*.edf *.EDF *.bdf *.BDF)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_opendir, path, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(path))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is in use.");
messagewindow.exec();
return;
}
file = fopeno(path, "r+b");
if(file==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file.");
messagewindow.exec();
return;
}
rewind(file);
if(fread(hdr, 256, 1, file) != 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not read from file.");
messagewindow.exec();
fclose(file);
file = NULL;
return;
}
if(!(strncmp(hdr, "0 ", 8))) edf = 1;
if((!(strncmp(hdr + 1, "BIOSEMI", 7))) && (((unsigned char *)hdr)[0] == 255))
{
bdf = 1;
}
if((!edf) && (!bdf))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "File is not a valid EDF or BDF file.\n"
"Invalid version.");
messagewindow.exec();
fclose(file);
file = NULL;
return;
}
edfsignals = antoi(hdr + 252, 4);
if(edfsignals < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Invalid number of signals in header (less than 1)");
messagewindow.exec();
fclose(file);
file = NULL;
return;
}
if(edfsignals > 2049)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Number of signals in header is more than 2048.\n"
"This tool can not process more than 2048 signals.");
messagewindow.exec();
fclose(file);
file = NULL;
return;
}
fseeko(file, 0LL, SEEK_END);
filesize = ftello(file);
if(filesize < (((edfsignals + 1LL) * 256LL) + edfsignals))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Filesize is too small.\n"
"Can not fix this file.");
messagewindow.exec();
fclose(file);
file = NULL;
return;
}
if((!(strncmp(hdr + 192, "EDF+C", 5))) || (!(strncmp(hdr + 192, "EDF+D", 5))))
{
edfplus = 1;
}
if((!(strncmp(hdr + 192, "BDF+C", 5))) || (!(strncmp(hdr + 192, "BDF+D", 5))))
{
bdfplus = 1;
}
read_header();
}
void UI_BDF2EDFwindow::SelectFileButton()
{
int i;
char txt_string[2048];
if(edfhdr!=NULL)
{
label1->setText("");
SignalsTablewidget->setRowCount(0);
free_edfheader();
inputfile = NULL;
outputfile = NULL;
inputpath[0] = 0;
pushButton3->setEnabled(false);
pushButton4->setEnabled(false);
pushButton5->setEnabled(false);
}
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);
inputfile = fopeno(inputpath, "rb");
if(inputfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading.", inputpath);
QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(txt_string));
messagewindow.exec();
return;
}
/***************** check if the file is valid ******************************/
EDFfileCheck EDFfilechecker;
edfhdr = EDFfilechecker.check_edf_file(inputfile, txt_string);
if(edfhdr==NULL)
{
fclose(inputfile);
QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string);
messagewindow.exec();
return;
}
if(!edfhdr->bdf)
{
fclose(inputfile);
QMessageBox messagewindow(QMessageBox::Critical, "Error", "File is not a BDF file.");
messagewindow.exec();
free_edfheader();
return;
}
/***************** load signalproperties ******************************/
label1->setText(QString::fromLocal8Bit(inputpath));
SignalsTablewidget->setRowCount(edfhdr->edfsignals);
for(i=0; i<edfhdr->edfsignals; i++)
{
SignalsTablewidget->setRowHeight(i, 25);
SignalsTablewidget->setCellWidget(i, 0, new QCheckBox(edfhdr->edfparam[i].label));
((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->setTristate(false);
((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->setCheckState(Qt::Checked);
if(!edfhdr->edfparam[i].annotation)
{
SignalsTablewidget->setCellWidget(i, 1, new QDoubleSpinBox);
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setDecimals(3);
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setSuffix(" Hz");
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setRange(0.001, 100.0);
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setValue(spinBox1->value());
SignalsTablewidget->setCellWidget(i, 2, new QDoubleSpinBox);
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->setDecimals(3);
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->setRange(1.0, 256.0);
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->setValue(spinBox2->value());
}
else
{
((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->setEnabled(false);
}
}
pushButton3->setEnabled(true);
pushButton4->setEnabled(true);
pushButton5->setEnabled(true);
}
void print_screen_to_edf(UI_Mainwindow *mainwindow)
{
int i, j, k, p,
n=0,
records,
records_written,
signalcomps,
duration_factor[MAXFILES],
temp=0,
edfplus=0,
tallen,
annotationlist_nr=0,
annotations_left=1,
add_one_sec=0,
annot_smp_per_record=16,
type,
len;
long long duration,
smpls_written[MAXSIGNALS],
s2,
preamble=0LL,
smpls_preamble[MAXSIGNALS],
taltime=0LL,
l_temp,
referencetime,
annot_difftime=0LL;
char path[MAX_PATH_LENGTH],
scratchpad[512],
datrecduration[8],
*viewbuf;
double frequency,
frequency2,
dig_value;
FILE *outputfile;
struct signalcompblock **signalcomp;
union {
signed int one_signed;
signed short two_signed[2];
unsigned char four[4];
} wr_var;
union {
signed short one_signed;
unsigned char two[2];
} null_bytes[MAXSIGNALS];
struct annotationblock *annotations_pntr;
struct date_time_struct date_time;
/////////////////////////////////////////////////////////////////////////
signalcomps = mainwindow->signalcomps;
signalcomp = mainwindow->signalcomp;
viewbuf = mainwindow->viewbuf;
annotations_pntr = mainwindow->annotationlist[0];
if((!mainwindow->files_open)||(!signalcomps))
{
QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "Put a signal on the screen and try again.");
messagewindow.exec();
return;
}
for(i=0; i<mainwindow->files_open; i++)
{
if(mainwindow->edfheaderlist[i]->bdf)
{
QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "BDF files can not be printed to EDF.");
messagewindow.exec();
return;
}
if(mainwindow->edfheaderlist[i]->discontinuous)
{
QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "Sorry, discontinues EDF files can not be printed to EDF.");
messagewindow.exec();
return;
}
if(mainwindow->edfheaderlist[i]->edfplus)
{
edfplus = 1;
for(j=0; j<mainwindow->edfheaderlist[i]->nr_annot_chns; j++)
{
if(mainwindow->edfheaderlist[i]->edfparam[mainwindow->edfheaderlist[i]->annot_ch[j]].smp_per_record>annot_smp_per_record)
{
annot_smp_per_record = mainwindow->edfheaderlist[i]->edfparam[mainwindow->edfheaderlist[i]->annot_ch[j]].smp_per_record;
}
}
}
}
annot_smp_per_record += 16;
taltime = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset;
duration = 0;
for(i=0; i<signalcomps; i++)
{
if(signalcomp[i]->edfhdr->long_data_record_duration>duration)
{
duration = signalcomp[i]->edfhdr->long_data_record_duration;
n = i;
}
}
fseeko(signalcomp[n]->edfhdr->file_hdl, 244LL, SEEK_SET);
if(fread(datrecduration, 8, 1, signalcomp[n]->edfhdr->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
return;
}
temp = 0;
for(i=0; i<signalcomps; i++)
{
if(duration % signalcomp[i]->edfhdr->long_data_record_duration)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "This combination of files can not be printed to EDF\n"
"because the quotient of the datarecordblock durations is not an integer.");
messagewindow.exec();
return;
}
duration_factor[signalcomp[i]->filenum] = duration / signalcomp[i]->edfhdr->long_data_record_duration;
temp += signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record;
}
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[mainwindow->sel_viewtime]->filename, MAX_PATH_LENGTH - len);
remove_extension_from_filename(path);
strcat(path, "_screenprint.edf");
strcpy(path, QFileDialog::getSaveFileName(0, "Print to EDF", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(path))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, selected file is in use.");
messagewindow.exec();
return;
}
outputfile = fopeno(path, "wb");
if(outputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not create a file for writing.");
messagewindow.exec();
return;
}
referencetime = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime;
if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime<0)
{
if((-mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime) % TIME_DIMENSION)
{
preamble = TIME_DIMENSION - ((-mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime) % TIME_DIMENSION);
referencetime--;
add_one_sec = 1;
}
}
else
{
preamble = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime % TIME_DIMENSION;
if(preamble) add_one_sec = 1;
}
for(i=0; i<signalcomps; i++)
{
smpls_preamble[i] = preamble / (signalcomp[i]->edfhdr->long_data_record_duration / signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record);
}
referencetime += (mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime / TIME_DIMENSION);
utc_to_date_time(referencetime, &date_time);
/************************* write EDF-header ***************************************/
rewind(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl);
rewind(outputfile);
if(edfplus)
{
if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->edfplus)
{
if(fread(scratchpad, 88, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 88, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
fprintf(outputfile, "0 X X X X ");
if(fread(scratchpad, 88, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad + 8, 72, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
fprintf(outputfile, "Startdate %02i-", date_time.day);
switch(date_time.month)
{
case 1 : fprintf(outputfile, "JAN");
break;
case 2 : fprintf(outputfile, "FEB");
break;
case 3 : fprintf(outputfile, "MAR");
break;
case 4 : fprintf(outputfile, "APR");
break;
case 5 : fprintf(outputfile, "MAY");
break;
case 6 : fprintf(outputfile, "JUN");
break;
case 7 : fprintf(outputfile, "JUL");
break;
case 8 : fprintf(outputfile, "AUG");
break;
case 9 : fprintf(outputfile, "SEP");
break;
case 10 : fprintf(outputfile, "OCT");
break;
case 11 : fprintf(outputfile, "NOV");
break;
case 12 : fprintf(outputfile, "DEC");
break;
default : fprintf(outputfile, "ERR");
break;
}
fprintf(outputfile, "-%04i ", date_time.year);
if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->edfplus)
{
if(fread(scratchpad, 80, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(scratchpad[10]=='X')
{
if(fwrite(scratchpad + 12, 58, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
if(fwrite(scratchpad + 22, 58, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
else
{
fprintf(outputfile, "X X X ");
if(fread(scratchpad, 80, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad + 28, 52, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
else
{
if(fread(scratchpad, 168, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 168, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
fprintf(outputfile,
"%02i.%02i.%02i%02i.%02i.%02i",
date_time.day,
date_time.month,
date_time.year % 100,
date_time.hour,
date_time.minute,
date_time.second);
fprintf(outputfile, "%-8i", (signalcomps + edfplus) * 256 + 256);
if(edfplus)
{
fprintf(outputfile, "EDF+C");
for(i=0; i<39; i++) fputc(' ', outputfile);
}
else for(i=0; i<44; i++) fputc(' ', outputfile);
records = (int)(mainwindow->pagetime / duration);
if(add_one_sec)
{
records += TIME_DIMENSION / duration;
}
fprintf(outputfile, "%-8i", records);
if(fwrite(datrecduration, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
fprintf(outputfile, "%-4i", signalcomps + edfplus);
for(i=0; i<signalcomps; i++)
{
strcpy(scratchpad, signalcomp[i]->signallabel);
strcat(scratchpad, " ");
if(fwrite(scratchpad, 16, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
if(fwrite("EDF Annotations ", 16, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if(fwrite(signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].transducer, 80, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
for(i=0; i<80; i++) fputc(' ', outputfile);
}
for(i=0; i<signalcomps; i++)
{
strcpy(scratchpad, signalcomp[i]->physdimension);
strcat(scratchpad, " ");
if(fwrite(scratchpad, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
for(i=0; i<8; i++) fputc(' ', outputfile);
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fseeko(signalcomp[i]->edfhdr->file_hdl, (long long)((signalcomp[i]->edfsignal[0] * 8) + (104 * signalcomp[i]->edfhdr->edfsignals) + 256), SEEK_SET);
if(fread(scratchpad, 8, 1, signalcomp[i]->edfhdr->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->ecg_filter != NULL)
{
if(fwrite("0 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->zratio_filter != NULL)
{
if(fwrite("-1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
if(edfplus)
{
if(fwrite("-1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fseeko(signalcomp[i]->edfhdr->file_hdl, (long long)((signalcomp[i]->edfsignal[0] * 8) + (112 * signalcomp[i]->edfhdr->edfsignals) + 256), SEEK_SET);
if(fread(scratchpad, 8, 1, signalcomp[i]->edfhdr->file_hdl)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
if(fwrite(scratchpad, 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->ecg_filter != NULL)
{
if(fwrite("1000 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(signalcomp[i]->zratio_filter != NULL)
{
if(fwrite("1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
if(edfplus)
{
if(fwrite("1 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min);
if(signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min<0)
{
null_bytes[i].one_signed = 0;
}
else
{
null_bytes[i].one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min;
}
}
else
{
if(fwrite("-32768 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
null_bytes[i].one_signed = -32768;
}
}
if(edfplus)
{
if(fwrite("-32768 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max);
}
else
{
if(fwrite("32767 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
}
if(edfplus)
{
if(fwrite("32767 ", 8, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
for(i=0; i<signalcomps; i++)
{
strcpy(scratchpad, signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].prefilter);
strcat(scratchpad, " ");
for(p = strlen(scratchpad) - 1; p>=0; p--)
{
if(scratchpad[p]!=' ') break;
}
p++;
if(p) p++;
for(j=0; j<signalcomp[i]->filter_cnt; j++)
{
if(signalcomp[i]->filter[j]->is_LPF == 1)
{
p += sprintf(scratchpad + p, "LP:%f", signalcomp[i]->filter[j]->cutoff_frequency);
}
if(signalcomp[i]->filter[j]->is_LPF == 0)
{
p += sprintf(scratchpad + p, "HP:%f", signalcomp[i]->filter[j]->cutoff_frequency);
}
for(k=(p-1); k>0; k--)
{
if(scratchpad[k]!='0') break;
}
if(scratchpad[k]=='.') scratchpad[k] = 0;
else scratchpad[k+1] = 0;
strcat(scratchpad, "Hz ");
p = strlen(scratchpad);
if(p>80) break;
}
for(j=0; j<signalcomp[i]->fidfilter_cnt; j++)
{
type = signalcomp[i]->fidfilter_type[j];
frequency = signalcomp[i]->fidfilter_freq[j];
frequency2 = signalcomp[i]->fidfilter_freq2[j];
if(type == 0)
{
p += sprintf(scratchpad + p, "HP:%f", frequency);
}
if(type == 1)
{
p += sprintf(scratchpad + p, "LP:%f", frequency);
}
if(type == 2)
{
p += sprintf(scratchpad + p, "N:%f", frequency);
}
if(type == 3)
{
p += sprintf(scratchpad + p, "BP:%f", frequency);
}
if(type == 4)
{
p += sprintf(scratchpad + p, "BS:%f", frequency);
}
for(k=(p-1); k>0; k--)
{
if(scratchpad[k]!='0') break;
}
if(scratchpad[k]=='.') scratchpad[k] = 0;
else scratchpad[k+1] = 0;
p = strlen(scratchpad);
if((type == 3) || (type == 4))
{
p += sprintf(scratchpad + p, "-%f", frequency2);
for(k=(p-1); k>0; k--)
{
if(scratchpad[k]!='0') break;
}
if(scratchpad[k]=='.') scratchpad[k] = 0;
else scratchpad[k+1] = 0;
}
strcat(scratchpad, "Hz ");
p = strlen(scratchpad);
if(p>80) break;
}
for(j=0; j<signalcomp[i]->ravg_filter_cnt; j++)
{
if(signalcomp[i]->ravg_filter_type[j] == 0)
{
p += sprintf(scratchpad + p, "HP:%iSmpls ", signalcomp[i]->ravg_filter[j]->size);
}
if(signalcomp[i]->ravg_filter_type[j] == 1)
{
p += sprintf(scratchpad + p, "LP:%iSmpls ", signalcomp[i]->ravg_filter[j]->size);
}
p = strlen(scratchpad);
if(p>80) break;
}
if(signalcomp[i]->ecg_filter != NULL)
{
p += sprintf(scratchpad + p, "ECG:HR ");
}
if(signalcomp[i]->zratio_filter != NULL)
{
p += sprintf(scratchpad + p, "Z-ratio ");
}
for(;p<81; p++)
{
scratchpad[p] = ' ';
}
if(fwrite(scratchpad, 80, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
if(edfplus)
{
for(i=0; i<80; i++) fputc(' ', outputfile);
}
for(i=0; i<signalcomps; i++)
{
fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record
* duration_factor[signalcomp[i]->filenum]);
}
if(edfplus)
{
fprintf(outputfile, "%-8i", annot_smp_per_record);
}
for(i=0; i<signalcomps; i++)
{
for(j=0; j<32; j++) fputc(' ', outputfile);
}
if(edfplus)
{
for(i=0; i<32; i++) fputc(' ', outputfile);
}
/////////////////////////////////////////////////////////////////////
for(i=0; i<MAXSIGNALS; i++) smpls_written[i] = 0;
mainwindow->print_to_edf_active = 1;
mainwindow->setup_viewbuf();
viewbuf = mainwindow->viewbuf;
if(viewbuf==NULL)
{
fclose(outputfile);
return;
}
QApplication::setOverrideCursor(Qt::WaitCursor);
for(records_written=0; records_written<records; records_written++)
{
qApp->processEvents();
for(i=0; i<signalcomps; i++)
{
for(k=0; k<signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record * duration_factor[signalcomp[i]->filenum]; k++)
{
if(smpls_preamble[i])
{
smpls_preamble[i]--;
fputc(null_bytes[i].two[0], outputfile);
if(fputc(null_bytes[i].two[1], outputfile)==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
dig_value = 0;
s2 = smpls_written[i] + signalcomp[i]->sample_timeoffset - signalcomp[i]->sample_start;
for(j=0; j<signalcomp[i]->num_of_signals; j++)
{
if((smpls_written[i]<signalcomp[i]->sample_stop)&&(s2>=0))
{
if(signalcomp[i]->edfhdr->edf)
{
temp = *(((short *)(
viewbuf
+ signalcomp[i]->viewbufoffset
+ (signalcomp[i]->edfhdr->recordsize * (s2 / signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].smp_per_record))
+ signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].buf_offset))
+ (s2 % signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].smp_per_record));
}
temp += signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].offset;
temp *= signalcomp[i]->factor[j];
temp -= signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].offset;
}
else
{
temp = 0;
}
dig_value += temp;
}
for(p=0; p<signalcomp[i]->filter_cnt; p++)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime==0)
{
reset_filter(dig_value, signalcomp[i]->filter[p]);
}
else
{
signalcomp[i]->filter[p]->old_input = signalcomp[i]->filterpreset_a[p];
signalcomp[i]->filter[p]->old_output = signalcomp[i]->filterpreset_b[p];
}
}
dig_value = first_order_filter(dig_value, signalcomp[i]->filter[p]);
}
for(p=0; p<signalcomp[i]->ravg_filter_cnt; p++)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime!=0)
{
ravg_filter_restore_buf(signalcomp[i]->ravg_filter[p]);
}
}
dig_value = run_ravg_filter(dig_value, signalcomp[i]->ravg_filter[p]);
}
for(p=0; p<signalcomp[i]->fidfilter_cnt; p++)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime!=0)
{
memcpy(signalcomp[i]->fidbuf[p], signalcomp[i]->fidbuf2[p], fid_run_bufsize(signalcomp[i]->fid_run[p]));
}
}
dig_value = signalcomp[i]->fidfuncp[p](signalcomp[i]->fidbuf[p], dig_value);
}
if(signalcomp[i]->ecg_filter != NULL)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime != 0)
{
ecg_filter_restore_buf(signalcomp[i]->ecg_filter);
}
}
dig_value = run_ecg_filter(dig_value, signalcomp[i]->ecg_filter);
dig_value = (dig_value * signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].bitvalue * 65.536) - 32768.0;
}
if(signalcomp[i]->zratio_filter != NULL)
{
if(smpls_written[i]==signalcomp[i]->sample_start)
{
if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime != 0)
{
zratio_filter_restore_buf(signalcomp[i]->zratio_filter);
}
}
dig_value = run_zratio_filter(dig_value, signalcomp[i]->zratio_filter);
dig_value = dig_value * signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].bitvalue * 32768.0;
}
if((smpls_written[i]>=signalcomp[i]->sample_start)&&(smpls_written[i]<signalcomp[i]->sample_stop))
{
wr_var.one_signed = dig_value;
if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL))
{
if(wr_var.one_signed>signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max)
{
wr_var.one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max;
}
if(wr_var.one_signed<signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min)
{
wr_var.one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min;
}
}
else
{
if(wr_var.one_signed > 32767)
{
wr_var.one_signed = 32767;
}
if(wr_var.one_signed < -32768)
{
wr_var.one_signed = -32768;
}
}
fputc(wr_var.four[0], outputfile);
if(fputc(wr_var.four[1], outputfile)==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
else
{
fputc(null_bytes[i].two[0], outputfile);
if(fputc(null_bytes[i].two[1], outputfile)==EOF)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile.");
messagewindow.exec();
fclose(outputfile);
return;
}
}
smpls_written[i]++;
}
}
}
if(edfplus)
{
tallen = fprintf(outputfile, "+%i.%07i",
(int)(taltime / TIME_DIMENSION),
(int)(taltime % TIME_DIMENSION));
fputc(20, outputfile);
fputc(20, outputfile);
fputc(0, outputfile);
tallen += 3;
if(annotations_left)
{
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_ABSOLUT)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[annotationlist_nr]->utc_starttime) * TIME_DIMENSION;
}
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_OFFSET)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
}
if((mainwindow->viewtime_sync==VIEWTIME_UNSYNCED) || (mainwindow->viewtime_sync==VIEWTIME_USER_DEF_SYNCED))
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
annot_difftime += (mainwindow->edfheaderlist[annotationlist_nr]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime);
}
if(annotationlist_nr != mainwindow->sel_viewtime)
{
annot_difftime -= mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset;
annot_difftime += mainwindow->edfheaderlist[annotationlist_nr]->starttime_offset;
}
}
while(annotations_left)
{
while(!annotations_pntr)
{
annotationlist_nr++;
if(annotationlist_nr>=mainwindow->files_open)
{
annotations_left = 0;
annotations_pntr = NULL;
break;
}
annotations_pntr = mainwindow->annotationlist[annotationlist_nr];
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_ABSOLUT)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[annotationlist_nr]->utc_starttime) * TIME_DIMENSION;
}
if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_OFFSET)
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
}
if((mainwindow->viewtime_sync==VIEWTIME_UNSYNCED) || (mainwindow->viewtime_sync==VIEWTIME_USER_DEF_SYNCED))
{
annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION;
annot_difftime += (mainwindow->edfheaderlist[annotationlist_nr]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime);
}
if(annotationlist_nr != mainwindow->sel_viewtime)
{
annot_difftime -= mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset;
annot_difftime += mainwindow->edfheaderlist[annotationlist_nr]->starttime_offset;
}
}
if(!annotations_left) break;
if(annotations_pntr)
{
l_temp = annotations_pntr->onset - annot_difftime;
if((l_temp >= 0LL) && (l_temp < (mainwindow->pagetime + TIME_DIMENSION)))
{
tallen += fprintf(outputfile, "%+i.%07i",
(int)(l_temp / TIME_DIMENSION),
(int)(l_temp % TIME_DIMENSION));
if(annotations_pntr->duration[0]!=0)
{
fputc(21, outputfile);
tallen++;
tallen += fprintf(outputfile, "%s", annotations_pntr->duration);
}
fputc(20, outputfile);
tallen++;
tallen += fprintf(outputfile, "%s", annotations_pntr->annotation);
fputc(20, outputfile);
fputc(0, outputfile);
tallen += 2;
annotations_pntr = annotations_pntr->next_annotation;
break;
}
else
{
annotations_pntr = annotations_pntr->next_annotation;
continue;
}
}
}
for(j=tallen; j<(annot_smp_per_record * 2); j++)
{
fputc(0, outputfile);
}
taltime += duration;
}
}
QApplication::restoreOverrideCursor();
fclose(outputfile);
}
void UI_BDF2EDFwindow::StartConversion()
{
int i, j, k,
datrecs,
new_edfsignals,
datarecords,
len,
progress_steps;
char *readbuf,
scratchpad[256];
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
union {
signed short one_short;
unsigned char two_bytes[2];
} var2;
pushButton3->setEnabled(false);
pushButton4->setEnabled(false);
pushButton5->setEnabled(false);
if(edfhdr==NULL)
{
return;
}
if(edfhdr->edfsignals>MAXSIGNALS)
{
return;
}
new_edfsignals = 0;
for(i=0; i<edfhdr->edfsignals; i++)
{
if(!edfhdr->edfparam[i].annotation)
{
if(((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->checkState()==Qt::Checked)
{
signalslist[new_edfsignals] = i;
annotlist[new_edfsignals] = 0;
filterlist[new_edfsignals] = create_filter(0,
((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->value(),
1.0 / (edfhdr->data_record_duration / edfhdr->edfparam[i].smp_per_record));
dividerlist[new_edfsignals] = ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->value();
new_edfsignals++;
}
}
else
{
signalslist[new_edfsignals] = i;
annotlist[new_edfsignals] = 1;
filterlist[new_edfsignals] = create_filter(0, 0.01,
1.0 / (edfhdr->data_record_duration / edfhdr->edfparam[i].smp_per_record));
dividerlist[new_edfsignals] = 1.0;
new_edfsignals++;
}
}
datarecords = edfhdr->datarecords;
QProgressDialog progress("Converting...", "Abort", 0, datarecords, myobjectDialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress.reset();
if(!new_edfsignals)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "You must select at least one signal.");
messagewindow.exec();
goto END_1;
}
readbuf = (char *)malloc(edfhdr->recordsize);
if(readbuf==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error, (readbuf).");
messagewindow.exec();
goto END_2;
}
/////////////////////////// write header ////////////////////////////////////////
outputpath[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(outputpath, recent_savedir);
strcat(outputpath, "/");
}
len = strlen(outputpath);
get_filename_from_path(outputpath + len, inputpath, MAX_PATH_LENGTH - len);
remove_extension_from_filename(outputpath);
strcat(outputpath, ".edf");
strcpy(outputpath, QFileDialog::getSaveFileName(0, "Select outputfile", QString::fromLocal8Bit(outputpath), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(outputpath, ""))
{
goto END_2;
}
get_directory_from_path(recent_savedir, outputpath, MAX_PATH_LENGTH);
if(mainwindow->file_is_opened(outputpath))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, selected file is in use.");
messagewindow.exec();
goto END_2;
}
outputfile = fopeno(outputpath, "wb");
if(outputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open outputfile for writing.");
messagewindow.exec();
goto END_2;
}
fprintf(outputfile, "0 ");
fseeko(inputfile, 8LL, SEEK_SET);
if(fread(scratchpad, 176, 1, inputfile)!=1)
{
showpopupmessage("Error", "Read error (1).");
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Read error (1).");
messagewindow.exec();
goto END_3;
}
if(fwrite(scratchpad, 176, 1, outputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Write error (1).");
messagewindow.exec();
goto END_3;
}
fprintf(outputfile, "%-8i", new_edfsignals * 256 + 256);
if(edfhdr->bdfplus)
{
if(edfhdr->discontinuous)
{
fprintf(outputfile, "EDF+D");
}
else
{
fprintf(outputfile, "EDF+C");
}
for(i=0; i<39; i++)
{
fputc(' ', outputfile);
}
}
else
{
for(i=0; i<44; i++)
{
fputc(' ', outputfile);
}
}
fprintf(outputfile, "%-8i", datarecords);
snprintf(scratchpad, 256, "%f", edfhdr->data_record_duration);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
fprintf(outputfile, "%-4i", new_edfsignals);
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
fprintf(outputfile, "EDF Annotations ");
}
else
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].label);
}
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].transducer);
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", edfhdr->edfparam[signalslist[i]].physdimension);
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
fprintf(outputfile, "-1 ");
}
else
{
snprintf(scratchpad, 256, "%f", edfhdr->edfparam[signalslist[i]].bitvalue * -32768.0 * dividerlist[i]);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
fprintf(outputfile, "1 ");
}
else
{
snprintf(scratchpad, 256, "%f", edfhdr->edfparam[signalslist[i]].bitvalue * 32767.0 * dividerlist[i]);
convert_trailing_zeros_to_spaces(scratchpad);
if(scratchpad[7]=='.')
{
scratchpad[7] = ' ';
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "-32768 ");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "32767 ");
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
for(j=0; j<80; j++)
{
fputc(' ', outputfile);
}
}
else
{
snprintf(scratchpad, 256, "HP:%f", ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(signalslist[i], 1)))->value());
remove_trailing_zeros(scratchpad);
strcat(scratchpad, "Hz ");
strcat(scratchpad, edfhdr->edfparam[signalslist[i]].prefilter);
for(j=strlen(scratchpad); j<200; j++)
{
scratchpad[j] = ' ';
}
scratchpad[200] = 0;
for(j=0; j<80; j++)
{
if(!strncmp(scratchpad + j, "No filtering", 12))
{
for(k=j; k<(j+12); k++)
{
scratchpad[k] = ' ';
}
}
}
for(j=0; j<80; j++)
{
if(!strncmp(scratchpad + j, "None", 4))
{
for(k=j; k<(j+4); k++)
{
scratchpad[k] = ' ';
}
}
}
for(j=0; j<80; j++)
{
if(!strncmp(scratchpad + j, "HP: DC;", 7))
{
for(k=j; k<(j+7); k++)
{
scratchpad[k] = ' ';
}
}
}
scratchpad[80] = 0;
fprintf(outputfile, "%s", scratchpad);
}
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
if(edfhdr->edfparam[signalslist[i]].smp_per_record % 2)
{
fprintf(outputfile, "%-8i", ((edfhdr->edfparam[signalslist[i]].smp_per_record * 15) / 10) + 1);
}
else
{
fprintf(outputfile, "%-8i", (edfhdr->edfparam[signalslist[i]].smp_per_record * 15) / 10);
}
}
else
{
fprintf(outputfile, "%-8i", edfhdr->edfparam[signalslist[i]].smp_per_record);
}
}
for(i=0; i<(new_edfsignals * 32); i++)
{
fputc(' ', outputfile);
}
///////////////////////////// start conversion //////////////////////////////////////
progress_steps = datarecords / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
fseeko(inputfile, (long long)(edfhdr->hdrsize), SEEK_SET);
for(datrecs=0; datrecs<datarecords; datrecs++)
{
if(!(datrecs%progress_steps))
{
progress.setValue(datrecs);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
goto END_3;
}
}
if(fread(readbuf, edfhdr->recordsize, 1, inputfile) != 1)
{
progress.reset();
showpopupmessage("Error", "Read error (2).");
goto END_3;
}
for(i=0; i<new_edfsignals; i++)
{
if(annotlist[i])
{
if(fwrite(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset, edfhdr->edfparam[signalslist[i]].smp_per_record * 3, 1, outputfile)!=1)
{
progress.reset();
showpopupmessage("Error", "Write error (2).");
goto END_3;
}
if(edfhdr->edfparam[signalslist[i]].smp_per_record % 2)
{
if(fputc(0, outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (3).");
goto END_3;
}
}
}
else
{
for(j=0; j<edfhdr->edfparam[signalslist[i]].smp_per_record; j++)
{
var.two[0] = *((unsigned short *)(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset + (j * 3)));
var.four[2] = *((unsigned char *)(readbuf + edfhdr->edfparam[signalslist[i]].buf_offset + (j * 3) + 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
var.one_signed += edfhdr->edfparam[signalslist[i]].offset;
var.one_signed = first_order_filter(var.one_signed, filterlist[i]);
var.one_signed /= dividerlist[i];
if(var.one_signed>32767) var.one_signed = 32767;
if(var.one_signed<-32768) var.one_signed = -32768;
var2.one_short = var.one_signed;
fputc(var2.two_bytes[0], outputfile);
if(fputc(var2.two_bytes[1], outputfile)==EOF)
{
progress.reset();
showpopupmessage("Error", "Write error (4).");
goto END_3;
}
}
}
}
}
progress.reset();
showpopupmessage("Ready", "Done.");
END_3:
fclose(outputfile);
outputfile = NULL;
END_2:
free(readbuf);
END_1:
for(i=0; i<new_edfsignals; i++)
{
free(filterlist[i]);
}
fclose(inputfile);
inputfile = NULL;
inputpath[0] = 0;
outputpath[0] = 0;
free_edfheader();
label1->setText("");
SignalsTablewidget->setRowCount(0);
}
void UI_NK2EDFwindow::SelectFileButton()
{
FILE *inputfile=NULL,
*outputfile=NULL,
*logfile=NULL,
*pntfile=NULL;
int i, j, k,
error,
ctl_block_cnt,
datablock_cnt,
total_blocks,
edfplus,
n_logs=0,
n_sublogs=0,
total_logs=0,
n_logblocks=0,
ctlblock_address,
wfmblock_address,
logblock_address,
read_subevents=0;
char txt_string[2048],
path[MAX_PATH_LENGTH],
outputpath[MAX_PATH_LENGTH],
logfilepath[MAX_PATH_LENGTH],
pntfilepath[MAX_PATH_LENGTH],
*log_buf=NULL,
*sublog_buf=NULL,
scratchpad[256];
pushButton1->setEnabled(false);
edfplus = checkBox1->checkState();
total_elapsed_time = 0;
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "EEG files (*.eeg *.EEG)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
pushButton1->setEnabled(true);
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
inputfile = fopeno(path, "rb");
if(inputfile==NULL)
{
snprintf(txt_string, 2048, "can not open file %s for reading.\n", path);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
return;
}
/***************** check if the EEG file is valid ******************************/
rewind(inputfile);
if(fread(scratchpad, 16, 1, inputfile)!=1)
{
textEdit1->append("error reading .eeg file.\n");
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
scratchpad[16] = 0;
if(check_device(scratchpad))
{
snprintf(txt_string, 2048, "error, deviceblock has unknown signature: \"%s\"\n", scratchpad);
textEdit1->append(txt_string);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
fseeko(inputfile, 0x0081LL, SEEK_SET);
if(fread(scratchpad, 16, 1, inputfile)!=1)
{
textEdit1->append("error reading .eeg file.\n");
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
scratchpad[16] = 0;
if(check_device(scratchpad))
{
snprintf(txt_string, 2048, "error, controlblock has unknown signature: \"%s\"\n", scratchpad);
textEdit1->append(txt_string);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
fseeko(inputfile, 0x17feLL, SEEK_SET);
if(fgetc(inputfile)!=0x01)
{
snprintf(txt_string, 2048, "error, waveformdatablock has wrong signature.\n");
textEdit1->append(txt_string);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
/************************* read logs **********************************************/
if(edfplus)
{
strncpy(logfilepath, path, MAX_PATH_LENGTH);
remove_extension_from_filename(logfilepath);
strcat(logfilepath, ".LOG");
logfile = fopeno(logfilepath, "rb");
if(logfile==NULL)
{
remove_extension_from_filename(logfilepath);
strcat(logfilepath, ".log");
logfile = fopeno(logfilepath, "rb");
if(logfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading,\n"
"if there is no .log file you can try to create an EDF file instead of EDF+.\n",
logfilepath);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
}
rewind(logfile);
if(fread(scratchpad, 16, 1, logfile)!=1)
{
textEdit1->append("error reading .log file.\n");
fclose(logfile);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
scratchpad[16] = 0;
if(check_device(scratchpad))
{
snprintf(txt_string, 2048, "error, .log file has unknown signature: \"%s\"\n", scratchpad);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fclose(logfile);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
fseeko(logfile, 0x0091LL, SEEK_SET);
n_logblocks = fgetc(logfile);
log_buf = (char *)calloc(1, n_logblocks * 11521);
if(log_buf==NULL)
{
textEdit1->append("malloc error\n");
fclose(logfile);
fclose(inputfile);
pushButton1->setEnabled(true);
return;
}
sublog_buf = (char *)calloc(1, n_logblocks * 11521);
if(sublog_buf==NULL)
{
textEdit1->append("malloc error\n");
fclose(logfile);
fclose(inputfile);
free(log_buf);
pushButton1->setEnabled(true);
return;
}
read_subevents = 1;
total_logs = 0;
for(i=0; i<n_logblocks; i++)
{
fseeko(logfile, (long long)(0x0092 + (i * 20)), SEEK_SET);
if(fread((char *)(&logblock_address), 4, 1, logfile)!=1)
{
textEdit1->append("error reading .log file.\n");
fclose(inputfile);
fclose(logfile);
free(log_buf);
free(sublog_buf);
pushButton1->setEnabled(true);
return;
}
fseeko(logfile, (long long)(logblock_address + 0x0012), SEEK_SET);
n_logs = fgetc(logfile);
fseeko(logfile, (long long)(logblock_address + 0x0014), SEEK_SET);
if(fread(log_buf + (total_logs * 45), n_logs * 45, 1, logfile)!=1)
{
textEdit1->append("error reading .log file.\n");
fclose(inputfile);
fclose(logfile);
free(log_buf);
free(sublog_buf);
pushButton1->setEnabled(true);
return;
}
if(read_subevents)
{
if(fseeko(logfile, 0x0092LL + ((i + 22) * 20) , SEEK_SET))
{
read_subevents = 0;
}
else
{
if(fread((char *)(&logblock_address), 4, 1, logfile)!=1)
{
read_subevents = 0;
}
else
{
if(fseeko(logfile, logblock_address + 0x0012LL, SEEK_SET))
{
read_subevents = 0;
}
else
{
n_sublogs = fgetc(logfile);
if(n_sublogs != n_logs)
{
read_subevents = 0;
}
else
{
if(fseeko(logfile, logblock_address + 0x0014LL, SEEK_SET))
{
read_subevents = 0;
}
else
{
if(fread(sublog_buf + (total_logs * 45), n_sublogs * 45, 1, logfile)!=1)
{
read_subevents = 0;
}
}
}
}
}
}
}
total_logs += n_logs;
}
for(i=0; i<total_logs; i++)
{
for(j=0; j<20; j++)
{
if(((unsigned char *)log_buf)[(i * 45) + j]<32) log_buf[(i * 45) + j] = ' ';
}
latin1_to_utf8(log_buf + (i * 45), 20);
if(read_subevents)
{
strncpy(log_buf + (i * 45) + 26, sublog_buf + (i * 45) + 24, 6);
}
}
/************************* check pntfile **********************************************/
strncpy(pntfilepath, path, MAX_PATH_LENGTH);
remove_extension_from_filename(logfilepath);
strcat(logfilepath, ".PNT");
pntfile = fopeno(pntfilepath, "rb");
if(pntfile==NULL)
{
remove_extension_from_filename(logfilepath);
strcat(logfilepath, ".pnt");
pntfile = fopeno(pntfilepath, "rb");
if(pntfile==NULL)
{
snprintf(txt_string, 2048, "Can not open file %s for reading,\n"
"if there is no .pnt file you can try to create an EDF file instead of EDF+.\n",
pntfilepath);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fclose(logfile);
fclose(inputfile);
free(log_buf);
free(sublog_buf);
pushButton1->setEnabled(true);
return;
}
}
rewind(pntfile);
if(fread(scratchpad, 16, 1, pntfile)!=1)
{
textEdit1->append("error reading .pnt file.\n");
fclose(pntfile);
fclose(logfile);
fclose(inputfile);
free(log_buf);
free(sublog_buf);
pushButton1->setEnabled(true);
return;
}
scratchpad[16] = 0;
if(check_device(scratchpad))
{
snprintf(txt_string, 2048, "error, .pnt file has unknown signature: \"%s\"\n", scratchpad);
textEdit1->append(QString::fromLocal8Bit(txt_string));
fclose(pntfile);
fclose(logfile);
fclose(inputfile);
free(log_buf);
free(sublog_buf);
pushButton1->setEnabled(true);
return;
}
}
/***************** initialize labels **************************************/
for(i=0; i<256; i++)
{
strcpy(labels[i], "- ");
}
strcpy(labels[0], "EEG FP1 ");
strcpy(labels[1], "EEG FP2 ");
strcpy(labels[2], "EEG F3 ");
strcpy(labels[3], "EEG F4 ");
strcpy(labels[4], "EEG C3 ");
strcpy(labels[5], "EEG C4 ");
strcpy(labels[6], "EEG P3 ");
strcpy(labels[7], "EEG P4 ");
strcpy(labels[8], "EEG O1 ");
strcpy(labels[9], "EEG O2 ");
strcpy(labels[10], "EEG F7 ");
strcpy(labels[11], "EEG F8 ");
strcpy(labels[12], "EEG T3 ");
strcpy(labels[13], "EEG T4 ");
strcpy(labels[14], "EEG T5 ");
strcpy(labels[15], "EEG T6 ");
strcpy(labels[16], "EEG FZ ");
strcpy(labels[17], "EEG CZ ");
strcpy(labels[18], "EEG PZ ");
strcpy(labels[19], "EEG E ");
strcpy(labels[20], "EEG PG1 ");
strcpy(labels[21], "EEG PG2 ");
strcpy(labels[22], "EEG A1 ");
strcpy(labels[23], "EEG A2 ");
strcpy(labels[24], "EEG T1 ");
strcpy(labels[25], "EEG T2 ");
for(i=26; i<35; i++)
{
sprintf(labels[i], "EEG X%i ", i - 25);
}
strcpy(labels[35], "EEG X10 ");
strcpy(labels[36], "EEG X11 ");
for(i=42; i<74; i++)
{
sprintf(labels[i], "DC%02i ", i - 41);
}
strcpy(labels[74], "EEG BN1 ");
strcpy(labels[75], "EEG BN2 ");
strcpy(labels[76], "EEG Mark1 ");
strcpy(labels[77], "EEG Mark2 ");
strcpy(labels[100], "EEG X12/BP1 ");
strcpy(labels[101], "EEG X13/BP2 ");
strcpy(labels[102], "EEG X14/BP3 ");
strcpy(labels[103], "EEG X15/BP4 ");
for(i=104; i<188; i++)
{
sprintf(labels[i], "EEG X%i ", i - 88);
}
for(i=188; i<254; i++)
{
sprintf(labels[i], "EEG X%i ", i - 88);
}
strcpy(labels[255], "Z ");
if(read_21e_file(path))
{
textEdit1->append("Can not open *.21e file, converter will use default electrode names.");
}
/***************** start conversion **************************************/
total_blocks = 0;
fseeko(inputfile, 0x0091LL, SEEK_SET);
ctl_block_cnt = fgetc(inputfile);
if(ctl_block_cnt==EOF)
{
textEdit1->append("error reading inputfile.\n");
pushButton1->setEnabled(true);
fclose(inputfile);
if(edfplus)
{
fclose(logfile);
free(log_buf);
free(sublog_buf);
fclose(pntfile);
}
return;
}
for(i=0; i<ctl_block_cnt; i++)
{
fseeko(inputfile, (long long)(0x0092 + (i * 20)), SEEK_SET);
if(fread((char *)(&ctlblock_address), 4, 1, inputfile)!=1)
{
textEdit1->append("error reading inputfile.\n");
pushButton1->setEnabled(true);
fclose(inputfile);
if(edfplus)
{
fclose(logfile);
free(log_buf);
free(sublog_buf);
fclose(pntfile);
}
return;
}
fseeko(inputfile, (long long)(ctlblock_address + 17), SEEK_SET);
datablock_cnt = fgetc(inputfile);
if(datablock_cnt==EOF)
{
textEdit1->append("error reading inputfile.\n");
pushButton1->setEnabled(true);
fclose(inputfile);
if(edfplus)
{
fclose(logfile);
free(log_buf);
free(sublog_buf);
fclose(pntfile);
}
return;
}
for(j=0; j<datablock_cnt; j++)
{
fseeko(inputfile, (long long)(ctlblock_address + (j * 20) + 18), SEEK_SET);
if(fread((char *)(&wfmblock_address), 4, 1, inputfile)!=1)
{
textEdit1->append("error reading inputfile.\n");
pushButton1->setEnabled(true);
fclose(inputfile);
if(edfplus)
{
fclose(logfile);
free(log_buf);
free(sublog_buf);
fclose(pntfile);
}
return;
}
/********************************************************************/
strcpy(outputpath, path);
if(edfplus) sprintf(outputpath + strlen(path) - 4, "_%u-%u+.edf", i + 1, j + 1);
else sprintf(outputpath + strlen(path) - 4, "_%u-%u.edf", i + 1, j + 1);
outputfile = fopeno(outputpath, "wb");
if(outputfile==NULL)
{
snprintf(txt_string, 2048, "can not open file %s for writing.\n", outputpath);
textEdit1->append(QString::fromLocal8Bit(txt_string));
pushButton1->setEnabled(true);
fclose(inputfile);
if(edfplus)
{
fclose(logfile);
free(log_buf);
free(sublog_buf);
fclose(pntfile);
}
return;
}
textEdit1->append("Converting a waveform datablock...");
for(k=0; k<10; k++) qApp->processEvents();
error = convert_nk2edf(inputfile, outputfile, pntfile, wfmblock_address, edfplus, total_logs, log_buf, read_subevents);
if(error==0)
{
snprintf(txt_string, 2048, "to %s", outputpath);
textEdit1->append(txt_string);
}
if(error==1) textEdit1->append("malloc error.\n");
if(error==2) textEdit1->append("read error during conversion.\n");
if(error==3) textEdit1->append("write error during conversion.\n");
if(error==4) textEdit1->append("format error.\n");
if(fclose(outputfile))
{
textEdit1->append("error closing outputfile.\n");
pushButton1->setEnabled(true);
fclose(inputfile);
if(edfplus)
{
fclose(logfile);
fclose(pntfile);
free(log_buf);
free(sublog_buf);
}
return;
}
if(error)
{
if(edfplus)
{
fclose(logfile);
fclose(pntfile);
free(log_buf);
free(sublog_buf);
}
pushButton1->setEnabled(true);
return;
}
total_blocks++;
/**************************************************************/
}
}
if(fclose(inputfile)) textEdit1->append("error closing inputfile.\n");
if(edfplus)
{
if(fclose(logfile)) textEdit1->append("error closing .log file.\n");
if(fclose(pntfile)) textEdit1->append("error closing .pnt file.\n");
free(log_buf);
free(sublog_buf);
}
if(edfplus) snprintf(txt_string, 2048, "Converted %u waveformblock(s) successfully to EDF+.\n", total_blocks);
else snprintf(txt_string, 2048, "Converted %u waveformblock(s) successfully to EDF.\n", total_blocks);
textEdit1->append(txt_string);
pushButton1->setEnabled(true);
}
void UI_AverageCurveWindow::export_edf(void)
{
int i, j, k, p,
type,
edf_hdl,
smp_per_record,
datarecords,
smpls_left;
char path[MAX_PATH_LENGTH],
str[512];
double *buf,
frequency,
frequency2;
smp_per_record = signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record;
datarecords = avg_samples_on_screen / smp_per_record;
smpls_left = avg_samples_on_screen % smp_per_record;
path[0] = 0;
if(mainwindow->recent_savedir[0]!=0)
{
strcpy(path, mainwindow->recent_savedir);
strcat(path, "/");
}
get_filename_from_path(path + strlen(path), signalcomp->edfhdr->filename, 512);
remove_extension_from_filename(path);
sprintf(path + strlen(path), " averaging %s %i triggers [%s]",
signalcomp->signallabel,
avg_cnt,
avg_annotation);
if(signalcomp->edfhdr->edf)
{
strcat(path, ".edf");
strcpy(path, QFileDialog::getSaveFileName(0, "Save as EDF", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
}
else
{
strcat(path, ".bdf");
strcpy(path, QFileDialog::getSaveFileName(0, "Save as BDF", QString::fromLocal8Bit(path), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
}
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH);
if(signalcomp->edfhdr->edf)
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, 1);
}
else
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_BDFPLUS, 1);
}
if(edf_hdl < 0)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open output file for writing.");
messagewindow.exec();
return;
}
edf_set_samplefrequency(edf_hdl, 0, smp_per_record);
if(edf_set_datarecord_duration(edf_hdl, signalcomp->edfhdr->long_data_record_duration / 100LL))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Datarecordduration out of range.");
messagewindow.exec();
return;
}
if(signalcomp->edfhdr->edf)
{
edf_set_digital_maximum(edf_hdl, 0, 32767);
edf_set_digital_minimum(edf_hdl, 0, -32768);
}
else
{
edf_set_digital_maximum(edf_hdl, 0, 8388607);
edf_set_digital_minimum(edf_hdl, 0, -8388608);
}
edf_set_physical_maximum(edf_hdl, 0, avg_max_value);
edf_set_physical_minimum(edf_hdl, 0, avg_min_value);
edf_set_label(edf_hdl, 0, signalcomp->signallabel);
edf_set_physical_dimension(edf_hdl, 0, signalcomp->physdimension);
p = 0;
for(j=0; j<signalcomp->fidfilter_cnt; j++)
{
type = signalcomp->fidfilter_type[j];
frequency = signalcomp->fidfilter_freq[j];
frequency2 = signalcomp->fidfilter_freq2[j];
if(type == 0)
{
p += sprintf(str + p, "HP:%f", frequency);
}
if(type == 1)
{
p += sprintf(str + p, "LP:%f", frequency);
}
if(type == 2)
{
p += sprintf(str + p, "N:%f", frequency);
}
if(type == 3)
{
p += sprintf(str + p, "BP:%f", frequency);
}
if(type == 4)
{
p += sprintf(str + p, "BS:%f", frequency);
}
for(k=(p-1); k>0; k--)
{
if(str[k]!='0') break;
}
if(str[k]=='.') str[k] = 0;
else str[k+1] = 0;
p = strlen(str);
if((type == 3) || (type == 4))
{
p += sprintf(str + p, "-%f", frequency2);
for(k=(p-1); k>0; k--)
{
if(str[k]!='0') break;
}
if(str[k]=='.') str[k] = 0;
else str[k+1] = 0;
}
strcat(str, "Hz ");
p = strlen(str);
if(p>80) break;
}
for(j=0; j<signalcomp->ravg_filter_cnt; j++)
{
if(signalcomp->ravg_filter_type[j] == 0)
{
p += sprintf(str + p, "HP:%iSmpls ", signalcomp->ravg_filter[j]->size);
}
if(signalcomp->ravg_filter_type[j] == 1)
{
p += sprintf(str + p, "LP:%iSmpls ", signalcomp->ravg_filter[j]->size);
}
p = strlen(str);
if(p>80) break;
}
strcat(str, signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].prefilter);
edf_set_prefilter(edf_hdl, 0, str);
edf_set_transducer(edf_hdl, 0, signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].transducer);
if((signalcomp->edfhdr->edfplus) || (signalcomp->edfhdr->bdfplus))
{
edf_set_patientname(edf_hdl, signalcomp->edfhdr->plus_patient_name);
sprintf(str, "%i triggers \"%s\" averaged. %s", avg_cnt, avg_annotation, signalcomp->edfhdr->plus_recording_additional);
edf_set_recording_additional(edf_hdl, str);
edf_set_patientcode(edf_hdl, signalcomp->edfhdr->plus_patientcode);
if(signalcomp->edfhdr->plus_gender[0] == 'M')
{
edf_set_gender(edf_hdl, 1);
}
if(signalcomp->edfhdr->plus_gender[0] == 'F')
{
edf_set_gender(edf_hdl, 0);
}
edf_set_patient_additional(edf_hdl, signalcomp->edfhdr->plus_patient_additional);
edf_set_admincode(edf_hdl, signalcomp->edfhdr->plus_admincode);
edf_set_technician(edf_hdl, signalcomp->edfhdr->plus_technician);
edf_set_equipment(edf_hdl, signalcomp->edfhdr->plus_equipment);
}
else
{
edf_set_patientname(edf_hdl, signalcomp->edfhdr->patient);
sprintf(str, "%i triggers \"%s\" averaged. %s", avg_cnt, avg_annotation, signalcomp->edfhdr->recording);
edf_set_recording_additional(edf_hdl, str);
}
for(i=0; i<datarecords; i++)
{
edfwrite_physical_samples(edf_hdl, avgbuf + (i * smp_per_record));
}
if(smpls_left)
{
buf = (double *)calloc(1, smp_per_record * sizeof(double));
if(buf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf).");
messagewindow.exec();
}
else
{
for(i=0; i<smpls_left; i++)
{
buf[i] = avgbuf[(datarecords * smp_per_record) + i];
}
edfwrite_physical_samples(edf_hdl, buf);
free(buf);
}
}
edfwrite_annotation_latin1(edf_hdl,
(avg_period * 10000.0) / (double)avg_trigger_position_ratio,
-1,
avg_annotation);
edfclose_file(edf_hdl);
}
void UI_BI98002EDFwindow::SelectFileButton()
{
int i, j, n,
tmp,
end_of_file,
samplefreq=0,
chns = 3,
hdl,
samplesize=1,
bufsize,
*buf2,
datablocks,
blocks_written,
checked_modelnumber=0,
checked_samplerate=0,
checked_recordhours=0,
checked_recorddate=0,
checked_recordtime=0,
startdate_year=0,
startdate_month=0,
startdate_day=0,
starttime_hour=0,
starttime_minute=0,
starttime_second=0,
progress_steps;
char path[MAX_PATH_LENGTH],
outputfilename[MAX_PATH_LENGTH],
str[2048],
str2[128],
*buf1,
tmp2,
modelnumber_str[32];
FILE *dcmfile,
*evtfile;
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "DCM files (*.dcm *.DCM)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH);
dcmfile = fopeno(path, "rb");
if(dcmfile==NULL)
{
snprintf(str, 2048, "Can not open file %s for reading.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(str));
messagewindow.exec();
return;
}
remove_extension_from_filename(path);
strcat(path, ".EVT");
evtfile = fopeno(path, "rb");
if(evtfile==NULL)
{
remove_extension_from_filename(path);
strcat(path, ".evt");
evtfile = fopeno(path, "rb");
if(evtfile==NULL)
{
snprintf(str, 2048, "Can not open file %s for reading.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
fclose(dcmfile);
return;
}
}
/***************** check if the file is valid ******************************/
for(end_of_file=0; end_of_file == 0; )
{
for(i=0; i<256; i++)
{
tmp = fgetc(evtfile);
if(tmp == '\n')
{
break;
}
if(tmp == EOF)
{
end_of_file = 1;
break;
}
str[i] = tmp;
}
str[i] = 0;
if(!(strncmp(str, "Sampling Rate=", 14)))
{
samplefreq = atoi(str + 14);
switch(samplefreq)
{
case 128 : break;
case 256 : break;
case 512 : break;
case 1024 : break;
default : QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown samplerate.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_samplerate = 1;
}
if(!(strncmp(str, "Model number=", 13)))
{
strncpy(modelnumber_str, str + 13, 8);
modelnumber_str[8] = 0;
if(strcmp(modelnumber_str, "TM SD01G") &&
strcmp(modelnumber_str, "SD SD02G"))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong modelnumber.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_modelnumber = 1;
}
if(!(strncmp(str, "Record Date=", 12)))
{
strncpy(str2, str + 12, 10);
str2[10] = 0;
startdate_year = atoi(str2);
startdate_month = atoi(str2 + 5);
startdate_day = atoi(str2 + 8);
if((startdate_year < 1970) || (startdate_year > 3000) ||
(startdate_month < 1) || (startdate_month > 12) ||
(startdate_day < 1) || (startdate_day > 31))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong record date.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_recorddate = 1;
}
if(!(strncmp(str, "Record Time=", 12)))
{
strncpy(str2, str + 12, 10);
str2[8] = 0;
starttime_hour = atoi(str2);
starttime_minute = atoi(str2 + 3);
starttime_second = atoi(str2 + 6);
if((starttime_hour < 0) || (starttime_hour > 23) ||
(starttime_minute < 0) || (starttime_minute > 59) ||
(starttime_second < 0) || (starttime_second > 59))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong recordtime.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_recordtime = 1;
}
if(!(strncmp(str, "Record Hours=", 13)))
{
strncpy(str2, str + 13, 10);
str2[2] = 0;
if((atoi(str2) != 24) && (atoi(str2) != 48))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong record hours.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
checked_recordhours = 1;
}
}
if(!checked_modelnumber ||
!checked_samplerate ||
!checked_recordhours ||
!checked_recorddate ||
!checked_recordtime)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Missing line.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
///////////////////////////////////////////////////////////////////////////////////
bufsize = chns * samplesize * samplefreq;
buf1 = (char *)malloc(bufsize);
if(buf1 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
return;
}
buf2 = (int *)malloc(bufsize * sizeof(int));
if(buf2 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error.");
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
free(buf1);
return;
}
///////////////////////////////////////////////////////////////////////////////////
path[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(path, recent_savedir);
strcat(path, "/");
}
strcat(path, outputfilename);
remove_extension_from_filename(path);
strcat(path, ".edf");
strcpy(path, QFileDialog::getSaveFileName(0, "Select outputfile", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
fclose(dcmfile);
fclose(evtfile);
free(buf1);
free(buf2);
return;
}
get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH);
hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, chns);
if(hdl<0)
{
snprintf(str, 2048, "Can not open file %s for writing.", path);
QMessageBox messagewindow(QMessageBox::Critical, "Error", str);
messagewindow.exec();
fclose(dcmfile);
fclose(evtfile);
free(buf1);
free(buf2);
return;
}
for(i=0; i<chns; i++)
{
edf_set_samplefrequency(hdl, i, samplefreq);
}
for(i=0; i<chns; i++)
{
edf_set_digital_maximum(hdl, i, 127);
}
for(i=0; i<chns; i++)
{
edf_set_digital_minimum(hdl, i, -128);
}
for(i=0; i<chns; i++)
{
edf_set_physical_maximum(hdl, i, 2442.307692);
}
for(i=0; i<chns; i++)
{
edf_set_physical_minimum(hdl, i, -2461.538462);
}
for(i=0; i<chns; i++)
{
edf_set_physical_dimension(hdl, i, "uV");
}
edf_set_label(hdl, 0, "channel 1");
edf_set_label(hdl, 1, "channel 2");
edf_set_label(hdl, 2, "channel 3");
edf_set_equipment(hdl, modelnumber_str);
edf_set_patientname(hdl, "BI9800");
edf_set_startdatetime(hdl, startdate_year, startdate_month, startdate_day, starttime_hour, starttime_minute, starttime_second);
fseeko(dcmfile, 0LL, SEEK_END);
datablocks = ftello(dcmfile) / bufsize;
fseeko(dcmfile, 0LL, SEEK_SET);
QProgressDialog progress("Converting...", "Cancel", 0, datablocks, myobjectDialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = datablocks / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
for(blocks_written=0; ; blocks_written++)
{
if(!(blocks_written % progress_steps))
{
progress.setValue(blocks_written);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
break;
}
}
n = fread(buf1, bufsize, 1, dcmfile);
if(n != 1)
{
break;
}
for(i=0; i<samplefreq; i++)
{
for(j=0; j<chns; j++)
{
tmp2 = buf1[(i * chns) + j] + 128;
buf2[(j * samplefreq) + i] = tmp2;
}
}
edf_blockwrite_digital_samples(hdl, buf2);
}
progress.reset();
edfwrite_annotation_latin1(hdl, 0LL, -1LL, "Recording starts");
fseeko(evtfile, 0LL, SEEK_SET);
for(end_of_file=0; end_of_file == 0; )
{
for(i=0; i<256; i++)
{
tmp = fgetc(evtfile);
if((tmp == '\n') || (tmp == '\r'))
{
break;
}
if(tmp == EOF)
{
end_of_file = 1;
break;
}
str[i] = tmp;
}
str[i] = 0;
if((isdigit(str[0])) && (isdigit(str[1])))
{
starttime_hour = atoi(str);
starttime_minute = atoi(str + 3);
starttime_second = atoi(str + 6);
if((starttime_hour < 0) || (starttime_hour > 23) ||
(starttime_minute < 0) || (starttime_minute > 59) ||
(starttime_second < 0) || (starttime_second > 59))
{
}
else
{
if(strlen(str) > 9)
{
edfwrite_annotation_latin1(hdl, (starttime_second + (starttime_minute * 60) + (starttime_hour * 3600)) * 10000, -1, str + 9);
}
}
}
}
edfwrite_annotation_latin1(hdl, blocks_written * 10000LL, -1LL, "Recording ends");
edfclose_file(hdl);
fclose(dcmfile);
fclose(evtfile);
free(buf1);
free(buf2);
}
void UI_WAV2EDFwindow::SelectFileButton()
{
FILE *inputfile=NULL;
int i, j,
edfsignals,
sf,
resolution,
edf_hdl,
readbufsize,
*writebuf,
bytes_per_sample,
sf_divider;
unsigned int fmt_chunk_offset,
data_chunk_offset,
tmp;
char path[MAX_PATH_LENGTH],
outputfilename[MAX_PATH_LENGTH],
scratchpad[512],
*readbuf;
long long blocks,
leftover,
progress_steps,
k;
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
enable_widgets(false);
if(!(strlen(PatientnameLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subject name.");
messagewindow.exec();
enable_widgets(true);
return;
}
if(!(strlen(RecordingLineEdit->text().toLatin1().data())))
{
QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recording description.");
messagewindow.exec();
enable_widgets(true);
return;
}
strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "Text files (*.wav *.WAV)").toLocal8Bit().data());
if(!strcmp(path, ""))
{
enable_widgets(true);
return;
}
get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH);
inputfile = fopeno(path, "rb");
if(inputfile==NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for reading.");
messagewindow.exec();
enable_widgets(true);
return;
}
/***************** check if the wavefile is valid ******************************/
rewind(inputfile);
if(fread(scratchpad, 256, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if((strncmp(scratchpad, "RIFF", 4)) || (strncmp(scratchpad + 8, "WAVE", 4)))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "File is not a Wave file.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
fmt_chunk_offset = 12;
while(1)
{
fseeko(inputfile, (long long)fmt_chunk_offset, SEEK_SET);
if(fread(scratchpad, 256, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find fmt chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(strncmp(scratchpad, "fmt ", 4) == 0)
{
break;
}
tmp = *((unsigned int *)(scratchpad + 4));
if(tmp < 2)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find fmt chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(tmp & 1)
{
tmp++;
}
fmt_chunk_offset += (tmp + 8);
}
if(*((signed short *)(scratchpad + 8)) != 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "File contains compressed data.\nCan not convert compressed data.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
edfsignals = *((unsigned short *)(scratchpad + 10));
if(edfsignals < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Channels < 1");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(edfsignals > MAXSIGNALS)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Channels > MAXSIGNALS");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
sf = *((unsigned int *)(scratchpad + 12));
if(sf < 1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency < 1");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(sf > 500000)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency > 500000");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
resolution = *((unsigned short *)(scratchpad + 22));
if(resolution < 8)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Resolution < 8 bit");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(resolution > 24)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Resolution > 24");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if((resolution != 8) && (resolution != 16) && (resolution != 24))
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Resolution (bitdepth) must be 8, 16 or 24 bit.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
bytes_per_sample = 2;
if(resolution > 16)
{
bytes_per_sample = 3;
}
if(resolution < 9)
{
bytes_per_sample = 1;
}
///////////////////////////////////////////////////////////////////////////////
data_chunk_offset = 12;
while(1)
{
fseeko(inputfile, (long long)data_chunk_offset, SEEK_SET);
if(fread(scratchpad, 256, 1, inputfile)!=1)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find data chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(strncmp(scratchpad, "data", 4) == 0)
{
break;
}
tmp = *((unsigned int *)(scratchpad + 4));
if(tmp < 2)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not find data chunk.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
if(tmp & 1)
{
tmp++;
}
data_chunk_offset += (tmp + 8);
}
///////////////////////////////////////////////////////////////////////////////
sf_divider = 1;
if((sf % 10) == 0)
{
sf_divider = 10;
sf /= 10;
}
blocks = (long long)(*((int *)(scratchpad + 4)));
blocks /= (sf * edfsignals * bytes_per_sample);
fseeko(inputfile, 0LL, SEEK_END);
leftover = ftello(inputfile) - (long long)data_chunk_offset - 8LL;
leftover /= (sf * edfsignals * bytes_per_sample);
if(blocks > leftover)
{
blocks = leftover;
}
if(blocks < 1LL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Not enough data in file.");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
readbufsize = bytes_per_sample * sf * edfsignals;
readbuf = (char *)malloc(readbufsize);
if(readbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred. (readbuf).");
messagewindow.exec();
fclose(inputfile);
enable_widgets(true);
return;
}
writebuf = (int *)malloc(sf * edfsignals * sizeof(int));
if(writebuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred. (writebuf).");
messagewindow.exec();
free(readbuf);
fclose(inputfile);
enable_widgets(true);
return;
}
// printf("resolution is %i edfsignals is %i sf is %i blocks is %lli\n", resolution, edfsignals, sf, blocks);
/***************** create a new EDF file *****************************************/
get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH);
remove_extension_from_filename(outputfilename);
if(resolution > 16)
{
strcat(outputfilename, ".bdf");
}
else
{
strcat(outputfilename, ".edf");
}
path[0] = 0;
if(recent_savedir[0]!=0)
{
strcpy(path, recent_savedir);
strcat(path, "/");
}
strcat(path, outputfilename);
if(resolution > 16)
{
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "BDF files (*.bdf *.BDF)").toLocal8Bit().data());
}
else
{
strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data());
}
if(!strcmp(path, ""))
{
enable_widgets(true);
fclose(inputfile);
return;
}
get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH);
if(resolution > 16)
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_BDFPLUS, edfsignals);
}
else
{
edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, edfsignals);
}
if(edf_hdl < 0)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open output file for writing.");
messagewindow.exec();
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
for(i=0; i<edfsignals; i++)
{
edf_set_samplefrequency(edf_hdl, i, sf);
}
if(sf_divider != 1)
{
edf_set_datarecord_duration(edf_hdl, 100000 / sf_divider);
}
for(i=0; i<edfsignals; i++)
{
if(resolution > 16)
{
edf_set_digital_maximum(edf_hdl, i, 8388607);
}
else
{
if(resolution < 9)
{
edf_set_digital_maximum(edf_hdl, i, 127);
}
else
{
edf_set_digital_maximum(edf_hdl, i, 32767);
}
}
}
for(i=0; i<edfsignals; i++)
{
if(resolution > 16)
{
edf_set_digital_minimum(edf_hdl, i, -8388608);
}
else
{
if(resolution < 9)
{
edf_set_digital_minimum(edf_hdl, i, -128);
}
else
{
edf_set_digital_minimum(edf_hdl, i, -32768);
}
}
}
for(i=0; i<edfsignals; i++)
{
edf_set_physical_maximum(edf_hdl, i, PhysMaxSpinBox->value());
}
for(i=0; i<edfsignals; i++)
{
edf_set_physical_minimum(edf_hdl, i, PhysMaxSpinBox->value() * -1.0);
}
for(i=0; i<edfsignals; i++)
{
edf_set_physical_dimension(edf_hdl, i, PhysDimLineEdit->text().toLatin1().data());
}
for(i=0; i<edfsignals; i++)
{
sprintf(scratchpad, "channel %i", i + 1);
edf_set_label(edf_hdl, i, scratchpad);
}
edf_set_patientname(edf_hdl, PatientnameLineEdit->text().toLatin1().data());
edf_set_recording_additional(edf_hdl, RecordingLineEdit->text().toLatin1().data());
edf_set_startdatetime(edf_hdl, StartDatetimeedit->date().year(), StartDatetimeedit->date().month(), StartDatetimeedit->date().day(),
StartDatetimeedit->time().hour(), StartDatetimeedit->time().minute(), StartDatetimeedit->time().second());
edfwrite_annotation_latin1(edf_hdl, 0LL, -1, "Recording starts");
/***************** start conversion **************************************/
fseeko(inputfile, (long long)data_chunk_offset + 8LL, SEEK_SET);
QProgressDialog progress("Converting a Wave file ...", "Abort", 0, (int)blocks, myobjectDialog);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = blocks / 100LL;
if(progress_steps < 1LL)
{
progress_steps = 1LL;
}
for(k=0LL; k<blocks; k++)
{
if(!(k%progress_steps))
{
progress.setValue((int)k);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
edfclose_file(edf_hdl);
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
}
if(fread(readbuf, readbufsize, 1, inputfile)!=1)
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during conversion.");
messagewindow.exec();
edfclose_file(edf_hdl);
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
if(bytes_per_sample == 1)
{
for(i=0; i<sf; i++)
{
for(j=0; j<edfsignals; j++)
{
writebuf[i + (j * sf)] = (signed char)(*(readbuf + (i * edfsignals) + j) + 128);
}
}
}
if(bytes_per_sample == 2)
{
for(i=0; i<sf; i++)
{
for(j=0; j<edfsignals; j++)
{
writebuf[i + (j * sf)] = *(((signed short *)readbuf) + (i * edfsignals) + j);
}
}
}
if(bytes_per_sample == 3)
{
for(i=0; i<sf; i++)
{
for(j=0; j<edfsignals; j++)
{
var.two[0] = *((unsigned short *)(readbuf + (i * edfsignals) + (j * 3)));
var.four[2] = *((unsigned char *)(readbuf + (i * edfsignals * 3) + (j * 3) + 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
writebuf[i + (j * sf)] = var.one_signed;
}
}
}
if(edf_blockwrite_digital_samples(edf_hdl, writebuf))
{
progress.reset();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "A write error occurred during conversion.");
messagewindow.exec();
edfclose_file(edf_hdl);
fclose(inputfile);
free(readbuf);
free(writebuf);
enable_widgets(true);
return;
}
}
progress.reset();
edfwrite_annotation_latin1(edf_hdl, (blocks * 10000LL) / sf_divider, -1, "Recording ends");
edfclose_file(edf_hdl);
fclose(inputfile);
QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done.");
messagewindow.setIconPixmap(QPixmap(":/images/ok.png"));
messagewindow.exec();
free(readbuf);
free(writebuf);
enable_widgets(true);
}
