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_FilterDialog::frequencyboxvaluechanged(double value)
{
char str[256];
if(freq2box->value() < (value * 1.12))
{
freq2box->setValue(value * 1.12);
}
if(typebox->currentIndex() == 2)
{
sprintf(str,"%f Hz", freqbox->value() / orderbox->value());
remove_trailing_zeros(str);
ordervaluelabel->setText(str);
}
updatecurve();
}
void UI_FreqSpectrumWindow::thr_finished_func()
{
char str[1024];
if(spectrumdialog_is_destroyed)
{
return;
}
if(malloc_err)
{
QApplication::restoreOverrideCursor();
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
curve1->clear();
busy = 0;
return;
}
strcpy(str, "FFT resolution: ");
convert_to_metric_suffix(str + strlen(str), freqstep, 3);
remove_trailing_zeros(str);
sprintf(str + strlen(str), "Hz %i blocks of %i samples", dftblocks, dftblocksize);
curve1->setUpperLabel1(str);
curve1->setUpperLabel2(signallabel);
sliderMoved(0);
curve1->setUpdatesEnabled(true);
busy = 0;
QApplication::restoreOverrideCursor();
}
void UI_Annotationswindow::updateList(void)
{
char str[MAX_ANNOTATION_LEN + 32],
*str_tmp;
int i,
len,
sequence_nr=0,
jump=0,
modified=0;
QListWidgetItem *listitem;
QString string;
QByteArray ba;
selected = -1;
#ifdef Q_OS_WIN32
QFont specialfont("courier", 11, QFont::Normal, true);
#else
QFont specialfont("andale mono", 12, QFont::Normal, true);
#endif
specialfont.setPixelSize(12);
list->clear();
edfplus_annotation_sort(&mainwindow->annotationlist[file_num]);
annotation = mainwindow->annotationlist[file_num];
while(annotation != NULL)
{
if(annotation->hided_in_list)
{
annotation = annotation->next_annotation;
sequence_nr++;
continue;
}
string = QString::fromUtf8(annotation->annotation);
ba = string.toUtf8();
str_tmp = ba.data();
len = 0;
for(i=0; ; i++)
{
if(str_tmp[i]==0) break;
if(((((unsigned char *)str_tmp)[i])&224)==192) len++;
}
for(i=0; i<len; i++) string.append(' ');
if(relative)
{
if((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) < 0LL)
{
snprintf(str, (MAX_ANNOTATION_LEN + 32) / 2, " -%2i:%02i:%02i.%04i",
(int)((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION)/ 3600),
(int)(((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 3600) / 60),
(int)((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 60),
(int)((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) % TIME_DIMENSION) / 1000LL));
}
else
{
snprintf(str, (MAX_ANNOTATION_LEN + 32) / 2, " %3i:%02i:%02i.%04i",
(int)(((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION)/ 3600),
(int)((((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 3600) / 60),
(int)(((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 60),
(int)(((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) % TIME_DIMENSION) / 1000LL));
}
}
else
{
snprintf(str, MAX_ANNOTATION_LEN + 32, " %3i:%02i:%02i.%04i",
(int)((((annotation->onset + mainwindow->edfheaderlist[file_num]->l_starttime) / TIME_DIMENSION)/ 3600) % 24),
(int)((((annotation->onset + mainwindow->edfheaderlist[file_num]->l_starttime) / TIME_DIMENSION) % 3600) / 60),
(int)(((annotation->onset + mainwindow->edfheaderlist[file_num]->l_starttime) / TIME_DIMENSION) % 60),
(int)(((annotation->onset + mainwindow->edfheaderlist[file_num]->l_starttime) % TIME_DIMENSION) / 1000LL));
}
str[MAX_ANNOTATION_LEN + 31] = 0;
remove_trailing_zeros(str);
if(string.size() < 20)
{
string = string.leftJustified(20, ' ');
}
string.append(QString::fromLatin1(str));
listitem = new QListWidgetItem(string, list);
listitem->setData(Qt::UserRole, QVariant(sequence_nr));
if(annotation->modified==1)
{
listitem->setFont(specialfont);
listitem->setForeground(Qt::red);
modified = 1;
}
if((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) < 0LL)
{
snprintf(str, (MAX_ANNOTATION_LEN + 32) / 2, "onset: -%i:%02i:%02i.%04i",
(int)((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION)/ 3600),
(int)(((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 3600) / 60),
(int)((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 60),
(int)((-(annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) % TIME_DIMENSION) / 1000LL));
}
else
{
snprintf(str, (MAX_ANNOTATION_LEN + 32) / 2, "onset: %2i:%02i:%02i.%04i",
(int)(((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION)/ 3600),
(int)((((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 3600) / 60),
(int)(((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) / TIME_DIMENSION) % 60),
(int)(((annotation->onset - mainwindow->edfheaderlist[file_num]->starttime_offset) % TIME_DIMENSION) / 1000LL));
}
if(annotation->duration[0]!=0)
{
snprintf(str + strlen(str), (MAX_ANNOTATION_LEN + 32) / 2, "\nduration: %s",annotation->duration);
}
str[MAX_ANNOTATION_LEN + 31] = 0;
remove_trailing_zeros(str);
strcat(str, "\n\n");
string = QString::fromLatin1(str);
string.append(QString::fromUtf8(annotation->annotation));
listitem->setToolTip(string);
if(annotation->selected)
{
selected = sequence_nr;
annotation->selected = 0;
if(annotation->jump)
{
jump = 1;
annotation->jump = 0;
}
}
annotation = annotation->next_annotation;
sequence_nr++;
}
if(mainwindow->annot_editor_active)
{
if(selected>=0)
{
list->setCurrentRow(selected, QItemSelectionModel::ClearAndSelect);
mainwindow->annotationEditDock->set_selected_annotation(file_num, selected);
if(jump)
{
jump = 0;
annotation_selected(list->currentItem());
}
selected = -1;
}
if(modified)
{
mainwindow->annotations_edited = 1;
mainwindow->save_act->setEnabled(true);
}
}
}
void AdjustFilterSettings::loadFilterSettings(void)
{
int i;
char txtbuf[2048];
txtbuf[0] = 0;
filterbox->clear();
for(i=0; i<signalcomp->fidfilter_cnt; i++)
{
type = signalcomp->fidfilter_type[i];
model = signalcomp->fidfilter_model[i];
order = signalcomp->fidfilter_order[i];
ripple = signalcomp->fidfilter_ripple[i];
frequency1 = signalcomp->fidfilter_freq[i];
if(type == 0)
{
if(model == 0)
{
sprintf(txtbuf, "HighPass Butterworth");
}
if(model == 1)
{
sprintf(txtbuf, "HighPass Chebyshev %.1fdB ripple", ripple);
}
if(model == 2)
{
sprintf(txtbuf, "HighPass Bessel");
}
}
if(type == 1)
{
if(model == 0)
{
sprintf(txtbuf, "LowPass Butterworth");
}
if(model == 1)
{
sprintf(txtbuf, "LowPass Chebyshev %.1fdB ripple", ripple);
}
if(model == 2)
{
sprintf(txtbuf, "LowPass Bessel");
}
}
if(type == 2)
{
sprintf(txtbuf, "Notch (resonator)");
}
if(type == 3)
{
if(model == 0)
{
sprintf(txtbuf, "BandPass Butterworth");
}
if(model == 1)
{
sprintf(txtbuf, "BandPass Chebyshev %.1fdB ripple", ripple);
}
if(model == 2)
{
sprintf(txtbuf, "BandPass Bessel");
}
}
if(type == 4)
{
if(model == 0)
{
sprintf(txtbuf, "BandStop Butterworth");
}
if(model == 1)
{
sprintf(txtbuf, "BandStop Chebyshev %.1fdB ripple", ripple);
}
if(model == 2)
{
sprintf(txtbuf, "BandStop Bessel");
}
}
sprintf(txtbuf + strlen(txtbuf), " %f", frequency1);
remove_trailing_zeros(txtbuf);
strcat(txtbuf, " Hz");
filterbox->addItem(txtbuf);
brand[filter_cnt++] = 0;
}
for(i=0; i<signalcomp->ravg_filter_cnt; i++)
{
type = signalcomp->ravg_filter_type[i];
size = signalcomp->ravg_filter_size[i];
if(type == 0)
{
sprintf(txtbuf, "Highpass Moving Average %i samples", size);
}
if(type == 1)
{
sprintf(txtbuf, "Lowpass Moving Average %i samples", size);
}
filterbox->addItem(txtbuf);
brand[filter_cnt++] = 1;
}
filterboxchanged(filterbox->currentIndex());
}
UI_ShowActualMontagewindow::UI_ShowActualMontagewindow(QWidget *w_parent)
{
int i, j,
type,
model,
order;
char txtbuf[2048];
double frequency,
frequency2,
ripple;
QStandardItem *parentItem,
*signalItem,
*filterItem;
mainwindow = (UI_Mainwindow *)w_parent;
ShowMontageDialog = new QDialog;
ShowMontageDialog->setMinimumSize(QSize(500, 300));
ShowMontageDialog->resize(500, 440);
ShowMontageDialog->setWindowTitle("Show montage");
ShowMontageDialog->setModal(true);
ShowMontageDialog->setAttribute(Qt::WA_DeleteOnClose, true);
tree = new QTreeView;
tree->setHeaderHidden(true);
tree->setIndentation(30);
tree->setSelectionMode(QAbstractItemView::NoSelection);
tree->setEditTriggers(QAbstractItemView::NoEditTriggers);
tree->setSortingEnabled(false);
tree->setDragDropMode(QAbstractItemView::NoDragDrop);
CloseButton = new QPushButton;
CloseButton->setFixedSize(100, 25);
CloseButton->setText("Close");
box = new QBoxLayout(QBoxLayout::TopToBottom, ShowMontageDialog);
box->addWidget(tree);
box->addWidget(CloseButton, 0, Qt::AlignRight);
QObject::connect(CloseButton, SIGNAL(clicked()), ShowMontageDialog, SLOT(close()));
t_model = new QStandardItemModel(this);
parentItem = t_model->invisibleRootItem();
for(i=0; i<mainwindow->signalcomps; i++)
{
txtbuf[0] = 0;
if(mainwindow->signalcomp[i]->alias[0] != 0)
{
strcpy(txtbuf, "alias: ");
strcat(txtbuf, mainwindow->signalcomp[i]->alias);
strcat(txtbuf, " ");
}
for(j=0; j<mainwindow->signalcomp[i]->num_of_signals; j++)
{
sprintf(txtbuf + strlen(txtbuf), "%+ix %s",
mainwindow->signalcomp[i]->factor[j],
mainwindow->signalcomp[i]->edfhdr->edfparam[mainwindow->signalcomp[i]->edfsignal[j]].label);
remove_trailing_spaces(txtbuf);
strcat(txtbuf, " ");
}
if(mainwindow->signalcomp[i]->polarity == -1)
{
strcat(txtbuf, "Inverted: yes");
}
signalItem = new QStandardItem(txtbuf);
parentItem->appendRow(signalItem);
sprintf(txtbuf, "amplitude: %f", mainwindow->signalcomp[i]->voltpercm);
strcat(txtbuf, mainwindow->signalcomp[i]->physdimension);
remove_trailing_spaces(txtbuf);
sprintf(txtbuf + strlen(txtbuf), "/cm offset: %f%s",
mainwindow->signalcomp[i]->screen_offset * mainwindow->pixelsizefactor * mainwindow->signalcomp[i]->voltpercm,
mainwindow->signalcomp[i]->physdimension);
remove_trailing_zeros(txtbuf);
remove_trailing_spaces(txtbuf);
strcat(txtbuf, " color: ");
switch(mainwindow->signalcomp[i]->color)
{
case Qt::white : strcat(txtbuf, "white");
break;
case Qt::black : strcat(txtbuf, "black");
break;
case Qt::red : strcat(txtbuf, "red");
break;
case Qt::darkRed : strcat(txtbuf, "dark red");
break;
case Qt::green : strcat(txtbuf, "green");
break;
case Qt::darkGreen : strcat(txtbuf, "dark green");
break;
case Qt::blue : strcat(txtbuf, "blue");
break;
case Qt::darkBlue : strcat(txtbuf, "dark blue");
break;
case Qt::cyan : strcat(txtbuf, "cyan");
break;
case Qt::darkCyan : strcat(txtbuf, "dark cyan");
break;
case Qt::magenta : strcat(txtbuf, "magenta");
break;
case Qt::darkMagenta : strcat(txtbuf, "dark magenta");
break;
case Qt::yellow : strcat(txtbuf, "yellow");
break;
case Qt::darkYellow : strcat(txtbuf, "dark yellow");
break;
case Qt::gray : strcat(txtbuf, "gray");
break;
case Qt::darkGray : strcat(txtbuf, "dark gray");
break;
case Qt::lightGray : strcat(txtbuf, "light gray");
break;
}
signalItem->appendRow(new QStandardItem(txtbuf));
filterItem = new QStandardItem("Filters");
signalItem->appendRow(filterItem);
if(mainwindow->signalcomp[i]->spike_filter)
{
sprintf(txtbuf, "Spike: %.8f", mainwindow->signalcomp[i]->spike_filter_velocity);
remove_trailing_zeros(txtbuf);
sprintf(txtbuf + strlen(txtbuf), " %s/0.5mSec. Hold-off: %i mSec.",
mainwindow->signalcomp[i]->physdimension,
mainwindow->signalcomp[i]->spike_filter_holdoff);
filterItem->appendRow(new QStandardItem(txtbuf));
}
for(j=0; j<mainwindow->signalcomp[i]->filter_cnt; j++)
{
if(mainwindow->signalcomp[i]->filter[j]->is_LPF == 1)
{
sprintf(txtbuf, "LPF: %fHz", mainwindow->signalcomp[i]->filter[j]->cutoff_frequency);
}
if(mainwindow->signalcomp[i]->filter[j]->is_LPF == 0)
{
sprintf(txtbuf, "HPF: %fHz", mainwindow->signalcomp[i]->filter[j]->cutoff_frequency);
}
remove_trailing_zeros(txtbuf);
filterItem->appendRow(new QStandardItem(txtbuf));
}
for(j=0; j<mainwindow->signalcomp[i]->ravg_filter_cnt; j++)
{
if(mainwindow->signalcomp[i]->ravg_filter_type[j] == 0)
{
sprintf(txtbuf, "highpass moving average %i smpls", mainwindow->signalcomp[i]->ravg_filter[j]->size);
}
if(mainwindow->signalcomp[i]->ravg_filter_type[j] == 1)
{
sprintf(txtbuf, "lowpass moving average %i smpls", mainwindow->signalcomp[i]->ravg_filter[j]->size);
}
filterItem->appendRow(new QStandardItem(txtbuf));
}
for(j=0; j<mainwindow->signalcomp[i]->fidfilter_cnt; j++)
{
type = mainwindow->signalcomp[i]->fidfilter_type[j];
model = mainwindow->signalcomp[i]->fidfilter_model[j];
frequency = mainwindow->signalcomp[i]->fidfilter_freq[j];
frequency2 = mainwindow->signalcomp[i]->fidfilter_freq2[j];
order = mainwindow->signalcomp[i]->fidfilter_order[j];
ripple = mainwindow->signalcomp[i]->fidfilter_ripple[j];
if(type == 0)
{
if(model == 0)
{
sprintf(txtbuf, "highpass Butterworth %fHz %ith order", frequency, order);
}
if(model == 1)
{
sprintf(txtbuf, "highpass Chebyshev %fHz %ith order %fdB ripple", frequency, order, ripple);
}
if(model == 2)
{
sprintf(txtbuf, "highpass Bessel %fHz %ith order", frequency, order);
}
}
if(type == 1)
{
if(model == 0)
{
sprintf(txtbuf, "lowpass Butterworth %fHz %ith order", frequency, order);
}
if(model == 1)
{
sprintf(txtbuf, "lowpass Chebyshev %fHz %ith order %fdB ripple", frequency, order, ripple);
}
if(model == 2)
{
sprintf(txtbuf, "lowpass Bessel %fHz %ith order", frequency, order);
}
}
if(type == 2)
{
sprintf(txtbuf, "notch %fHz Q-factor %i", frequency, order);
}
if(type == 3)
{
if(model == 0)
{
sprintf(txtbuf, "bandpass Butterworth %f-%fHz %ith order", frequency, frequency2, order);
}
if(model == 1)
{
sprintf(txtbuf, "bandpass Chebyshev %f-%fHz %ith order %fdB ripple", frequency, frequency2, order, ripple);
}
if(model == 2)
{
sprintf(txtbuf, "bandpass Bessel %f-%fHz %ith order", frequency, frequency2, order);
}
}
if(type == 4)
{
if(model == 0)
{
sprintf(txtbuf, "bandstop Butterworth %f-%fHz %ith order", frequency, frequency2, order);
}
if(model == 1)
{
sprintf(txtbuf, "bandstop Chebyshev %f-%fHz %ith order %fdB ripple", frequency, frequency2, order, ripple);
}
if(model == 2)
{
sprintf(txtbuf, "bandstop Bessel %f-%fHz %ith order", frequency, frequency2, order);
}
}
remove_trailing_zeros(txtbuf);
filterItem->appendRow(new QStandardItem(txtbuf));
}
if(mainwindow->signalcomp[i]->ecg_filter != NULL)
{
sprintf(txtbuf, "ECG heartrate detection");
filterItem->appendRow(new QStandardItem(txtbuf));
}
if(mainwindow->signalcomp[i]->zratio_filter != NULL)
{
sprintf(txtbuf, "Z-ratio cross-over frequency is %.1f Hz", mainwindow->signalcomp[i]->zratio_crossoverfreq);
filterItem->appendRow(new QStandardItem(txtbuf));
}
}
sprintf(txtbuf, "timescale: %f seconds", (double)mainwindow->pagetime / (double)TIME_DIMENSION);
remove_trailing_zeros(txtbuf);
parentItem->appendRow(new QStandardItem(txtbuf));
tree->setModel(t_model);
tree->expandAll();
ShowMontageDialog->exec();
}
int main(int argc, char *argv[])
{
int i, j,
hdl,
chns=1,
smp_freq=8192,
fileduration=300,
linear=1;
double buf[smp_freq],
q,
sine_1,
startfreq=10.0,
stopfreq=4095.0,
freqspan,
freq;
long long samples,
sampleswritten;
char str[256];
#ifdef BDF_FORMAT
hdl = edfopen_file_writeonly("freq_sweep.bdf", EDFLIB_FILETYPE_BDFPLUS, chns);
#else
hdl = edfopen_file_writeonly("freq_sweep.edf", EDFLIB_FILETYPE_EDFPLUS, chns);
#endif
if(hdl<0)
{
printf("error: edfopen_file_writeonly()\n");
return(1);
}
for(i=0; i<chns; i++)
{
if(edf_set_samplefrequency(hdl, i, smp_freq))
{
printf("error: edf_set_samplefrequency()\n");
return(1);
}
}
#ifdef BDF_FORMAT
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 8388607))
{
printf("error: edf_set_digital_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -8388608))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
}
#else
for(i=0; i<chns; i++)
{
if(edf_set_digital_maximum(hdl, i, 32767))
{
printf("error: edf_set_digital_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_digital_minimum(hdl, i, -32768))
{
printf("error: edf_set_digital_minimum()\n");
return(1);
}
}
#endif
for(i=0; i<chns; i++)
{
if(edf_set_physical_maximum(hdl, i, 400.0))
{
printf("error: edf_set_physical_maximum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_minimum(hdl, i, -400.0))
{
printf("error: edf_set_physical_minimum()\n");
return(1);
}
}
for(i=0; i<chns; i++)
{
if(edf_set_physical_dimension(hdl, i, "uV"))
{
printf("error: edf_set_physical_dimension()\n");
return(1);
}
}
if(edf_set_label(hdl, 0, "sweep"))
{
printf("error: edf_set_label()\n");
return(1);
}
if(edf_set_equipment(hdl, "Software generated file"))
{
printf("edf_set_equipment()\n");
return(1);
}
if(linear)
{
sprintf(str, "Linear frequency sweep from %fHz to %fHz", startfreq, stopfreq);
}
else
{
sprintf(str, "Logarithmic frequency sweep from %fHz to %fHz", startfreq, stopfreq);
}
remove_trailing_zeros(str);
edf_set_patientname(hdl, str);
edfwrite_annotation_latin1(hdl, 0LL, -1LL, "Recording starts");
sine_1 = 0.0;
sampleswritten = 0;
samples = fileduration * (long long)smp_freq;
freqspan = stopfreq - startfreq;
for(j=0; j<fileduration; j++)
{
for(i=0; i<smp_freq; i++)
{
q = M_PI * 2.0;
q /= (smp_freq / freq);
sine_1 += q;
q = sin(sine_1);
q *= 200.0;
buf[i] = q;
if(linear)
{
freq = startfreq + (freqspan * ((double)sampleswritten / (double)samples));
}
else
{
// freq = exp10((((double)sampleswritten / (double)samples)) * log10(stopfreq));
freq = exp10(((((startfreq / stopfreq) * ((stopfreq / freqspan) * samples)) + sampleswritten) / ((stopfreq / freqspan) * samples)) * log10(stopfreq));
}
sampleswritten++;
}
if(edfwrite_physical_samples(hdl, buf))
{
printf("error: edfwrite_physical_samples()\n");
return(1);
}
if(!(j%10))
{
sprintf(str, "%fHz", freq);
remove_trailing_zeros(str);
edfwrite_annotation_latin1(hdl, j * 10000LL, -1LL, str);
}
}
sprintf(str, "%fHz", freq);
remove_trailing_zeros(str);
edfwrite_annotation_latin1(hdl, j * 10000LL, -1LL, str);
edfwrite_annotation_latin1(hdl, fileduration * 10000LL, -1LL, "Recording ends");
edfclose_file(hdl);
return(0);
}
void UI_FreqSpectrumWindow::sliderMoved(int)
{
long long startstep,
stopstep,
spanstep;
double max_freq,
start_freq;
char str[1024];
if(VlogCheckBox->checkState() == Qt::Checked)
{
mainwindow->spectrum_vlog = 1;
log_minslider->setVisible(true);
}
else
{
mainwindow->spectrum_vlog = 0;
log_minslider->setVisible(false);
}
if(sqrtCheckBox->checkState() == Qt::Checked)
{
mainwindow->spectrum_sqrt = 1;
sprintf(str, "Amplitude Spectrum %s", signallabel);
SpectrumDialog->setWindowTitle(str);
if(mainwindow->spectrum_vlog)
{
sprintf(str, "log10(%s)", physdimension);
curve1->setV_label(str);
}
else
{
curve1->setV_label(physdimension);
}
}
else
{
mainwindow->spectrum_sqrt = 0;
sprintf(str, "Power Spectral Density %s", signallabel);
SpectrumDialog->setWindowTitle(str);
if(mainwindow->spectrum_vlog)
{
sprintf(str, "log10((%s)^2/Hz)", physdimension);
}
else
{
sprintf(str, "(%s)^2/Hz", physdimension);
}
curve1->setV_label(str);
}
if(BWCheckBox->isChecked() == true)
{
curve1->setSignalColor(Qt::black);
curve1->setBackgroundColor(Qt::white);
curve1->setRasterColor(Qt::black);
curve1->setMarker1Color(Qt::black);
curve1->setBorderColor(Qt::white);
curve1->setTextColor(Qt::black);
curve1->setCrosshairColor(Qt::black);
mainwindow->spectrum_bw = 1;
}
else
{
curve1->setSignalColor(Qt::green);
curve1->setBackgroundColor(Qt::black);
curve1->setRasterColor(Qt::gray);
curve1->setMarker1Color(Qt::yellow);
curve1->setBorderColor(Qt::lightGray);
curve1->setTextColor(Qt::black);
curve1->setCrosshairColor(Qt::red);
mainwindow->spectrum_bw = 0;
}
spanstep = (long long)spanSlider->value() * (long long)steps / 1000LL;
startstep = (long long)centerSlider->value() * ((long long)steps - spanstep) / 1000LL;
stopstep = startstep + spanstep;
if(mainwindow->spectrum_sqrt)
{
if(mainwindow->spectrum_vlog)
{
curve1->drawCurve(buf5 + startstep, stopstep - startstep, (maxvalue_sqrt_vlog * ((double)flywheel_value / 1000.0) * (double)amplitudeSlider->value()) / 1000.0, minvalue_sqrt_vlog * (double)log_minslider->value() / 1000.0);
}
else
{
curve1->drawCurve(buf3 + startstep, stopstep - startstep, (maxvalue_sqrt * ((double)flywheel_value / 1000.0) * (double)amplitudeSlider->value()) / 1000.0, 0.0);
}
}
else
{
if(mainwindow->spectrum_vlog)
{
curve1->drawCurve(buf4 + startstep, stopstep - startstep, (maxvalue_vlog * ((double)flywheel_value / 1000.0) * (double)amplitudeSlider->value()) / 1000.0, minvalue_vlog * (double)log_minslider->value() / 1000.0);
}
else
{
curve1->drawCurve(buf2 + startstep, stopstep - startstep, (maxvalue * ((double)flywheel_value / 1000.0) * (double)amplitudeSlider->value()) / 1000.0, 0.0);
}
}
max_freq = ((double)samplefreq / 2.0) * stopstep / steps;
start_freq = ((double)samplefreq / 2.0) * startstep / steps;
// printf("steps: %i\n"
// "startstep: %lli\n"
// "stopstep: %lli\n"
// "spanstep: %lli\n"
// "samplefreq: %f\n"
// "max_freq: %f\n"
// "start_freq: %f\n",
// steps,
// startstep,
// stopstep,
// spanstep,
// samplefreq,
// max_freq,
// start_freq);
curve1->setH_RulerValues(start_freq, max_freq);
strcpy(str, "Center ");
convert_to_metric_suffix(str + strlen(str), start_freq + ((max_freq - start_freq) / 2.0), 3);
remove_trailing_zeros(str);
strcat(str, "Hz");
centerLabel->setText(str);
strcpy(str, "Span ");
convert_to_metric_suffix(str + strlen(str), max_freq - start_freq, 3);
remove_trailing_zeros(str);
strcat(str, "Hz");
spanLabel->setText(str);
}
void UI_FilterDialog::filtertypeboxvaluechanged(int type)
{
char str[256];
QObject::disconnect(orderbox, SIGNAL(valueChanged(int)), this, SLOT(orderboxvaluechanged(int)));
QObject::disconnect(modelbox, SIGNAL(currentIndexChanged(int)), this, SLOT(filtermodelboxvaluechanged(int)));
if(type == 2)
{
ripplebox->setVisible(FALSE);
ordervaluelabel->setVisible(TRUE);
orderboxlabel->setText("Notch Q-factor");
orderbox->setMaximum(100);
orderbox->setSingleStep(1);
orderbox->setMinimum(3);
orderbox->setValue(last_qfactor);
orderlabel->setText("-3 dB bandwidth:");
sprintf(str,"%f Hz", freqbox->value() / orderbox->value());
remove_trailing_zeros(str);
ordervaluelabel->setText(str);
modelbox->clear();
modelbox->addItem("Resonator");
}
else
{
orderboxlabel->setText("Order");
if((type == 3) || (type == 4))
{
orderbox->setMaximum(16);
orderbox->setSingleStep(2);
orderbox->setMinimum(2);
orderbox->setValue(last_order * 2);
}
else
{
orderbox->setMaximum(8);
orderbox->setSingleStep(1);
orderbox->setMinimum(1);
orderbox->setValue(last_order);
}
if(last_model == 3)
{
if(type < 2)
{
ripplebox->setVisible(FALSE);
ordervaluelabel->setVisible(FALSE);
orderlabel->setText("");
ordervaluelabel->setText("");
orderboxlabel->setText("Samples");
orderbox->setMaximum(10000);
orderbox->setSingleStep(1);
orderbox->setMinimum(2);
orderbox->setValue(last_samples);
}
else
{
last_model = 0;
}
}
if(last_model == 0)
{
ripplebox->setVisible(FALSE);
ordervaluelabel->setVisible(TRUE);
orderlabel->setText("Slope roll-off:");
ordervaluelabel->setText(QString::number(6 * last_order, 'f', 0).append(" dB / octave"));
}
if(last_model == 1)
{
ordervaluelabel->setVisible(FALSE);
ripplebox->setVisible(TRUE);
orderlabel->setText("passband ripple");
ordervaluelabel->setText("1 dB");
}
if(last_model == 2)
{
ripplebox->setVisible(FALSE);
ordervaluelabel->setVisible(TRUE);
orderlabel->setText("");
ordervaluelabel->setText("");
}
modelbox->clear();
modelbox->addItem("Butterworth");
modelbox->addItem("Chebyshev");
modelbox->addItem("Bessel");
if(type < 2)
{
modelbox->addItem("Moving Average");
}
modelbox->setCurrentIndex(last_model);
}
if((type == 3) || (type == 4))
{
freqboxlabel->setText("Frequency 1");
freqbox2label->setText("Frequency 2");
freqbox2label->setVisible(TRUE);
freq2box->setVisible(TRUE);
}
else
{
freqbox2label->setVisible(FALSE);
freq2box->setVisible(FALSE);
if(last_model == 3)
{
orderlabel->setText("");
ordervaluelabel->setText("");
freqboxlabel->setText("");
freqbox2label->setText("");
}
else
{
freqboxlabel->setText("Frequency");
freqbox2label->setText("");
}
}
QObject::connect(orderbox, SIGNAL(valueChanged(int)), this, SLOT(orderboxvaluechanged(int)));
QObject::connect(modelbox, SIGNAL(currentIndexChanged(int)), this, SLOT(filtermodelboxvaluechanged(int)));
updatecurve();
}
int save_annotations(UI_Mainwindow *mainwindow, FILE *outputfile, struct edfhdrblock *hdr, struct annotationblock *annotlist)
{
int i, j, k, n, p=0,
new_edfsignals=0,
signalslist[MAXSIGNALS],
datarecords,
annot_len,
annot_smp_per_record,
annot_recordsize,
timestamp_decimals,
timestamp_digits,
annots_per_datrec,
space,
progress_steps;
char *readbuf,
scratchpad[256],
*annot_buf;
long long time;
FILE *inputfile;
struct annotationblock *annot;
inputfile = hdr->file_hdl;
for(i=0; i<hdr->edfsignals; i++)
{
if(!hdr->edfparam[i].annotation)
{
signalslist[new_edfsignals] = i;
new_edfsignals++;
}
}
datarecords = hdr->datarecords;
time = (hdr->datarecords * hdr->long_data_record_duration) / TIME_DIMENSION;
timestamp_decimals = get_tal_timestamp_decimal_cnt(hdr);
if(timestamp_decimals < 0)
{
return(1);
}
timestamp_digits = get_tal_timestamp_digit_cnt(hdr);
if(timestamp_digits < 0)
{
return(1);
}
annot = annotlist;
annot_len = get_max_annotation_strlen(&annot);
i = edfplus_annotation_count(&annot);
annots_per_datrec = i / datarecords;
if(i % datarecords)
{
annots_per_datrec++;
}
annot_recordsize = (annot_len * annots_per_datrec) + timestamp_digits + timestamp_decimals + 4;
if(timestamp_decimals)
{
annot_recordsize++;
}
if(hdr->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;
}
}
readbuf = (char *)malloc(hdr->recordsize);
if(readbuf==NULL)
{
return(1);
}
annot_buf = (char *)malloc(annot_recordsize + 10);
if(annot_buf==NULL)
{
free(readbuf);
return(1);
}
///////////////////////////////////////////////////////////////////
rewind(outputfile);
if(hdr->edf)
{
fprintf(outputfile, "0 ");
}
else
{
fprintf(outputfile, "XBIOSEMI");
rewind(outputfile);
fputc(255, outputfile);
fseeko(outputfile, 0LL, SEEK_END);
}
fseeko(inputfile, 8LL, SEEK_SET);
if((hdr->edfplus)||(hdr->bdfplus))
{
if(fread(scratchpad, 176, 1, inputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(2);
}
if((hdr->genuine_nk) && (hdr->nk_triggers_read))
{
space = 0;
for(n=80; n<160; n++)
{
if(scratchpad[n] == ' ')
{
space++;
if(space > 3)
{
break;
}
}
}
n += 14;
if(n<150)
{
if(!strncmp(scratchpad + n, "EEG", 3))
{
scratchpad[n] = 'e';
scratchpad[n+1] = 'e';
scratchpad[n+2] = 'g';
}
}
}
if(fwrite(scratchpad, 176, 1, outputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(3);
}
}
else
{
sprintf(scratchpad, "X X X X ");
if(fread(scratchpad + 8, 80, 1, inputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(2);
}
if(fwrite(scratchpad, 80, 1, outputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(3);
}
sprintf(scratchpad, "Startdate X X X X ");
if(fread(scratchpad + 18, 80, 1, inputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(2);
}
if(fwrite(scratchpad, 80, 1, outputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(3);
}
if(fread(scratchpad, 16, 1, inputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(2);
}
if(fwrite(scratchpad, 16, 1, outputfile)!=1)
{
free(readbuf);
free(annot_buf);
return(3);
}
}
fprintf(outputfile, "%-8i", (new_edfsignals * 256) + 512);
if(hdr->edf)
{
fprintf(outputfile, "EDF+C");
}
else
{
fprintf(outputfile, "BDF+C");
}
for(i=0; i<39; i++)
{
fputc(' ', outputfile);
}
fprintf(outputfile, "%-8i", datarecords);
snprintf(scratchpad, 256, "%.12f", hdr->data_record_duration);
remove_trailing_zeros(scratchpad);
strcat(scratchpad, " ");
if((!strncmp(scratchpad, "0.", 2)) && (scratchpad[8] != ' '))
{
scratchpad[9] = 0;
fprintf(outputfile, "%s", scratchpad + 1);
}
else
{
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
fprintf(outputfile, "%-4i", new_edfsignals + 1);
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", hdr->edfparam[signalslist[i]].label);
}
if(hdr->edf)
{
fprintf(outputfile, "%s", "EDF Annotations ");
}
else
{
fprintf(outputfile, "%s", "BDF Annotations ");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", hdr->edfparam[signalslist[i]].transducer);
}
for(i=0; i<80; i++)
{
fputc(' ', outputfile);
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", hdr->edfparam[signalslist[i]].physdimension);
}
for(i=0; i<8; i++)
{
fputc(' ', outputfile);
}
for(i=0; i<new_edfsignals; i++)
{
snprintf(scratchpad, 256, "%f", hdr->edfparam[signalslist[i]].phys_min);
for(k=0; k<8; k++)
{
if(scratchpad[k]=='.')
{
for(j=7; j>=0; j--)
{
if((scratchpad[j]!='.')&&(scratchpad[j]!='0'))
{
break;
}
if(scratchpad[j]=='.')
{
scratchpad[j] = ' ';
break;
}
scratchpad[j] = ' ';
}
break;
}
scratchpad[8] = 0;
}
fprintf(outputfile, "%s", scratchpad);
}
fprintf(outputfile, "-1 ");
for(i=0; i<new_edfsignals; i++)
{
snprintf(scratchpad, 256, "%f", hdr->edfparam[signalslist[i]].phys_max);
for(k=0; k<8; k++)
{
if(scratchpad[k]=='.')
{
for(j=7; j>=0; j--)
{
if((scratchpad[j]!='.')&&(scratchpad[j]!='0'))
{
break;
}
if(scratchpad[j]=='.')
{
scratchpad[j] = ' ';
break;
}
scratchpad[j] = ' ';
}
break;
}
}
scratchpad[8] = 0;
fprintf(outputfile, "%s", scratchpad);
}
fprintf(outputfile, "1 ");
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%-8i", hdr->edfparam[signalslist[i]].dig_min);
}
if(hdr->edf)
{
fprintf(outputfile, "%s", "-32768 ");
}
else
{
fprintf(outputfile, "%s", "-8388608");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%-8i", hdr->edfparam[signalslist[i]].dig_max);
}
if(hdr->edf)
{
fprintf(outputfile, "%s", "32767 ");
}
else
{
fprintf(outputfile, "%s", "8388607 ");
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%s", hdr->edfparam[signalslist[i]].prefilter);
}
for(i=0; i<80; i++)
{
fputc(' ', outputfile);
}
for(i=0; i<new_edfsignals; i++)
{
fprintf(outputfile, "%-8i", hdr->edfparam[signalslist[i]].smp_per_record);
}
fprintf(outputfile, "%-8i", annot_smp_per_record);
for(i=0; i<((new_edfsignals * 32) + 32); i++)
{
fputc(' ', outputfile);
}
///////////////////////////////////////////////////////////////////
QProgressDialog progress("Saving file...", "Abort", 0, datarecords, mainwindow);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(200);
progress_steps = datarecords / 100;
if(progress_steps < 1)
{
progress_steps = 1;
}
fseeko(inputfile, (long long)(hdr->hdrsize), SEEK_SET);
annot = annotlist;
time = hdr->starttime_offset;
for(k=0; k<datarecords; k++)
{
if(!(k%progress_steps))
{
progress.setValue(k);
qApp->processEvents();
if(progress.wasCanceled() == true)
{
free(readbuf);
free(annot_buf);
return(4);
}
}
if(fread(readbuf, hdr->recordsize, 1, inputfile) != 1)
{
free(readbuf);
free(annot_buf);
return(2);
}
if(hdr->edf)
{
for(i=0; i<new_edfsignals; i++)
{
for(j=0; j<hdr->edfparam[signalslist[i]].smp_per_record; j++)
{
fputc(*((unsigned char *)(readbuf + hdr->edfparam[signalslist[i]].buf_offset + (j * 2))), outputfile);
fputc(*((unsigned char *)(readbuf + hdr->edfparam[signalslist[i]].buf_offset + (j * 2) + 1)), outputfile);
}
}
}
else
{
for(i=0; i<new_edfsignals; i++)
{
for(j=0; j<hdr->edfparam[signalslist[i]].smp_per_record; j++)
{
fputc(*((unsigned char *)(readbuf + hdr->edfparam[signalslist[i]].buf_offset + (j * 3))), outputfile);
fputc(*((unsigned char *)(readbuf + hdr->edfparam[signalslist[i]].buf_offset + (j * 3) + 1)), outputfile);
fputc(*((unsigned char *)(readbuf + hdr->edfparam[signalslist[i]].buf_offset + (j * 3) + 2)), outputfile);
}
}
}
#ifdef Q_OS_WIN32
switch(timestamp_decimals)
{
case 0 : p = __mingw_snprintf(annot_buf, 16, "+%lli", time / TIME_DIMENSION);
break;
case 1 : p = __mingw_snprintf(annot_buf, 16, "+%lli.%01lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 1000000LL);
break;
case 2 : p = __mingw_snprintf(annot_buf, 16, "+%lli.%02lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 100000LL);
break;
case 3 : p = __mingw_snprintf(annot_buf, 16, "+%lli.%03lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 10000LL);
break;
case 4 : p = __mingw_snprintf(annot_buf, 16, "+%lli.%04lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 1000LL);
break;
case 5 : p = __mingw_snprintf(annot_buf, 16, "+%lli.%05lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 100LL);
break;
case 6 : p = __mingw_snprintf(annot_buf, 16, "+%lli.%06lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 10LL);
break;
case 7 : p = __mingw_snprintf(annot_buf, 16, "+%lli.%07lli", time / TIME_DIMENSION, time % TIME_DIMENSION);
break;
}
#else
switch(timestamp_decimals)
{
case 0 : p = snprintf(annot_buf, 16, "+%lli", time / TIME_DIMENSION);
break;
case 1 : p = snprintf(annot_buf, 16, "+%lli.%01lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 1000000LL);
break;
case 2 : p = snprintf(annot_buf, 16, "+%lli.%02lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 100000LL);
break;
case 3 : p = snprintf(annot_buf, 16, "+%lli.%03lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 10000LL);
break;
case 4 : p = snprintf(annot_buf, 16, "+%lli.%04lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 1000LL);
break;
case 5 : p = snprintf(annot_buf, 16, "+%lli.%05lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 100LL);
break;
case 6 : p = snprintf(annot_buf, 16, "+%lli.%06lli", time / TIME_DIMENSION, (time % TIME_DIMENSION) / 10LL);
break;
case 7 : p = snprintf(annot_buf, 16, "+%lli.%07lli", time / TIME_DIMENSION, time % TIME_DIMENSION);
break;
}
#endif
annot_buf[p++] = 20;
annot_buf[p++] = 20;
annot_buf[p++] = 0;
if(annot!=NULL)
{
for(i=0; i<annots_per_datrec; i++)
{
if(annot!=NULL)
{
if(annot->onset<0)
{
#ifdef Q_OS_WIN32
p += __mingw_snprintf(annot_buf + p, 20, "-%lli.%07lli", -(annot->onset / TIME_DIMENSION), -(annot->onset % TIME_DIMENSION));
#else
p += snprintf(annot_buf + p, 20, "-%lli.%07lli", -(annot->onset / TIME_DIMENSION), -(annot->onset % TIME_DIMENSION));
#endif
}
else
{
#ifdef Q_OS_WIN32
p += __mingw_snprintf(annot_buf + p, 20, "+%lli.%07lli", annot->onset / TIME_DIMENSION, annot->onset % TIME_DIMENSION);
#else
p += snprintf(annot_buf + p, 20, "+%lli.%07lli", annot->onset / TIME_DIMENSION, annot->onset % TIME_DIMENSION);
#endif
}
for(j=0; j<7; j++)
{
if(annot_buf[p - j - 1] != '0')
{
break;
}
}
if(j)
{
p -= j;
if(j == 7)
{
p--;
}
}
if(annot->duration[0])
{
annot_buf[p++] = 21;
p += sprintf(annot_buf + p, "%s", annot->duration);
}
annot_buf[p++] = 20;
p += sprintf(annot_buf + p, "%s", annot->annotation);
annot_buf[p++] = 20;
annot_buf[p++] = 0;
annot = annot->next_annotation;
}
}
}
for(; p<annot_recordsize; p++)
{
annot_buf[p] = 0;
}
if(fwrite(annot_buf, annot_recordsize, 1, outputfile) != 1)
{
free(readbuf);
free(annot_buf);
return(3);
}
time += hdr->long_data_record_duration;
}
progress.reset();
free(readbuf);
free(annot_buf);
return(0);
}
void UI_SpectrumDockWindow::update_curve()
{
int i, j, k, n,
dftblocksize,
dftblocks,
samplesleft,
fft_outputbufsize;
long long s, s2;
char str[512];
double dig_value=0.0,
f_tmp=0.0;
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
if(signalcomp == NULL)
{
return;
}
if(busy)
{
return;
}
viewbuf = mainwindow->viewbuf;
if(viewbuf == NULL)
{
return;
}
busy = 1;
curve1->setUpdatesEnabled(false);
samples = signalcomp->samples_on_screen;
if(signalcomp->samples_on_screen > signalcomp->sample_stop)
{
samples = signalcomp->sample_stop;
}
samples -= signalcomp->sample_start;
if((samples < 10) || (viewbuf == NULL))
{
curve1->setUpdatesEnabled(true);
busy = 0;
if(spectrum_color != NULL)
{
for(i=0; i < spectrum_color->items; i++)
{
spectrum_color->value[i] = 0.0;
}
}
curve1->clear();
return;
}
if(buf1 != NULL)
{
free(buf1);
}
buf1 = (double *)malloc(sizeof(double) * signalcomp->samples_on_screen);
if(buf1 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.\n"
"Decrease the timescale and try again.");
messagewindow.exec();
return;
}
samples = 0;
for(s=signalcomp->sample_start; s<signalcomp->samples_on_screen; s++)
{
if(s>signalcomp->sample_stop) break;
dig_value = 0.0;
s2 = s + signalcomp->sample_timeoffset - signalcomp->sample_start;
for(j=0; j<signalcomp->num_of_signals; j++)
{
if(signalcomp->edfhdr->bdf)
{
var.two[0] = *((unsigned short *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset
+ ((s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record) * 3)));
var.four[2] = *((unsigned char *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset
+ ((s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record) * 3)
+ 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
f_tmp = var.one_signed;
}
if(signalcomp->edfhdr->edf)
{
f_tmp = *(((short *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset))
+ (s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record));
}
f_tmp += signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].offset;
f_tmp *= signalcomp->factor[j];
dig_value += f_tmp;
}
if(signalcomp->spike_filter)
{
if(s==signalcomp->sample_start)
{
spike_filter_restore_buf(signalcomp->spike_filter);
}
dig_value = run_spike_filter(dig_value, signalcomp->spike_filter);
}
for(k=0; k<signalcomp->filter_cnt; k++)
{
dig_value = first_order_filter(dig_value, signalcomp->filter[k]);
}
for(k=0; k<signalcomp->ravg_filter_cnt; k++)
{
if(s==signalcomp->sample_start)
{
ravg_filter_restore_buf(signalcomp->ravg_filter[k]);
}
dig_value = run_ravg_filter(dig_value, signalcomp->ravg_filter[k]);
}
for(k=0; k<signalcomp->fidfilter_cnt; k++)
{
if(s==signalcomp->sample_start)
{
memcpy(signalcomp->fidbuf[k], signalcomp->fidbuf2[k], fid_run_bufsize(signalcomp->fid_run[k]));
}
dig_value = signalcomp->fidfuncp[k](signalcomp->fidbuf[k], dig_value);
}
if(signalcomp->ecg_filter != NULL)
{
if(s==signalcomp->sample_start)
{
ecg_filter_restore_buf(signalcomp->ecg_filter);
}
dig_value = run_ecg_filter(dig_value, signalcomp->ecg_filter);
}
if(s>=signalcomp->sample_start)
{
buf1[samples++] = dig_value * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue;
}
}
samplefreq = (double)signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record / ((double)signalcomp->edfhdr->long_data_record_duration / TIME_DIMENSION);
dftblocksize = mainwindow->maxdftblocksize;
if(dftblocksize & 1)
{
dftblocksize--;
}
dftblocks = 1;
if(dftblocksize < samples)
{
dftblocks = samples / dftblocksize;
}
else
{
dftblocksize = samples;
}
if(dftblocksize & 1)
{
dftblocksize--;
}
samplesleft = samples % dftblocksize;
if(samplesleft & 1)
{
samplesleft--;
}
freqstep = samplefreq / (double)dftblocksize;
fft_outputbufsize = dftblocksize / 2;
steps = fft_outputbufsize;
if(buf2 != NULL)
{
free(buf2);
}
buf2 = (double *)calloc(1, sizeof(double) * fft_outputbufsize);
if(buf2 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
buf1 = NULL;
return;
}
if(buf3 != NULL)
{
free(buf3);
}
buf3 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf3 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
buf1 = NULL;
buf2 = NULL;
return;
}
if(buf4 != NULL)
{
free(buf4);
}
buf4 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf4 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
return;
}
if(buf5 != NULL)
{
free(buf5);
}
buf5 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf5 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
free(buf4);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
buf4 = NULL;
return;
}
if(init_maxvalue && !set_settings)
{
maxvalue = 0.000001;
maxvalue_sqrt = 0.000001;
maxvalue_vlog = 0.000001;
maxvalue_sqrt_vlog = 0.000001;
minvalue_vlog = 0.0;
minvalue_sqrt_vlog = 0.0;
}
if(set_settings)
{
maxvalue = settings.maxvalue;
maxvalue_sqrt = settings.maxvalue_sqrt;
maxvalue_vlog = settings.maxvalue_vlog;
maxvalue_sqrt_vlog = settings.maxvalue_sqrt_vlog;
minvalue_vlog = settings.minvalue_vlog;
minvalue_sqrt_vlog = settings.minvalue_sqrt_vlog;
}
kiss_fftr_cfg cfg;
kiss_fft_cpx *kiss_fftbuf;
kiss_fftbuf = (kiss_fft_cpx *)malloc((fft_outputbufsize + 1) * sizeof(kiss_fft_cpx));
if(kiss_fftbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
free(buf4);
free(buf5);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
buf4 = NULL;
buf5 = NULL;
return;
}
cfg = kiss_fftr_alloc(dftblocksize, 0, NULL, NULL);
for(j=0; j<dftblocks; j++)
{
kiss_fftr(cfg, buf1 + (j * dftblocksize), kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] += (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize);
}
}
if(samplesleft)
{
kiss_fftr(cfg, buf1 + (((j-1) * dftblocksize) + samplesleft), kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] += (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize);
buf2[i] /= (dftblocks + 1);
}
}
else
{
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] /= dftblocks;
}
}
if(signalcomp->ecg_filter == NULL)
{
buf2[0] /= 2.0; // DC!
}
else
{
buf2[0] = 0.0; // Remove DC because heart rate is always a positive value
}
free(cfg);
free(kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] /= samplefreq;
buf3[i] = sqrt(buf2[i] * freqstep);
if(buf2[i] <= SPECT_LOG_MINIMUM)
{
buf4[i] = log10(SPECT_LOG_MINIMUM);
}
else
{
buf4[i] = log10(buf2[i]);
}
if(buf3[i] <= SPECT_LOG_MINIMUM)
{
buf5[i] = log10(SPECT_LOG_MINIMUM);
}
else
{
buf5[i] = log10(buf3[i]);
}
if(init_maxvalue && !set_settings)
{
if(i) // don't use the dc-bin for the autogain of the screen
{
if(buf2[i] > maxvalue)
{
maxvalue = buf2[i];
}
if(buf3[i] > maxvalue_sqrt)
{
maxvalue_sqrt = buf3[i];
}
if(buf4[i] > maxvalue_vlog)
{
maxvalue_vlog = buf4[i];
}
if(buf5[i] > maxvalue_sqrt_vlog)
{
maxvalue_sqrt_vlog = buf5[i];
}
if((buf4[i] < minvalue_vlog) && (buf4[i] >= SPECT_LOG_MINIMUM_LOG))
{
minvalue_vlog = buf4[i];
}
if((buf5[i] < minvalue_sqrt_vlog) && (buf5[i] >= SPECT_LOG_MINIMUM_LOG))
{
minvalue_sqrt_vlog = buf5[i];
}
}
}
}
if(init_maxvalue)
{
if(minvalue_vlog < SPECT_LOG_MINIMUM_LOG)
minvalue_vlog = SPECT_LOG_MINIMUM_LOG;
if(minvalue_sqrt_vlog < SPECT_LOG_MINIMUM_LOG)
minvalue_sqrt_vlog = SPECT_LOG_MINIMUM_LOG;
}
if(samplesleft)
{
dftblocks++;
}
if(buf1 != NULL)
{
free(buf1);
buf1 = NULL;
}
sprintf(str, "FFT resolution: %f Hz %i blocks of %i samples", freqstep, dftblocks, dftblocksize);
remove_trailing_zeros(str);
curve1->setUpperLabel1(str);
curve1->setUpperLabel2(signallabel);
if(spectrum_color != NULL)
{
if(spectrum_color->items > 0)
{
spectrum_color->value[0] = 0.0;
n = 0;
for(j=0; j<steps; j++)
{
if(((freqstep * j) + (freqstep * 0.5)) < spectrum_color->freq[0])
{
if(spectrum_color->method == 0) // sum
{
spectrum_color->value[0] += buf2[j];
}
if(spectrum_color->method == 1) // peak
{
if(spectrum_color->value[0] < buf2[j])
{
spectrum_color->value[0] = buf2[j];
}
}
if(spectrum_color->method == 2) // average
{
spectrum_color->value[0] += buf2[j];
n++;
}
}
}
if(spectrum_color->method == 2) // average
{
if(n)
{
spectrum_color->value[0] /= n;
}
}
}
for(i=1; i < spectrum_color->items; i++)
{
spectrum_color->value[i] = 0.0;
n = 0;
for(j=0; j<steps; j++)
{
if((((freqstep * j) + (freqstep * 0.5)) > spectrum_color->freq[i-1]) && (((freqstep * j) + (freqstep * 0.5)) < spectrum_color->freq[i]))
{
if(spectrum_color->method == 0) // sum
{
spectrum_color->value[i] += buf2[j];
}
if(spectrum_color->method == 1) // peak
{
if(spectrum_color->value[i] < buf2[j])
{
spectrum_color->value[i] = buf2[j];
}
}
if(spectrum_color->method == 2) // average
{
spectrum_color->value[i] += buf2[j];
n++;
}
}
}
if(spectrum_color->method == 2) // average
{
if(n)
{
spectrum_color->value[i] /= n;
}
}
}
}
if(mainwindow->spectrumdock_sqrt)
{
snprintf(str, 512, "Amplitude Spectrum %s", signallabel);
}
else
{
snprintf(str, 512, "Power Spectrum %s", signallabel);
}
dock->setWindowTitle(str);
if(set_settings)
{
set_settings = 0;
if((settings.amp >= 1) && (settings.amp <= 2000))
{
amplitudeSlider->setValue(settings.amp);
}
if((settings.log_min_sl >= 1) && (settings.log_min_sl <= 2000))
{
log_minslider->setValue(settings.log_min_sl);
}
if((settings.span >= 10) && (settings.span <= 1000))
{
spanSlider->setValue(settings.span);
}
if((settings.center >= 0) && (settings.center <= 1000))
{
centerSlider->setValue(settings.center);
}
if(settings.sqrt > 0)
{
sqrtButton->setChecked(true);
}
else
{
sqrtButton->setChecked(false);
}
if(settings.log > 0)
{
vlogButton->setChecked(true);
log_minslider->setVisible(true);
}
else
{
vlogButton->setChecked(false);
log_minslider->setVisible(false);
}
if(settings.colorbar > 0)
{
colorBarButton->setChecked(true);
}
else
{
colorBarButton->setChecked(false);
}
if((flywheel_value >= 10) && (flywheel_value <= 100000))
{
flywheel_value = settings.wheel;
}
}
sliderMoved(0);
curve1->setUpdatesEnabled(true);
busy = 0;
init_maxvalue = 0;
}
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::SelectFileButton()
{
int i, j,
days;
long long seconds,
milliSec;
char txt_string[2048],
str[256];
label1->clear();
label4->clear();
label5->clear();
SignalsTablewidget->setRowCount(0);
inputfile = NULL;
outputfile = NULL;
inputpath[0] = 0;
edfhdr = NULL;
file_num = -1;
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->setChecked(true);
radioButton1->setEnabled(false);
radioButton2->setEnabled(false);
label2->setEnabled(false);
label3->setEnabled(false);
label4->setEnabled(false);
label5->setEnabled(false);
UI_activeFileChooserWindow afchooser(&file_num, mainwindow);
if(file_num < 0)
{
return;
}
edfhdr = mainwindow->edfheaderlist[file_num];
strcpy(inputpath, edfhdr->filename);
inputfile = edfhdr->file_hdl;
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();
inputpath[0] = 0;
edfhdr = NULL;
file_num = -1;
return;
}
if(edfhdr->datarecords > 2147483647LL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Failure", "This file contains more than 2147483647 datarecords.\n"
"This tool can not handle more than 2147483647 datarecords.");
messagewindow.exec();
inputfile = NULL;
inputpath[0] = 0;
edfhdr = NULL;
file_num = -1;
return;
}
/***************** load signalproperties ******************************/
label1->setText(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)
{
((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->setEnabled(false);
}
if(!(edfhdr->edfparam[i].annotation))
{
SignalsTablewidget->setCellWidget(i, 1, new QComboBox);
((QComboBox *)(SignalsTablewidget->cellWidget(i, 1)))->setEditable(false);
for(j=1; j<=edfhdr->edfparam[i].smp_per_record; j++)
{
if(!(edfhdr->edfparam[i].smp_per_record % j))
{
snprintf(str, 256, "%i (%f", j, ((double)(edfhdr->edfparam[i].smp_per_record / j)) / edfhdr->data_record_duration);
remove_trailing_zeros(str);
strcat(str, " Hz)");
((QComboBox *)(SignalsTablewidget->cellWidget(i, 1)))->addItem(str, QVariant(j));
}
}
}
}
pushButton3->setEnabled(true);
pushButton4->setEnabled(true);
pushButton5->setEnabled(true);
pushButton6->setEnabled(true);
spinBox1->setValue(1);
spinBox2->setMaximum(edfhdr->datarecords);
spinBox2->setValue(edfhdr->datarecords);
spinBox1->setMaximum(edfhdr->datarecords);
spinBox3->setEnabled(true);
spinBox4->setEnabled(true);
radioButton1->setEnabled(true);
radioButton2->setEnabled(true);
label4->setText("0:00:00.000");
days = (int)(((edfhdr->datarecords * edfhdr->long_data_record_duration) / TIME_DIMENSION) / 86400LL);
seconds = (edfhdr->datarecords * edfhdr->long_data_record_duration) / TIME_DIMENSION;
seconds %= 86400LL;
milliSec = (edfhdr->datarecords * edfhdr->long_data_record_duration) % TIME_DIMENSION;
milliSec /= 10000LL;
if(days)
{
sprintf(txt_string, "%id %i:%02i:%02i.%03i", days, (int)(seconds / 3600), (int)((seconds % 3600) / 60), (int)(seconds % 60), (int)milliSec);
}
else
{
sprintf(txt_string, "%i:%02i:%02i.%03i", (int)(seconds / 3600), (int)((seconds % 3600) / 60), (int)(seconds % 60), (int)milliSec);
}
label5->setText(txt_string);
}
void UI_EDFhdrwindow::show_params(int row)
{
int i,
signal_cnt;
char str[512];
long long file_duration;
struct date_time_struct date_time;
if(row<0) return;
if(mainwindow->edfheaderlist[row]->edfplus || mainwindow->edfheaderlist[row]->bdfplus)
{
edfplus_layout = 1;
EDFhdrDialog->setMinimumSize(QSize(690, 765));
EDFhdrDialog->setMaximumSize(QSize(690, 765));
pushButton1->setGeometry(QRect(580, 730, 100, 25));
signallist->setGeometry(QRect(10, 580, 670, 100));
label20a->setGeometry(QRect(150, 545, 100, 25));
label20->setGeometry(QRect(10, 545, 130, 25));
label21->setGeometry(QRect(410, 545, 80, 25));
label21a->setGeometry(QRect(500, 545, 180, 25));
label5a->setGeometry(QRect(150, 500, 350, 25));
label5->setGeometry(QRect(10, 500, 80, 25));
label4a->setGeometry(QRect(500, 465, 180, 25));
label4->setGeometry(QRect(410, 465, 80, 25));
label3a->setGeometry(QRect(150, 465, 180, 25));
label3->setGeometry(QRect(10, 465, 80, 25));
label1a->setGeometry(QRect(150, 120, 530, 25));
label1a->setText(mainwindow->edfheaderlist[row]->plus_patientcode);
label1->setGeometry(QRect(10, 120, 130, 25));
label1->setText("Subject code");
label2a->setGeometry(QRect(150, 155, 530, 25));
label2a->setText(mainwindow->edfheaderlist[row]->plus_gender);
label2->setGeometry(QRect(10, 155, 130, 25));
label2->setText("Sex");
label6->setVisible(TRUE);
label6a->setVisible(TRUE);
label6a->setText(mainwindow->edfheaderlist[row]->plus_birthdate);
label7->setVisible(TRUE);
label7a->setVisible(TRUE);
label7a->setText(mainwindow->edfheaderlist[row]->plus_patient_name);
label8->setVisible(TRUE);
label8a->setVisible(TRUE);
label8a->setText(mainwindow->edfheaderlist[row]->plus_patient_additional);
label9->setVisible(TRUE);
label9a->setVisible(TRUE);
label9a->setText(mainwindow->edfheaderlist[row]->plus_startdate);
label10->setVisible(TRUE);
label10a->setVisible(TRUE);
label10a->setText(mainwindow->edfheaderlist[row]->plus_admincode);
label11->setVisible(TRUE);
label11a->setVisible(TRUE);
label11a->setText(mainwindow->edfheaderlist[row]->plus_technician);
label12->setVisible(TRUE);
label12a->setVisible(TRUE);
label12a->setText(mainwindow->edfheaderlist[row]->plus_equipment);
label13->setVisible(TRUE);
label13a->setVisible(TRUE);
label13a->setText(mainwindow->edfheaderlist[row]->plus_recording_additional);
}
else
{
label6->setVisible(FALSE);
label6a->setVisible(FALSE);
label7->setVisible(FALSE);
label7a->setVisible(FALSE);
label8->setVisible(FALSE);
label8a->setVisible(FALSE);
label9->setVisible(FALSE);
label9a->setVisible(FALSE);
label10->setVisible(FALSE);
label10a->setVisible(FALSE);
label11->setVisible(FALSE);
label11a->setVisible(FALSE);
label12->setVisible(FALSE);
label12a->setVisible(FALSE);
label13->setVisible(FALSE);
label13a->setVisible(FALSE);
EDFhdrDialog->setMinimumSize(QSize(690, 480));
EDFhdrDialog->setMaximumSize(QSize(690, 480));
label1->setGeometry(QRect(10, 120, 80, 25));
label1->setText("Subject");
label1a->setGeometry(QRect(100, 120, 580, 25));
label1a->setText(mainwindow->edfheaderlist[row]->patient);
label2->setGeometry(QRect(10, 155, 80, 25));
label2->setText("Recording");
label2a->setGeometry(QRect(100, 155, 580, 25));
label2a->setText(mainwindow->edfheaderlist[row]->recording);
label3a->setGeometry(QRect(100, 190, 180, 25));
label3->setGeometry(QRect(10, 190, 80, 25));
label4a->setGeometry(QRect(500, 190, 180, 25));
label4->setGeometry(QRect(410, 190, 80, 25));
label5a->setGeometry(QRect(100, 225, 350, 25));
label5->setGeometry(QRect(10, 225, 80, 25));
label20->setGeometry(QRect(10, 260, 130, 25));
label20a->setGeometry(QRect(150, 260, 100, 25));
label21->setGeometry(QRect(410, 260, 80, 25));
label21a->setGeometry(QRect(500, 260, 180, 25));
signallist->setGeometry(QRect(10, 295, 670, 100));
pushButton1->setGeometry(QRect(580, 445, 100, 25));
}
utc_to_date_time(mainwindow->edfheaderlist[row]->utc_starttime, &date_time);
date_time.month_str[0] += 32;
date_time.month_str[1] += 32;
date_time.month_str[2] += 32;
snprintf(str, 400, "%i %s %i %2i:%02i:%02i",
date_time.day,
date_time.month_str,
date_time.year,
date_time.hour,
date_time.minute,
date_time.second);
if(mainwindow->edfheaderlist[row]->starttime_offset != 0LL)
{
#ifdef Q_WS_WIN
snprintf(str + strlen(str), 100, ".%07I64d", mainwindow->edfheaderlist[row]->starttime_offset);
#else
snprintf(str + strlen(str), 100, ".%07lli", mainwindow->edfheaderlist[row]->starttime_offset);
#endif
remove_trailing_zeros(str);
}
label3a->setText(str);
file_duration = mainwindow->edfheaderlist[row]->long_data_record_duration * mainwindow->edfheaderlist[row]->datarecords;
snprintf(str, 512,
"%2i:%02i:%02i",
(int)((file_duration / TIME_DIMENSION)/ 3600LL),
(int)(((file_duration / TIME_DIMENSION) % 3600LL) / 60LL),
(int)((file_duration / TIME_DIMENSION) % 60LL));
label4a->setText(str);
label5a->setText(mainwindow->edfheaderlist[row]->reserved);
snprintf(str, 512, "%.12f", mainwindow->edfheaderlist[row]->data_record_duration);
remove_trailing_zeros(str);
label20a->setText(str);
label21a->setText(mainwindow->edfheaderlist[row]->version);
signal_cnt = mainwindow->edfheaderlist[row]->edfsignals;
signallist->setColumnCount(10);
signallist->setRowCount(signal_cnt);
signallist->setSelectionMode(QAbstractItemView::NoSelection);
signallist->setColumnWidth(0, 180);
signallist->setColumnWidth(1, 120);
signallist->setColumnWidth(2, 120);
signallist->setColumnWidth(3, 120);
signallist->setColumnWidth(4, 120);
signallist->setColumnWidth(5, 120);
signallist->setColumnWidth(6, 120);
signallist->setColumnWidth(7, 120);
signallist->setColumnWidth(8, 520);
signallist->setColumnWidth(9, 520);
QStringList horizontallabels;
horizontallabels += "Label";
horizontallabels += "Samplefrequency";
horizontallabels += "Physical maximum";
horizontallabels += "Physical minimum";
horizontallabels += "Physical dimension";
horizontallabels += "Digital maximum";
horizontallabels += "Digital minimum";
horizontallabels += "Samples per record";
horizontallabels += "Prefilter";
horizontallabels += "Transducer";
signallist->setHorizontalHeaderLabels(horizontallabels);
for(i=0; i<signal_cnt; i++)
{
signallist->setRowHeight(i, 20);
signallist->setCellWidget(i, 0, new QLabel(mainwindow->edfheaderlist[row]->edfparam[i].label));
snprintf(str, 512, "%f", (double)mainwindow->edfheaderlist[row]->edfparam[i].smp_per_record / mainwindow->edfheaderlist[row]->data_record_duration);
strcat(str, " Hz");
remove_trailing_zeros(str);
signallist->setCellWidget(i, 1, new QLabel(str));
snprintf(str, 512, "%+f", mainwindow->edfheaderlist[row]->edfparam[i].phys_max);
remove_trailing_zeros(str);
signallist->setCellWidget(i, 2, new QLabel(str));
snprintf(str, 512, "%+f", mainwindow->edfheaderlist[row]->edfparam[i].phys_min);
remove_trailing_zeros(str);
signallist->setCellWidget(i, 3, new QLabel(str));
signallist->setCellWidget(i, 4, new QLabel(mainwindow->edfheaderlist[row]->edfparam[i].physdimension));
snprintf(str, 512, "%+i", mainwindow->edfheaderlist[row]->edfparam[i].dig_max);
signallist->setCellWidget(i, 5, new QLabel(str));
snprintf(str, 512, "%+i", mainwindow->edfheaderlist[row]->edfparam[i].dig_min);
signallist->setCellWidget(i, 6, new QLabel(str));
snprintf(str, 512, "%i", mainwindow->edfheaderlist[row]->edfparam[i].smp_per_record);
signallist->setCellWidget(i, 7, new QLabel(str));
signallist->setCellWidget(i, 8, new QLabel(mainwindow->edfheaderlist[row]->edfparam[i].prefilter));
signallist->setCellWidget(i, 9, new QLabel(mainwindow->edfheaderlist[row]->edfparam[i].transducer));
}
}
UI_FreqSpectrumWindow::UI_FreqSpectrumWindow(struct signalcompblock *signal_comp, char *view_buf, UI_FreqSpectrumWindow **spectrdialog, int number, QWidget *w_parent)
{
int i;
char str[1024];
long long l_temp;
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
buf4 = NULL;
buf5 = NULL;
busy = 0;
spectrumdialog_is_destroyed = 0;
class_is_deleted = 0;
flywheel_value = 1050;
spectrumdialog = spectrdialog;
spectrumdialognumber = number;
mainwindow = (UI_Mainwindow *)w_parent;
viewbuf = view_buf;
signalcomp = signal_comp;
for(i=strlen(signalcomp->edfhdr->filename); i>0; i--)
{
if((signalcomp->edfhdr->filename[i-1]=='/')||(signalcomp->edfhdr->filename[i-1]=='\\')) break;
}
if((signalcomp->edfhdr->viewtime + signalcomp->edfhdr->starttime_offset)>=0LL)
{
if(signalcomp->alias[0] != 0)
{
snprintf(signallabel, 512, " %s %i:%02i:%02i.%04i %s", signalcomp->alias,
(int)((signalcomp->edfhdr->viewtime / TIME_DIMENSION)/ 3600LL),
(int)(((signalcomp->edfhdr->viewtime / TIME_DIMENSION) % 3600LL) / 60LL),
(int)((signalcomp->edfhdr->viewtime / TIME_DIMENSION) % 60LL),
(int)((signalcomp->edfhdr->viewtime % TIME_DIMENSION) / 1000LL),
signalcomp->edfhdr->filename + i);
}
else
{
snprintf(signallabel, 512, " %s %i:%02i:%02i.%04i %s", signalcomp->signallabel,
(int)((signalcomp->edfhdr->viewtime / TIME_DIMENSION)/ 3600LL),
(int)(((signalcomp->edfhdr->viewtime / TIME_DIMENSION) % 3600LL) / 60LL),
(int)((signalcomp->edfhdr->viewtime / TIME_DIMENSION) % 60LL),
(int)((signalcomp->edfhdr->viewtime % TIME_DIMENSION) / 1000LL),
signalcomp->edfhdr->filename + i);
}
}
else
{
l_temp = signalcomp->edfhdr->l_starttime + ((signalcomp->edfhdr->viewtime + signalcomp->edfhdr->starttime_offset) % (86400LL * TIME_DIMENSION));
if(l_temp<=0)
{
l_temp = (86400LL * TIME_DIMENSION) + l_temp;
}
l_temp = -signalcomp->edfhdr->viewtime;
if(signalcomp->alias[0] != 0)
{
snprintf(signallabel, 512, " %s -%i:%02i:%02i.%04i %s", signalcomp->alias,
(int)((l_temp / TIME_DIMENSION)/ 3600LL),
(int)(((l_temp / TIME_DIMENSION) % 3600LL) / 60LL),
(int)((l_temp / TIME_DIMENSION) % 60LL),
(int)((l_temp % TIME_DIMENSION) / 1000LL),
signalcomp->edfhdr->filename + i);
}
else
{
snprintf(signallabel, 512, " %s -%i:%02i:%02i.%04i %s", signalcomp->signallabel,
(int)((l_temp / TIME_DIMENSION)/ 3600LL),
(int)(((l_temp / TIME_DIMENSION) % 3600LL) / 60LL),
(int)((l_temp / TIME_DIMENSION) % 60LL),
(int)((l_temp % TIME_DIMENSION) / 1000LL),
signalcomp->edfhdr->filename + i);
}
}
remove_trailing_zeros(signallabel);
strcpy(physdimension, signalcomp->physdimension);
SpectrumDialog = new QDialog();
SpectrumDialog->setAttribute(Qt::WA_DeleteOnClose, true);
SpectrumDialog->setMinimumSize(QSize(650, 480));
SpectrumDialog->setSizeGripEnabled(true);
SpectrumDialog->setModal(false);
SpectrumDialog->setWindowFlags(Qt::Window | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint);
if(mainwindow->spectrum_sqrt)
{
snprintf(str, 512, "Amplitude Spectrum %s", signallabel);
}
else
{
snprintf(str, 512, "Power Spectral Density %s", signallabel);
}
SpectrumDialog->setWindowTitle(str);
SpectrumDialog->setWindowIcon(QIcon(":/images/edf.png"));
curve1 = new SignalCurve;
curve1->setSignalColor(Qt::green);
curve1->setBackgroundColor(Qt::black);
curve1->setRasterColor(Qt::gray);
curve1->setTraceWidth(0);
curve1->setH_label("Hz");
curve1->setLowerLabel("Frequency");
if(mainwindow->spectrum_sqrt)
{
if(mainwindow->spectrum_vlog)
{
sprintf(str, "log10(%s)", physdimension);
curve1->setV_label(str);
}
else
{
curve1->setV_label(physdimension);
}
}
else
{
if(mainwindow->spectrum_vlog)
{
sprintf(str, "log10((%s)^2/Hz)", physdimension);
}
else
{
sprintf(str, "(%s)^2/Hz", physdimension);
}
curve1->setV_label(str);
}
curve1->create_button("to Text");
curve1->setDashBoardEnabled(false);
flywheel1 = new UI_Flywheel;
flywheel1->setMinimumSize(20, 85);
amplitudeSlider = new QSlider;
amplitudeSlider->setOrientation(Qt::Vertical);
amplitudeSlider->setMinimum(1);
amplitudeSlider->setMaximum(2000);
amplitudeSlider->setValue(1000);
amplitudeSlider->setInvertedAppearance(true);
amplitudeSlider->setMinimumSize(15, 280);
log_minslider = new QSlider;
log_minslider->setOrientation(Qt::Vertical);
log_minslider->setMinimum(1);
log_minslider->setMaximum(2000);
log_minslider->setValue(1000);
log_minslider->setInvertedAppearance(false);
log_minslider->setMinimumSize(15, 280);
amplitudeLabel = new QLabel;
amplitudeLabel->setText("Amplitude");
amplitudeLabel->setMinimumSize(100, 15);
amplitudeLabel->setAlignment(Qt::AlignHCenter);
sqrtCheckBox = new QCheckBox("Amplitude");
sqrtCheckBox->setMinimumSize(70, 25);
sqrtCheckBox->setTristate(false);
if(mainwindow->spectrum_sqrt)
{
sqrtCheckBox->setCheckState(Qt::Checked);
}
else
{
sqrtCheckBox->setCheckState(Qt::Unchecked);
}
VlogCheckBox = new QCheckBox("Log");
VlogCheckBox->setMinimumSize(70, 25);
VlogCheckBox->setTristate(false);
if(mainwindow->spectrum_vlog)
{
VlogCheckBox->setCheckState(Qt::Checked);
log_minslider->setVisible(true);
}
else
{
VlogCheckBox->setCheckState(Qt::Unchecked);
log_minslider->setVisible(false);
}
BWCheckBox = new QCheckBox("B/W");
BWCheckBox->setMinimumSize(70, 25);
BWCheckBox->setTristate(false);
if(mainwindow->spectrum_bw == 1)
{
BWCheckBox->setCheckState(Qt::Checked);
}
else
{
BWCheckBox->setCheckState(Qt::Unchecked);
}
vlayout3 = new QVBoxLayout;
vlayout3->addStretch(100);
vlayout3->addWidget(flywheel1, 100);
vlayout3->addStretch(100);
hlayout4 = new QHBoxLayout;
hlayout4->addStretch(100);
hlayout4->addLayout(vlayout3, 100);
hlayout4->addStretch(100);
hlayout4->addWidget(amplitudeSlider, 300);
hlayout4->addWidget(log_minslider, 300);
vlayout2 = new QVBoxLayout;
vlayout2->setSpacing(10);
vlayout2->addStretch(100);
vlayout2->addWidget(amplitudeLabel, 0, Qt::AlignHCenter);
vlayout2->addLayout(hlayout4, 200);
vlayout2->addWidget(sqrtCheckBox);
vlayout2->addWidget(VlogCheckBox);
vlayout2->addWidget(BWCheckBox);
spanSlider = new QSlider;
spanSlider->setOrientation(Qt::Horizontal);
spanSlider->setMinimum(10);
spanSlider->setMaximum(1000);
spanSlider->setValue(1000);
spanSlider->setMinimumSize(500, 15);
spanLabel = new QLabel;
spanLabel->setText("Span");
spanLabel->setMinimumSize(110, 15);
spanLabel->setAlignment(Qt::AlignHCenter);
centerSlider = new QSlider;
centerSlider->setOrientation(Qt::Horizontal);
centerSlider->setMinimum(0);
centerSlider->setMaximum(1000);
centerSlider->setValue(0);
centerSlider->setMinimumSize(500, 15);
centerLabel = new QLabel;
centerLabel->setText("Center");
centerLabel->setMinimumSize(110, 15);
centerLabel->setAlignment(Qt::AlignHCenter);
hlayout1 = new QHBoxLayout;
hlayout1->setSpacing(20);
hlayout1->addLayout(vlayout2);
hlayout1->addWidget(curve1, 100);
hlayout2 = new QHBoxLayout;
hlayout2->setSpacing(20);
hlayout2->addWidget(spanLabel);
hlayout2->addWidget(spanSlider);
hlayout2->addStretch(100);
hlayout3 = new QHBoxLayout;
hlayout3->setSpacing(20);
hlayout3->addWidget(centerLabel);
hlayout3->addWidget(centerSlider);
hlayout3->addStretch(100);
vlayout1 = new QVBoxLayout;
vlayout1->setSpacing(20);
vlayout1->addLayout(hlayout1);
vlayout1->addLayout(hlayout2);
vlayout1->addLayout(hlayout3);
SpectrumDialog->setLayout(vlayout1);
t1 = new QTimer(this);
t1->setSingleShot(true);
t1->start(10);
QObject::connect(t1, SIGNAL(timeout()), this, SLOT(update_curve()));
QObject::connect(amplitudeSlider, SIGNAL(valueChanged(int)), this, SLOT(sliderMoved(int)));
QObject::connect(log_minslider, SIGNAL(valueChanged(int)), this, SLOT(sliderMoved(int)));
QObject::connect(spanSlider, SIGNAL(valueChanged(int)), this, SLOT(sliderMoved(int)));
QObject::connect(centerSlider, SIGNAL(valueChanged(int)), this, SLOT(sliderMoved(int)));
QObject::connect(sqrtCheckBox, SIGNAL(stateChanged(int)), this, SLOT(sliderMoved(int)));
QObject::connect(VlogCheckBox, SIGNAL(stateChanged(int)), this, SLOT(sliderMoved(int)));
QObject::connect(BWCheckBox, SIGNAL(stateChanged(int)), this, SLOT(sliderMoved(int)));
QObject::connect(SpectrumDialog, SIGNAL(destroyed(QObject *)), this, SLOT(SpectrumDialogDestroyed(QObject *)));
QObject::connect(curve1, SIGNAL(extra_button_clicked()), this, SLOT(print_to_txt()));
QObject::connect(flywheel1, SIGNAL(dialMoved(int)), this, SLOT(update_flywheel(int)));
SpectrumDialog->show();
}
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_FreqSpectrumWindow::update_curve()
{
int i, j, k,
dftblocksize,
dftblocks,
samplesleft,
fft_outputbufsize;
long long s, s2;
char str[512];
double dig_value=0.0,
f_tmp=0.0;
union {
unsigned int one;
signed int one_signed;
unsigned short two[2];
signed short two_signed[2];
unsigned char four[4];
} var;
if(signalcomp == NULL)
{
return;
}
if(busy)
{
return;
}
viewbuf = mainwindow->viewbuf;
if(viewbuf == NULL)
{
return;
}
busy = 1;
curve1->setUpdatesEnabled(false);
samples = signalcomp->samples_on_screen;
if(signalcomp->samples_on_screen > signalcomp->sample_stop)
{
samples = signalcomp->sample_stop;
}
samples -= signalcomp->sample_start;
if((samples < 10) || (viewbuf == NULL))
{
curve1->setUpdatesEnabled(true);
busy = 0;
curve1->clear();
return;
}
if(buf1 != NULL)
{
free(buf1);
}
buf1 = (double *)malloc(sizeof(double) * signalcomp->samples_on_screen);
if(buf1 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.\n"
"Decrease the timescale and try again.");
messagewindow.exec();
return;
}
samples = 0;
for(s=signalcomp->sample_start; s<signalcomp->samples_on_screen; s++)
{
if(s>signalcomp->sample_stop) break;
dig_value = 0.0;
s2 = s + signalcomp->sample_timeoffset - signalcomp->sample_start;
for(j=0; j<signalcomp->num_of_signals; j++)
{
if(signalcomp->edfhdr->bdf)
{
var.two[0] = *((unsigned short *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset
+ ((s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record) * 3)));
var.four[2] = *((unsigned char *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset
+ ((s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record) * 3)
+ 2));
if(var.four[2]&0x80)
{
var.four[3] = 0xff;
}
else
{
var.four[3] = 0x00;
}
f_tmp = var.one_signed;
}
if(signalcomp->edfhdr->edf)
{
f_tmp = *(((short *)(
viewbuf
+ signalcomp->viewbufoffset
+ (signalcomp->edfhdr->recordsize * (s2 / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record))
+ signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].buf_offset))
+ (s2 % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].smp_per_record));
}
f_tmp += signalcomp->edfhdr->edfparam[signalcomp->edfsignal[j]].offset;
f_tmp *= signalcomp->factor[j];
dig_value += f_tmp;
}
if(signalcomp->spike_filter)
{
if(s==signalcomp->sample_start)
{
spike_filter_restore_buf(signalcomp->spike_filter);
}
dig_value = run_spike_filter(dig_value, signalcomp->spike_filter);
}
for(k=0; k<signalcomp->filter_cnt; k++)
{
dig_value = first_order_filter(dig_value, signalcomp->filter[k]);
}
for(k=0; k<signalcomp->ravg_filter_cnt; k++)
{
if(s==signalcomp->sample_start)
{
ravg_filter_restore_buf(signalcomp->ravg_filter[k]);
}
dig_value = run_ravg_filter(dig_value, signalcomp->ravg_filter[k]);
}
for(k=0; k<signalcomp->fidfilter_cnt; k++)
{
if(s==signalcomp->sample_start)
{
memcpy(signalcomp->fidbuf[k], signalcomp->fidbuf2[k], fid_run_bufsize(signalcomp->fid_run[k]));
}
dig_value = signalcomp->fidfuncp[k](signalcomp->fidbuf[k], dig_value);
}
if(signalcomp->ecg_filter != NULL)
{
if(s==signalcomp->sample_start)
{
ecg_filter_restore_buf(signalcomp->ecg_filter);
}
dig_value = run_ecg_filter(dig_value, signalcomp->ecg_filter);
}
if(s>=signalcomp->sample_start)
{
buf1[samples++] = dig_value * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue;
}
}
samplefreq = (double)signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record / ((double)signalcomp->edfhdr->long_data_record_duration / TIME_DIMENSION);
dftblocksize = mainwindow->maxdftblocksize;
if(dftblocksize & 1)
{
dftblocksize--;
}
dftblocks = 1;
if(dftblocksize < samples)
{
dftblocks = samples / dftblocksize;
}
else
{
dftblocksize = samples;
}
if(dftblocksize & 1)
{
dftblocksize--;
}
samplesleft = samples % dftblocksize;
if(samplesleft & 1)
{
samplesleft--;
}
freqstep = samplefreq / (double)dftblocksize;
fft_outputbufsize = dftblocksize / 2;
steps = fft_outputbufsize;
if(buf2 != NULL)
{
free(buf2);
}
buf2 = (double *)calloc(1, sizeof(double) * fft_outputbufsize);
if(buf2 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
buf1 = NULL;
return;
}
if(buf3 != NULL)
{
free(buf3);
}
buf3 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf3 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
buf1 = NULL;
buf2 = NULL;
return;
}
if(buf4 != NULL)
{
free(buf4);
}
buf4 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf4 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
return;
}
if(buf5 != NULL)
{
free(buf5);
}
buf5 = (double *)malloc(sizeof(double) * fft_outputbufsize);
if(buf5 == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
free(buf4);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
buf4 = NULL;
return;
}
maxvalue = 0.000001;
maxvalue_sqrt = 0.000001;
maxvalue_vlog = 0.000001;
maxvalue_sqrt_vlog = 0.000001;
minvalue_vlog = 0.0;
minvalue_sqrt_vlog = 0.0;
#ifdef CHECK_POWERSPECTRUM
printf("samples is %i dftblocksize is %i dftblocks is %i samplesleft is %i fft_outputbufsize is %i steps is %i\n", samples, dftblocksize, dftblocks, samplesleft, fft_outputbufsize, steps);
double power1=0.0, power2=0.0;
for(i=0; i<samples; i++)
{
power1 += (buf1[i] * buf1[i]);
}
#endif
kiss_fftr_cfg cfg;
kiss_fft_cpx *kiss_fftbuf;
kiss_fftbuf = (kiss_fft_cpx *)malloc((fft_outputbufsize + 1) * sizeof(kiss_fft_cpx));
if(kiss_fftbuf == NULL)
{
QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action.");
messagewindow.exec();
free(buf1);
free(buf2);
free(buf3);
free(buf4);
free(buf5);
buf1 = NULL;
buf2 = NULL;
buf3 = NULL;
buf4 = NULL;
buf5 = NULL;
return;
}
cfg = kiss_fftr_alloc(dftblocksize, 0, NULL, NULL);
for(j=0; j<dftblocks; j++)
{
kiss_fftr(cfg, buf1 + (j * dftblocksize), kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] += (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize);
}
}
if(samplesleft)
{
kiss_fftr(cfg, buf1 + (((j-1) * dftblocksize) + samplesleft), kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] += (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize);
buf2[i] /= (dftblocks + 1);
}
}
else
{
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] /= dftblocks;
}
}
if(signalcomp->ecg_filter == NULL)
{
buf2[0] /= 2.0; // DC!
}
else
{
buf2[0] = 0.0; // Remove DC because heart rate is always a positive value
}
free(cfg);
free(kiss_fftbuf);
for(i=0; i<fft_outputbufsize; i++)
{
buf2[i] /= samplefreq;
#ifdef CHECK_POWERSPECTRUM
power2 += buf2[i];
#endif
buf3[i] = sqrt(buf2[i] * freqstep);
if(buf2[i] <= SPECT_LOG_MINIMUM)
{
buf4[i] = log10(SPECT_LOG_MINIMUM);
}
else
{
buf4[i] = log10(buf2[i]);
}
if(buf3[i] <= SPECT_LOG_MINIMUM)
{
buf5[i] = log10(SPECT_LOG_MINIMUM);
}
else
{
buf5[i] = log10(buf3[i]);
}
if(i) // don't use the dc-bin for the autogain of the screen
{
if(buf2[i] > maxvalue)
{
maxvalue = buf2[i];
}
if(buf3[i] > maxvalue_sqrt)
{
maxvalue_sqrt = buf3[i];
}
if(buf4[i] > maxvalue_vlog)
{
maxvalue_vlog = buf4[i];
}
if(buf5[i] > maxvalue_sqrt_vlog)
{
maxvalue_sqrt_vlog = buf5[i];
}
if((buf4[i] < minvalue_vlog) && (buf4[i] >= SPECT_LOG_MINIMUM_LOG))
{
minvalue_vlog = buf4[i];
}
if((buf5[i] < minvalue_sqrt_vlog) && (buf5[i] >= SPECT_LOG_MINIMUM_LOG))
{
minvalue_sqrt_vlog = buf5[i];
}
}
}
if(minvalue_vlog < SPECT_LOG_MINIMUM_LOG)
minvalue_vlog = SPECT_LOG_MINIMUM_LOG;
if(minvalue_sqrt_vlog < SPECT_LOG_MINIMUM_LOG)
minvalue_sqrt_vlog = SPECT_LOG_MINIMUM_LOG;
if(samplesleft)
{
dftblocks++;
}
#ifdef CHECK_POWERSPECTRUM
power1 /= samples;
power2 *= freqstep;
printf("\n power1 is %f\n power2 is %f\n\n", power1, power2);
#endif
if(buf1 != NULL)
{
free(buf1);
buf1 = NULL;
}
sprintf(str, "FFT resolution: %f Hz %i blocks of %i samples", freqstep, dftblocks, dftblocksize);
remove_trailing_zeros(str);
curve1->setUpperLabel1(str);
curve1->setUpperLabel2(signallabel);
sliderMoved(0);
curve1->setUpdatesEnabled(true);
busy = 0;
}
void UI_FilterDialog::orderboxvaluechanged(int order)
{
int type,
model;
char str[256];
type = typebox->currentIndex();
model = modelbox->currentIndex();
if(type == 2)
{
sprintf(str,"%f Hz", freqbox->value() / orderbox->value());
remove_trailing_zeros(str);
ordervaluelabel->setText(str);
last_qfactor = order;
}
else
{
if((type == 3) || (type == 4))
{
last_order = order / 2;
}
else
{
if(model == 3)
{
last_samples = order;
}
else
{
last_order = order;
}
}
if(model == 0)
{
orderlabel->setText("Slope roll-off:");
ordervaluelabel->setText(QString::number(6 * last_order, 'f', 0).append(" dB / octave"));
}
if(model == 1)
{
orderlabel->setText("passband ripple");
ordervaluelabel->setText("1 dB");
}
if(model == 2)
{
orderlabel->setText("");
ordervaluelabel->setText("");
}
if(model == 3)
{
orderlabel->setText("");
ordervaluelabel->setText("");
}
}
updatecurve();
}