void UI_Annotationswindow::average_annot(bool) { if(mainwindow->files_open != 1) { return; } if(!mainwindow->signalcomps) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "First add a signal to the screen."); messagewindow.exec(); return; } if(mainwindow->annot_editor_active) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Close the annotation editor and try again."); messagewindow.exec(); return; } if(list->count() < 1) { return; } UI_AveragerWindow average_wndw(mainwindow, list->currentRow()); }
void Signaltypes::registerSignaltypes(bool ask) // ask=true { struct signalcompblock *signalcomp; struct edfparamblock *edfparam; unsigned signalcomps = parent->mainwindow->signalcomps; for(unsigned i=0; i<signalcomps; i++) { signalcomp = parent->mainwindow->signalcomp[i]; // current signalcomp if(signalcomp->type < 1) // -1 : type default value. 0 : Unspecified { edfparam = signalcomp->edfhdr->edfparam; // edfparam of signal composition. signalcomp->type = get_type_from_label(edfparam[signalcomp->edfsignal[0]].label); for(int j=1; j<signalcomp->num_of_signals; j++) // inconsistencies in type, e.g. units, are only problematic with signal combinations (num_of_signals>1). { if( signalcomp->type != get_type_from_label(edfparam[signalcomp->edfsignal[j]].label) ) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "In Signaltypes::registerSignaltypes() : Your signal composition consists of incompatible types. Setting to Unspecified."); messagewindow.exec(); signalcomp->type = 0; } } //if(signalcomp->type == 0) ask = true; } } if(ask) { ask_for_types(); // if not all types were determined, fire up the user interface. } }
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_SignalChooser::call_sidemenu(QListWidgetItem *) { int i; if(task == 3) return; signalchooser_dialog->hide(); if(task == 0) { mainwindow->maincurve->exec_sidemenu(list->currentRow()); } if(task == 1) { for(i=0; i<MAXSPECTRUMDOCKS; i++) { if(mainwindow->spectrumdock[i]->dock->isHidden()) break; } if(i<MAXSPECTRUMDOCKS) { mainwindow->spectrumdock[i]->init(list->currentRow()); } else { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The maximum number of docked Power Spectrum windows has been reached.\n" "Close one first."); messagewindow.exec(); } } if(task == 2) { AdjustFilterSettings filtersettings(mainwindow->signalcomp[list->currentRow()], mainwindow->maincurve); } if(task == 4) { if(signal_nr != NULL) { *signal_nr = list->currentRow(); } } signalchooser_dialog->close(); }
void UI_Mainwindow::video_process_error(QProcess::ProcessError err) { char str[1024]; if(video_player->status == VIDEO_STATUS_STOPPED) return; stop_video_generic(); strcpy(str, "The process that runs the mediaplayer reported an error:\n"); if(err == QProcess::FailedToStart) { strcat(str, "\nFailed to start."); } if(err == QProcess::Crashed) { strcat(str, "\nCrashed."); } if(err == QProcess::Timedout) { strcat(str, "\nTimed out."); } if(err == QProcess::WriteError) { strcat(str, "\nWrite error."); } if(err == QProcess::ReadError) { strcat(str, "\nRead error."); } if(err == QProcess::UnknownError) { strcat(str, "\nUnknown error."); } QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); }
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_ExportAnnotationswindow::ExportButtonClicked() { int i, j, n, len, csv_format=0, hdl, annot_cnt, temp, include_duration; char path[MAX_PATH_LENGTH], str[1024], separator; FILE *annotationfile=NULL; struct annotationblock *annot, *annot_list; struct edfhdrblock *hdr; struct date_time_struct tm; if(CSVRadioButton->isChecked() == true) { if(asciiSecondsRadioButton->isChecked() == true) { csv_format = 1; } if(asciiISOtimeRadioButton->isChecked() == true) { csv_format = 2; } if(asciiISOtimedateRadioButton->isChecked() == true) { csv_format = 3; } if(asciiISOtimeFractionRadioButton->isChecked() == true) { csv_format = 4; } if(asciiISOtimedateFractionRadioButton->isChecked() == true) { csv_format = 5; } } if(EDFplusRadioButton->isChecked() == true) { csv_format = 0; } if(XMLRadioButton->isChecked() == true) { csv_format = 8; } mainwindow->export_annotations_var->format = csv_format; if(separatorBox->currentIndex() == 0) { separator = ','; mainwindow->export_annotations_var->separator = 0; } else { separator = '\t'; mainwindow->export_annotations_var->separator = 1; } if(durationCheckBox->checkState() == Qt::Checked) { include_duration = 1; mainwindow->export_annotations_var->duration = 1; } else { include_duration = 0; mainwindow->export_annotations_var->duration = 0; } if(!mainwindow->files_open) { ExportAnnotsDialog->close(); return; } if(filelist->count() < 1) { ExportAnnotsDialog->close(); return; } ExportButton->setEnabled(false); CloseButton->setEnabled(false); for(i=0; i<mainwindow->files_open; i++) { if(!strcmp(mainwindow->edfheaderlist[i]->filename, filelist->item(filelist->currentRow())->text().toLocal8Bit().data())) { break; } } if(i==mainwindow->files_open) { ExportAnnotsDialog->close(); return; } n = i; if(mergeRadioButton->isChecked() == true) { n = mainwindow->sel_viewtime; } hdr = mainwindow->edfheaderlist[n]; path[0] = 0; if(mainwindow->recent_savedir[0]!=0) { strcpy(path, mainwindow->recent_savedir); strcat(path, "/"); } len = strlen(path); get_filename_from_path(path + len, mainwindow->edfheaderlist[n]->filename, MAX_PATH_LENGTH - len); remove_extension_from_filename(path); if((csv_format > 0) && (csv_format < 6)) { strcat(path, "_annotations.txt"); strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "Text files (*.txt *.TXT *.csv *.CSV)").toLocal8Bit().data()); } if(csv_format == 8) { strcat(path, "_annotations.xml"); strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "XML files (*.xml *.XML)").toLocal8Bit().data()); } if(csv_format == 0) { strcat(path, "_annotations.edf"); strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data()); } if(!strcmp(path, "")) { ExportAnnotsDialog->close(); return; } get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH); if(mainwindow->file_is_opened(path)) { QMessageBox messagewindow(QMessageBox::Critical, "Export annotations", "Error, selected file is in use."); messagewindow.exec(); return; } annot_list = edfplus_annotation_copy_list(&mainwindow->annotationlist[n]); if(mergeRadioButton->isChecked() == true) { for(i=0; i < mainwindow->files_open; i++) { if(i != mainwindow->sel_viewtime) { annot_cnt = edfplus_annotation_count(&mainwindow->annotationlist[i]); for(j=0; j < annot_cnt; j++) { edfplus_annotation_add_copy(&annot_list, edfplus_annotation_item(&mainwindow->annotationlist[i], j)); annot = edfplus_annotation_item(&annot_list, edfplus_annotation_count(&annot_list) - 1); annot->onset -= (mainwindow->edfheaderlist[i]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime); } } } edfplus_annotation_sort(&annot_list); } annot_cnt = edfplus_annotation_count(&annot_list); ///////////////////////////// CSV (text) export ////////////////////////////////////// if((csv_format > 0) && (csv_format < 6)) { annotationfile = fopeno(path, "wb"); if(annotationfile==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open annotationfile for writing."); messagewindow.exec(); ExportAnnotsDialog->close(); edfplus_annotation_delete_list(&annot_list); return; } if(include_duration) { fprintf(annotationfile, "Onset%cDuration%cAnnotation\n", separator, separator); } else { fprintf(annotationfile, "Onset%cAnnotation\n", separator); } for(j=0; j < annot_cnt; j++) { annot = edfplus_annotation_item(&annot_list, j); if(annot == NULL) { break; } strncpy(str, annot->annotation, 1024); str[1023] = 0; utf8_to_latin1(str); len = strlen(str); for(i=0; i<len; i++) { if((((unsigned char *)str)[i] < 32) || (((unsigned char *)str)[i] == ',')) { str[i] = '.'; } } if(csv_format == 1) { if(include_duration) { fprintf(annotationfile, "%+.7f%c%s%c%s\n", (double)(annot->onset - hdr->starttime_offset) / TIME_DIMENSION, separator, annot->duration, separator, str); } else { fprintf(annotationfile, "%+.7f%c%s\n", (double)(annot->onset - hdr->starttime_offset) / TIME_DIMENSION, separator, str); } } if(csv_format == 2) { temp = annot->onset % TIME_DIMENSION; if(temp < 0) { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm); } else { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm); } if(include_duration) { fprintf(annotationfile, "%02i:%02i:%02i%c%s%c%s\n", tm.hour, tm.minute, tm.second, separator, annot->duration, separator, str); } else { fprintf(annotationfile, "%02i:%02i:%02i%c%s\n", tm.hour, tm.minute, tm.second, separator, str); } } if(csv_format == 3) { temp = annot->onset % TIME_DIMENSION; if(temp < 0) { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm); } else { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm); } if(include_duration) { fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i%c%s%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, separator, annot->duration, separator, str); } else { fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, separator, str); } } if(csv_format == 4) { temp = annot->onset % TIME_DIMENSION; if(temp < 0) { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm); temp = TIME_DIMENSION + temp; } else { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm); } if(include_duration) { fprintf(annotationfile, "%02i:%02i:%02i.%07i%c%s%c%s\n", tm.hour, tm.minute, tm.second, temp, separator, annot->duration, separator, str); } else { fprintf(annotationfile, "%02i:%02i:%02i.%07i%c%s\n", tm.hour, tm.minute, tm.second, temp, separator, str); } } if(csv_format == 5) { temp = annot->onset % TIME_DIMENSION; if(temp < 0) { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm); temp = TIME_DIMENSION + temp; } else { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm); } if(include_duration) { fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i.%07i%c%s%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, temp, separator, annot->duration, separator, str); } else { fprintf(annotationfile, "%04i-%02i-%02iT%02i:%02i:%02i.%07i%c%s\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, temp, separator, str); } } } fclose(annotationfile); edfplus_annotation_delete_list(&annot_list); QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done."); messagewindow.setIconPixmap(QPixmap(":/images/ok.png")); messagewindow.exec(); ExportAnnotsDialog->close(); return; } ///////////////////////////// XML export ////////////////////////////////////// if(csv_format == 8) { annotationfile = fopeno(path, "wb"); if(annotationfile==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open annotationfile for writing."); messagewindow.exec(); ExportAnnotsDialog->close(); edfplus_annotation_delete_list(&annot_list); return; } fprintf(annotationfile, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); fprintf(annotationfile, "<!-- Generated by " PROGRAM_NAME " " PROGRAM_VERSION " -->\n"); fprintf(annotationfile, "<annotationlist>\n"); utc_to_date_time(hdr->utc_starttime, &tm); fprintf(annotationfile, " <recording_start_time>%04i-%02i-%02iT%02i:%02i:%02i.%07i</recording_start_time>\n", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, (int)hdr->starttime_offset); for(j=0; j < annot_cnt; j++) { annot = edfplus_annotation_item(&annot_list, j); if(annot == NULL) { break; } temp = annot->onset % TIME_DIMENSION; if(temp < 0) { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION) - 1, &tm); temp = TIME_DIMENSION + temp; } else { utc_to_date_time(hdr->utc_starttime + (annot->onset / TIME_DIMENSION), &tm); } fprintf(annotationfile, " <annotation>\n" " <onset>%04i-%02i-%02iT%02i:%02i:%02i.%07i</onset>\n" " <duration>%s</duration>\n" " <description>", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second, temp, annot->duration); xml_fwrite_encode_entity(annotationfile, annot->annotation); fprintf(annotationfile, "</description>\n" " </annotation>\n"); } fprintf(annotationfile, "</annotationlist>\n"); fclose(annotationfile); edfplus_annotation_delete_list(&annot_list); QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done."); messagewindow.setIconPixmap(QPixmap(":/images/ok.png")); messagewindow.exec(); ExportAnnotsDialog->close(); return; } ///////////////////////////// EDFplus export ////////////////////////////////////// if(csv_format == 0) { hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, 0); if(hdl < 0) { switch(hdl) { case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error"); break; case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory"); break; case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum files reached"); break; case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file already opened"); break; case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: number of signals is invalid"); break; default : strcpy(str, "EDFlib: unknown error"); break; } QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); edfplus_annotation_delete_list(&annot_list); ExportAnnotsDialog->close(); return; } utc_to_date_time(hdr->utc_starttime, &tm); edf_set_startdatetime(hdl, tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second); if((hdr->edfplus) || (hdr->bdfplus)) { edf_set_patientname(hdl, hdr->plus_patient_name); edf_set_patientcode(hdl, hdr->plus_patientcode); if(!(strcmp(hdr->plus_gender, "Male"))) { edf_set_gender(hdl, 1); } if(!(strcmp(hdr->plus_gender, "Female"))) { edf_set_gender(hdl, 0); } if(hdr->plus_birthdate[0] != 0) { if(!(strncmp(hdr->plus_birthdate + 3, "jan", 3))) n = 1; if(!(strncmp(hdr->plus_birthdate + 3, "feb", 3))) n = 2; if(!(strncmp(hdr->plus_birthdate + 3, "mar", 3))) n = 3; if(!(strncmp(hdr->plus_birthdate + 3, "apr", 3))) n = 4; if(!(strncmp(hdr->plus_birthdate + 3, "may", 3))) n = 5; if(!(strncmp(hdr->plus_birthdate + 3, "jun", 3))) n = 6; if(!(strncmp(hdr->plus_birthdate + 3, "jul", 3))) n = 7; if(!(strncmp(hdr->plus_birthdate + 3, "aug", 3))) n = 8; if(!(strncmp(hdr->plus_birthdate + 3, "sep", 3))) n = 9; if(!(strncmp(hdr->plus_birthdate + 3, "oct", 3))) n = 10; if(!(strncmp(hdr->plus_birthdate + 3, "nov", 3))) n = 11; if(!(strncmp(hdr->plus_birthdate + 3, "dec", 3))) n = 12; edf_set_birthdate(hdl, atoi(hdr->plus_birthdate + 7), n, atoi(hdr->plus_birthdate)); } edf_set_patient_additional(hdl, hdr->plus_patient_additional); edf_set_admincode(hdl, hdr->plus_admincode); edf_set_technician(hdl, hdr->plus_technician); edf_set_equipment(hdl, hdr->plus_equipment); edf_set_recording_additional(hdl, hdr->plus_recording_additional); } else { edf_set_patientname(hdl, hdr->patient); edf_set_recording_additional(hdl, hdr->recording); } int hasdot, decimals; for(j=0; j < annot_cnt; j++) { annot = edfplus_annotation_item(&annot_list, j); if(annot == NULL) { break; } if(annot->duration[0] == 0) { edfwrite_annotation_utf8(hdl, annot->onset / 1000LL, -1LL, annot->annotation); } else { strcpy(str, annot->duration); len = strlen(str); hasdot = 0; for(i=0; i<len; i++) { if(str[i] == '.') { hasdot = 1; for(decimals=0; decimals<4; decimals++) { str[i] = str[i+1]; if(str[i] == 0) { for( ; decimals<4; decimals++) { str[i] = '0'; i++; } i--; } i++; } str[i] = 0; break; } } if(!hasdot) { strcat(str, "0000"); } edfwrite_annotation_utf8(hdl, annot->onset / 1000LL, atoi(str), annot->annotation); } } if(edfclose_file(hdl) != 0) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred: edfclose_file()"); messagewindow.exec(); } edfplus_annotation_delete_list(&annot_list); QMessageBox messagewindow(QMessageBox::Information, "Ready", "Done."); messagewindow.setIconPixmap(QPixmap(":/images/ok.png")); messagewindow.exec(); ExportAnnotsDialog->close(); } }
void UI_FINO2EDFwindow::SelectFileButton() { FILE *inputfile=NULL, *outputfile=NULL; int i, j, k, p, temp, separator=';', edfsignals=0, ok, timestep, new_smpl_time=0, datarecords, str_start, column, line_nr; char txt_string[2048], path[512], outputfilename[MAX_PATH_LENGTH], line[2048], scratchpad[128], labels[MAX_SIGNALS][17], phys_dim[MAX_SIGNALS][9], phys_min[MAX_SIGNALS][9], phys_max[MAX_SIGNALS][9], patientname[81], recording[81], datetime[17]; double sensitivity[MAX_SIGNALS], new_value[MAX_SIGNALS], old_value[MAX_SIGNALS]; union{ short two; char one[2]; } var; for(j=0; j<MAX_SIGNALS; j++) { old_value[j] = 0.0; } enable_widgets(false); if(!(strlen(PatientnameLineEdit->text().toLatin1().data()))) { QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subjectname."); messagewindow.exec(); enable_widgets(true); return; } if(!(strlen(RecordingLineEdit->text().toLatin1().data()))) { QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recordingdescription."); messagewindow.exec(); enable_widgets(true); return; } strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "Text files (*.txt *.TXT)").toLocal8Bit().data()); if(!strcmp(path, "")) { enable_widgets(true); return; } get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH); inputfile = fopeno(path, "rb"); if(inputfile==NULL) { snprintf(txt_string, 2048, "Can not open file %s for reading.", path); QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string); messagewindow.exec(); enable_widgets(true); return; } /***************** check if the txtfile is valid ******************************/ rewind(inputfile); if(fread(scratchpad, 5, 1, inputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading the inputfile."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } if(strncmp(scratchpad, "\"T\";", 4)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown data in file (1)."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } while(1) { temp = fgetc(inputfile); if(temp==EOF) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (2)."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } if(temp=='\n') break; } if(fread(scratchpad, 2, 1, inputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading inputfile (3)."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } if(strncmp(scratchpad, "\"s\";", 4)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown data in file (4)."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } /***************** collect items *****************************************/ rewind(inputfile); while(1) { temp = fgetc(inputfile); if(temp==EOF) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (5)."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } if(temp==separator) { break; } } i = 0; while(temp!='\n') { temp = fgetc(inputfile); if(temp==EOF) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (6)."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } if(temp=='\r') { continue; } if((temp==separator)||(temp=='\n')) { if(edfsignals>=MAX_SIGNALS) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Too many labels/signals (7)."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } line[i] = 0; ok = 0; if(!strcmp(line, "\" reSYS\"")) { strcpy(labels[edfsignals], "reSYS "); strcpy(phys_dim[edfsignals], "mmHg "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" fiSYS\"")) { strcpy(labels[edfsignals], "fiSYS "); strcpy(phys_dim[edfsignals], "mmHg "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" reDIA\"")) { strcpy(labels[edfsignals], "reDIA "); strcpy(phys_dim[edfsignals], "mmHg "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" fiDIA\"")) { strcpy(labels[edfsignals], "fiDIA "); strcpy(phys_dim[edfsignals], "mmHg "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" reMAP\"")) { strcpy(labels[edfsignals], "reMAP "); strcpy(phys_dim[edfsignals], "mmHg "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" fiMAP\"")) { strcpy(labels[edfsignals], "fiMAP "); strcpy(phys_dim[edfsignals], "mmHg "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" HR\"")) { strcpy(labels[edfsignals], "HR "); strcpy(phys_dim[edfsignals], "bpm "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" IBI\"")) { strcpy(labels[edfsignals], "IBI "); strcpy(phys_dim[edfsignals], "s "); strcpy(phys_min[edfsignals], "-31.744 "); strcpy(phys_max[edfsignals], "31.744 "); sensitivity[edfsignals] = 1000.0; ok = 1; } if(!strcmp(line, "\" SV\"")) { strcpy(labels[edfsignals], "SV "); strcpy(phys_dim[edfsignals], "ml "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" CO\"")) { strcpy(labels[edfsignals], "CO "); strcpy(phys_dim[edfsignals], "lpm "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" EJT\"")) { strcpy(labels[edfsignals], "EJT "); strcpy(phys_dim[edfsignals], "s "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" TPR\"")) { strcpy(labels[edfsignals], "TPR "); strcpy(phys_dim[edfsignals], "MU "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" Artifact\"")) { strcpy(labels[edfsignals], "Artifact "); strcpy(phys_dim[edfsignals], "_TPSROD2"); strcpy(phys_min[edfsignals], "0 "); strcpy(phys_max[edfsignals], "10000000"); sensitivity[edfsignals] = 0.0063488; ok = 1; } if(!strcmp(line, "\" Zao\"")) { strcpy(labels[edfsignals], "Zao "); strcpy(phys_dim[edfsignals], "mMU "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" Cwk\"")) { strcpy(labels[edfsignals], "Cwk "); strcpy(phys_dim[edfsignals], "MU "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!strcmp(line, "\" Height\"")) { strcpy(labels[edfsignals], "Height "); strcpy(phys_dim[edfsignals], "mmHg "); strcpy(phys_min[edfsignals], "-1024 "); strcpy(phys_max[edfsignals], "1024 "); sensitivity[edfsignals] = 31.0; ok = 1; } if(!ok) { snprintf(txt_string, 2048, "Found unknown label/signal: %s", line); QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } edfsignals++; i = 0; } if(temp==separator) { continue; } line[i++] = temp; } if(!edfsignals) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There are no labels/signals."); messagewindow.exec(); fclose(inputfile); enable_widgets(true); return; } p = sprintf(patientname, "%s", PatientnameLineEdit->text().toLatin1().data()); latin1_to_ascii(patientname, p); for( ; p<80; p++) { patientname[p] = ' '; } patientname[80] = 0; p = sprintf(recording, "%s", RecordingLineEdit->text().toLatin1().data()); latin1_to_ascii(recording, p); for( ; p<80; p++) { recording[p] = ' '; } recording[80] = 0; sprintf(datetime, "%02i.%02i.%02i%02i.%02i.%02i", StartDatetimeedit->date().day(), StartDatetimeedit->date().month(), StartDatetimeedit->date().year() % 100, StartDatetimeedit->time().hour(), StartDatetimeedit->time().minute(), StartDatetimeedit->time().second()); datetime[16] = 0; /***************** write header *****************************************/ get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH); remove_extension_from_filename(outputfilename); strcat(outputfilename, "_finometer.edf"); path[0] = 0; if(recent_savedir[0]!=0) { strcpy(path, recent_savedir); strcat(path, "/"); } strcat(path, outputfilename); strcpy(path, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data()); if(!strcmp(path, "")) { enable_widgets(true); fclose(inputfile); return; } get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH); outputfile = fopeno(path, "wb"); if(outputfile==NULL) { snprintf(txt_string, 2048, "Can not open file %s for writing.", path); QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string); messagewindow.exec(); enable_widgets(true); fclose(inputfile); return; } fprintf(outputfile, "0 "); fprintf(outputfile, "%s", patientname); fprintf(outputfile, "%s", recording); fprintf(outputfile, "%s", datetime); fprintf(outputfile, "%-8i", 256 * edfsignals + 256); fprintf(outputfile, " "); fprintf(outputfile, "-1 "); fprintf(outputfile, "0.01 "); fprintf(outputfile, "%-4i", edfsignals); for(i=0; i<edfsignals; i++) { fprintf(outputfile, "%s", labels[i]); } for(i=0; i<(80*edfsignals); i++) { fputc(' ', outputfile); } for(i=0; i<edfsignals; i++) { fprintf(outputfile, "%s", phys_dim[i]); } for(i=0; i<edfsignals; i++) { fprintf(outputfile, "%s", phys_min[i]); } for(i=0; i<edfsignals; i++) { fprintf(outputfile, "%s", phys_max[i]); } for(i=0; i<edfsignals; i++) { fprintf(outputfile, "-31744 "); } for(i=0; i<edfsignals; i++) { fprintf(outputfile, "31744 "); } for(i=0; i<(80*edfsignals); i++) { fputc(' ', outputfile); } for(i=0; i<edfsignals; i++) { fprintf(outputfile, "1 "); } for(i=0; i<(32*edfsignals); i++) { fputc(' ', outputfile); } /***************** start conversion **************************************/ rewind(inputfile); for(i=0; ; ) { temp = fgetc(inputfile); if(temp==EOF) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Reached end of file unexpectedly (8)."); messagewindow.exec(); fclose(inputfile); fclose(outputfile); enable_widgets(true); return; } if(temp=='\n') i++; if(i>1) break; } QApplication::setOverrideCursor(Qt::WaitCursor); for(k=0; k<10; k++) qApp->processEvents(); i = 0; column = 0; datarecords = 0; str_start = 0; line_nr = 2; while(1) { temp = fgetc(inputfile); if(temp==EOF) { for(k=0; k<edfsignals; k++) { temp = (int)(new_value[k] * sensitivity[k]); if(temp>31744) temp = 31744; if(temp<-31744) temp = -31744; var.two = (short)temp; fputc(var.one[0], outputfile); fputc(var.one[1], outputfile); } datarecords++; break; } line[i] = temp; /**************************************/ if(line[i]==',') { line[i] = '.'; } if((line[i]==separator)||(line[i]=='\n')) { if(column) { new_value[column-1] = atof(line + str_start); } else { new_smpl_time = (int)(atof(line + str_start) * 100.0); } if(line[i]=='\n') { /**************************************/ line_nr++; if(column!=edfsignals) { QApplication::restoreOverrideCursor(); snprintf(txt_string, 2048, "Number of separators in line %i is wrong.", line_nr); QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string); messagewindow.exec(); fclose(inputfile); fclose(outputfile); enable_widgets(true); return; } timestep = new_smpl_time - datarecords; if(timestep<=0) { QApplication::restoreOverrideCursor(); snprintf(txt_string, 2048, "Timestep <= 0 in line %i.", line_nr); QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string); messagewindow.exec(); fclose(inputfile); fclose(outputfile); enable_widgets(true); return; } for(j=0; j<timestep; j++) { for(k=0; k<edfsignals; k++) { temp = (int)((old_value[k] + ((new_value[k] - old_value[k]) * ((double)j / (double)timestep))) * sensitivity[k]); if(temp>31744) temp = 31744; if(temp<-31744) temp = -31744; var.two = (short)temp; fputc(var.one[0], outputfile); fputc(var.one[1], outputfile); } datarecords++; } for(j=0; j<edfsignals; j++) { old_value[j] = new_value[j]; } /**************************************/ str_start = 0; i = 0; column = 0; continue; } str_start = i + 1; column++; } /**************************************/ i++; if(i>2046) { QApplication::restoreOverrideCursor(); snprintf(txt_string, 2048, "Line %i is too long.", line_nr); QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string); messagewindow.exec(); fclose(inputfile); fclose(outputfile); enable_widgets(true); return; } } QApplication::restoreOverrideCursor(); fseeko(outputfile, 236LL, SEEK_SET); fprintf(outputfile, "%-8i", datarecords); if(fclose(outputfile)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while closing outputfile."); messagewindow.exec(); enable_widgets(true); fclose(inputfile); return; } if(fclose(inputfile)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while closing inputfile."); messagewindow.exec(); } snprintf(txt_string, 2048, "Done, EDF file is located at %s", path); QMessageBox messagewindow(QMessageBox::Information, "Ready", txt_string); messagewindow.setIconPixmap(QPixmap(":/images/ok.png")); messagewindow.exec(); enable_widgets(true); }
void UI_headerEditorWindow::read_header() { int i, j, p, r; char scratchpad[256], str[256]; if(file == NULL) { return; } fileNameLabel->setText(QString::fromLocal8Bit(path)); rewind(file); if(fread(hdr, (256 * edfsignals) + 256, 1, file) != 1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not read from file."); messagewindow.exec(); fclose(file); file = NULL; return; } startTimeDate->setVisible(true); startTimeDateLabel->setVisible(true); if(edfplus || bdfplus) { startTimeDate->setMinimumDate(QDate(1970, 1, 1)); startTimeDate->setMaximumDate(QDate(2299, 12, 31)); startTimeDate->setDate(QDate(1970, 1, 1)); } else { startTimeDate->setMinimumDate(QDate(1985, 1, 1)); startTimeDate->setMaximumDate(QDate(2084, 12, 31)); startTimeDate->setDate(QDate(1985, 1, 1)); } startTimeDate->setTime(QTime(0, 0, 0)); memcpy(scratchpad, hdr + 168, 8); scratchpad[2] = 0; scratchpad[5] = 0; scratchpad[8] = 0; r = atoi(scratchpad + 6); if(r < 85) { r += 2000; } else { r += 1900; } startTimeDate->setDate(QDate(r, atoi(scratchpad + 3), atoi(scratchpad))); startTimeDate->setMinimumDate(QDate(1985, 1, 1)); startTimeDate->setMaximumDate(QDate(2084, 12, 31)); memcpy(scratchpad, hdr + 176, 8); scratchpad[2] = 0; scratchpad[5] = 0; scratchpad[8] = 0; startTimeDate->setTime(QTime(atoi(scratchpad), atoi(scratchpad + 3), atoi(scratchpad + 6))); if(edfplus || bdfplus) { label1->setVisible(false); label2->setVisible(false); lineEdit1->setVisible(false); lineEdit2->setVisible(false); label3->setVisible(true); label4->setVisible(true); label5->setVisible(true); label6->setVisible(true); label7->setVisible(true); label8->setVisible(true); label9->setVisible(true); label11->setVisible(true); label12->setVisible(true); charsleft1Label->setVisible(true); charsleft2Label->setVisible(true); lineEdit3->setVisible(true); lineEdit4->setVisible(true); lineEdit5->setVisible(true); lineEdit6->setVisible(true); lineEdit7->setVisible(true); lineEdit8->setVisible(true); lineEdit9->setVisible(true); comboBox1->setVisible(true); checkBox1->setVisible(true); dateEdit1->setVisible(true); strncpy(scratchpad, hdr + 8, 80); scratchpad[80] = 0; strcat(scratchpad, " "); p = 0; for(i=0; i<80; i++) { if(scratchpad[i] == ' ') break; } if(strncmp(scratchpad, "X ", 2)) { scratchpad[i] = 0; for(j=p; j<i; j++) { if(scratchpad[j] == '_') scratchpad[j] = ' '; } strcpy(str, scratchpad); remove_trailing_spaces(str); lineEdit3->setText(str); } else { lineEdit3->clear(); } p = ++i; for(; i<80; i++) { if(scratchpad[i] == ' ') break; } comboBox1->setCurrentIndex(0); if(!(strncmp(scratchpad + p, "M ", 2))) { comboBox1->setCurrentIndex(1); } if(!(strncmp(scratchpad + p, "F ", 2))) { comboBox1->setCurrentIndex(2); } p = ++i; for(; i<80; i++) { if(scratchpad[i] == ' ') break; } dateEdit1->setDate(QDate(1800, 1, 1)); if(strncmp(scratchpad + p, "X ", 2)) { scratchpad[i] = 0; r = 0; if(!strncmp(scratchpad + p + 3, "JAN", 3)) r = 1; else if(!strncmp(scratchpad + p + 3, "FEB", 3)) r = 2; else if(!strncmp(scratchpad + p + 3, "MAR", 3)) r = 3; else if(!strncmp(scratchpad + p + 3, "APR", 3)) r = 4; else if(!strncmp(scratchpad + p + 3, "MAY", 3)) r = 5; else if(!strncmp(scratchpad + p + 3, "JUN", 3)) r = 6; else if(!strncmp(scratchpad + p + 3, "JUL", 3)) r = 7; else if(!strncmp(scratchpad + p + 3, "AUG", 3)) r = 8; else if(!strncmp(scratchpad + p + 3, "SEP", 3)) r = 9; else if(!strncmp(scratchpad + p + 3, "OCT", 3)) r = 10; else if(!strncmp(scratchpad + p + 3, "NOV", 3)) r = 11; else if(!strncmp(scratchpad + p + 3, "DEC", 3)) r = 12; if(r) { dateEdit1->setDate(QDate(atoi(scratchpad + p + 7), r, atoi(scratchpad + p))); checkBox1->setCheckState(Qt::Unchecked); } p += 10; } else { checkBox1->setCheckState(Qt::Checked); } p = ++i; for(; i<80; i++) { if(scratchpad[i] == ' ') break; } if(strncmp(scratchpad + p, "X ", 2)) { scratchpad[i] = 0; for(j=p; j<i; j++) { if(scratchpad[j] == '_') scratchpad[j] = ' '; } strcpy(str, scratchpad + p); remove_trailing_spaces(str); lineEdit4->setText(str); } else { lineEdit4->clear(); } p = ++i; scratchpad[80] = 0; strcpy(str, scratchpad + p); remove_trailing_spaces(str); lineEdit5->setText(str); strncpy(scratchpad, hdr + 88, 80); scratchpad[80] = 0; strcat(scratchpad, " "); p = 10; for(i=10; i<80; i++) { if(scratchpad[i] == ' ') break; } if(strncmp(scratchpad + p, "X ", 2)) { scratchpad[i] = 0; has_startdate = 1; scratchpad[12] = 0; scratchpad[16] = 0; scratchpad[21] = 0; r = 0; if(!strncmp(scratchpad + 13, "JAN", 3)) r = 1; else if(!strncmp(scratchpad + 13, "FEB", 3)) r = 2; else if(!strncmp(scratchpad + 13, "MAR", 3)) r = 3; else if(!strncmp(scratchpad + 13, "APR", 3)) r = 4; else if(!strncmp(scratchpad + 13, "MAY", 3)) r = 5; else if(!strncmp(scratchpad + 13, "JUN", 3)) r = 6; else if(!strncmp(scratchpad + 13, "JUL", 3)) r = 7; else if(!strncmp(scratchpad + 13, "AUG", 3)) r = 8; else if(!strncmp(scratchpad + 13, "SEP", 3)) r = 9; else if(!strncmp(scratchpad + 13, "OCT", 3)) r = 10; else if(!strncmp(scratchpad + 13, "NOV", 3)) r = 11; else if(!strncmp(scratchpad + 13, "DEC", 3)) r = 12; if(r) { startTimeDate->setDate(QDate(atoi(scratchpad + 17), r, atoi(scratchpad + 10))); startTimeDate->setMinimumDate(QDate(1970, 1, 1)); startTimeDate->setMaximumDate(QDate(2299, 12, 31)); } } else { has_startdate = 0; } p = ++i; for(; i<80; i++) { if(scratchpad[i] == ' ') break; } if(strncmp(scratchpad + p, "X ", 2)) { scratchpad[i] = 0; for(j=p; j<i; j++) { if(scratchpad[j] == '_') scratchpad[j] = ' '; } strcpy(str, scratchpad + p); remove_trailing_spaces(str); lineEdit6->setText(str); } else { lineEdit6->clear(); } p = ++i; for(; i<80; i++) { if(scratchpad[i] == ' ') break; } if(strncmp(scratchpad + p, "X ", 2)) { scratchpad[i] = 0; for(j=p; j<i; j++) { if(scratchpad[j] == '_') scratchpad[j] = ' '; } strcpy(str, scratchpad + p); remove_trailing_spaces(str); lineEdit7->setText(str); } else { lineEdit7->clear(); } p = ++i; for(; i<80; i++) { if(scratchpad[i] == ' ') break; } if(strncmp(scratchpad + p, "X ", 2)) { scratchpad[i] = 0; for(j=p; j<i; j++) { if(scratchpad[j] == '_') scratchpad[j] = ' '; } strcpy(str, scratchpad + p); remove_trailing_spaces(str); lineEdit8->setText(str); } else { lineEdit8->clear(); } p = ++i; scratchpad[80] = 0; strcpy(str, scratchpad + p); remove_trailing_spaces(str); lineEdit9->setText(str); calculate_chars_left_name(""); calculate_chars_left_recording(""); connect(lineEdit3, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &))); connect(lineEdit4, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &))); connect(lineEdit5, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &))); connect(lineEdit6, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); connect(lineEdit7, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); connect(lineEdit8, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); connect(lineEdit9, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); }
UI_headerEditorWindow::UI_headerEditorWindow(QWidget *w_parent) { mainwindow = (UI_Mainwindow *)w_parent; setWindowTitle("EDF+/BDF+ header editor"); edf = 0; bdf = 0; edfplus = 0; bdfplus = 0; edfsignals = 0; file = NULL; setMinimumSize(690, 525); setMaximumSize(690, 525); tabholder = new QTabWidget(this); tabholder->setGeometry(0, 0, 690, 455); tab1 = new QWidget; tab2 = new QWidget; fileNameLabel = new QLabel(tab1); fileNameLabel->setGeometry(10, 10, 670, 25); startTimeDateLabel = new QLabel(tab1); startTimeDateLabel->setGeometry(10, 45, 80, 25); startTimeDateLabel->setText("Starttime"); startTimeDateLabel->setVisible(false); startTimeDate = new QDateTimeEdit(tab1); startTimeDate->setGeometry(100, 45, 250, 25); startTimeDate->setDisplayFormat("dd.MM.yyyy hh:mm:ss"); startTimeDate->setMinimumDate(QDate(1970, 1, 1)); startTimeDate->setMaximumDate(QDate(2299, 12, 31)); startTimeDate->setVisible(false); label1 = new QLabel(tab1); label1->setGeometry(10, 80, 80, 25); label1->setText("Subject"); label1->setVisible(false); lineEdit1 = new QLineEdit(tab1); lineEdit1->setGeometry(100, 80, 580, 25); lineEdit1->setMaxLength(80); lineEdit1->setVisible(false); label2 = new QLabel(tab1); label2->setGeometry(10, 115, 80, 25); label2->setText("Recording"); label2->setVisible(false); lineEdit2 = new QLineEdit(tab1); lineEdit2->setGeometry(100, 115, 580, 25); lineEdit2->setMaxLength(80); lineEdit2->setVisible(false); label3 = new QLabel(tab1); label3->setGeometry(10, 80, 80, 25); label3->setText("Subject code"); label3->setVisible(false); lineEdit3 = new QLineEdit(tab1); lineEdit3->setGeometry(100, 80, 580, 25); lineEdit3->setMaxLength(80); lineEdit3->setVisible(false); label4 = new QLabel(tab1); label4->setGeometry(10, 115, 80, 25); label4->setText("Subject name"); label4->setVisible(false); lineEdit4 = new QLineEdit(tab1); lineEdit4->setGeometry(100, 115, 580, 25); lineEdit4->setMaxLength(80); lineEdit4->setVisible(false); label11 = new QLabel(tab1); label11->setGeometry(10, 150, 80, 25); label11->setText("Gender"); label11->setVisible(false); comboBox1 = new QComboBox(tab1); comboBox1->setGeometry(100, 150, 125, 25); comboBox1->addItem("unknown"); comboBox1->addItem("male"); comboBox1->addItem("female"); comboBox1->setVisible(false); charsleft1Label = new QLabel(tab1); charsleft1Label->setGeometry(500, 150, 120, 25); charsleft1Label->setVisible(false); label12 = new QLabel(tab1); label12->setGeometry(10, 185, 80, 25); label12->setText("Birthdate"); label12->setVisible(false); dateEdit1 = new QDateEdit(tab1); dateEdit1->setGeometry(100, 185, 125, 25); dateEdit1->setDisplayFormat("d MMM yyyy"); dateEdit1->setVisible(false); checkBox1 = new QCheckBox("No birthdate", tab1); checkBox1->setGeometry(245, 185, 125, 25); checkBox1->setTristate(false); checkBox1->setCheckState(Qt::Unchecked); checkBox1->setVisible(false); label5 = new QLabel(tab1); label5->setGeometry(10, 220, 80, 25); label5->setText("Additional info"); label5->setVisible(false); lineEdit5 = new QLineEdit(tab1); lineEdit5->setGeometry(100, 220, 580, 25); lineEdit5->setMaxLength(80); lineEdit5->setVisible(false); label6 = new QLabel(tab1); label6->setGeometry(10, 255, 80, 25); label6->setText("Admin. code"); label6->setVisible(false); lineEdit6 = new QLineEdit(tab1); lineEdit6->setGeometry(100, 255, 580, 25); lineEdit6->setMaxLength(80); lineEdit6->setVisible(false); label7 = new QLabel(tab1); label7->setGeometry(10, 290, 80, 25); label7->setText("Technician"); label7->setVisible(false); lineEdit7 = new QLineEdit(tab1); lineEdit7->setGeometry(100, 290, 580, 25); lineEdit7->setMaxLength(80); lineEdit7->setVisible(false); label8 = new QLabel(tab1); label8->setGeometry(10, 325, 80, 25); label8->setText("Device"); label8->setVisible(false); lineEdit8 = new QLineEdit(tab1); lineEdit8->setGeometry(100, 325, 580, 25); lineEdit8->setMaxLength(80); lineEdit8->setVisible(false); label9 = new QLabel(tab1); label9->setGeometry(10, 360, 80, 25); label9->setText("Additional info"); label9->setVisible(false); lineEdit9 = new QLineEdit(tab1); lineEdit9->setGeometry(100, 360, 580, 25); lineEdit9->setMaxLength(80); lineEdit9->setVisible(false); charsleft2Label = new QLabel(tab1); charsleft2Label->setGeometry(500, 395, 120, 25); charsleft2Label->setVisible(false); signallist = new QTableWidget(tab2); signallist->setGeometry(10, 10, 670, 375); signallist->setSelectionMode(QAbstractItemView::NoSelection); signallist->setEditTriggers(QAbstractItemView::NoEditTriggers); signallist->setColumnCount(4); signallist->setSelectionMode(QAbstractItemView::NoSelection); signallist->setColumnWidth(0, 180); signallist->setColumnWidth(1, 120); signallist->setColumnWidth(2, 520); signallist->setColumnWidth(3, 520); QStringList horizontallabels; horizontallabels += "Label"; horizontallabels += "Physical dimension"; horizontallabels += "Prefilter"; horizontallabels += "Transducer"; signallist->setHorizontalHeaderLabels(horizontallabels); pushButton1 = new QPushButton(this); pushButton1->setGeometry(580, 475, 100, 25); pushButton1->setText("Close"); pushButton2 = new QPushButton(this); pushButton2->setGeometry(200, 475, 100, 25); pushButton2->setText("Save"); pushButton3 = new QPushButton(this); pushButton3->setGeometry(10, 475, 100, 25); pushButton3->setText("Select file"); connect(pushButton1, SIGNAL(clicked()), this, SLOT(close())); connect(pushButton2, SIGNAL(clicked()), this, SLOT(save_hdr())); connect(pushButton3, SIGNAL(clicked()), this, SLOT(open_file())); tabholder->addTab(tab1, "Header"); tabholder->addTab(tab2, "Signals"); hdr = (char *)malloc(256 * 2050); QMessageBox messagewindow(QMessageBox::Warning, "Warning", "Always make a backup copy of your file before using this tool!"); messagewindow.exec(); exec(); }
void UI_BDF2EDFwindow::SelectFileButton() { int i; char txt_string[2048]; if(edfhdr!=NULL) { label1->setText(""); SignalsTablewidget->setRowCount(0); free_edfheader(); inputfile = NULL; outputfile = NULL; inputpath[0] = 0; pushButton3->setEnabled(false); pushButton4->setEnabled(false); pushButton5->setEnabled(false); } strcpy(inputpath, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "BDF files (*.bdf *.BDF)").toLocal8Bit().data()); if(!strcmp(inputpath, "")) { return; } get_directory_from_path(recent_opendir, inputpath, MAX_PATH_LENGTH); inputfile = fopeno(inputpath, "rb"); if(inputfile==NULL) { snprintf(txt_string, 2048, "Can not open file %s for reading.", inputpath); QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(txt_string)); messagewindow.exec(); return; } /***************** check if the file is valid ******************************/ EDFfileCheck EDFfilechecker; edfhdr = EDFfilechecker.check_edf_file(inputfile, txt_string); if(edfhdr==NULL) { fclose(inputfile); QMessageBox messagewindow(QMessageBox::Critical, "Error", txt_string); messagewindow.exec(); return; } if(!edfhdr->bdf) { fclose(inputfile); QMessageBox messagewindow(QMessageBox::Critical, "Error", "File is not a BDF file."); messagewindow.exec(); free_edfheader(); return; } /***************** load signalproperties ******************************/ label1->setText(QString::fromLocal8Bit(inputpath)); SignalsTablewidget->setRowCount(edfhdr->edfsignals); for(i=0; i<edfhdr->edfsignals; i++) { SignalsTablewidget->setRowHeight(i, 25); SignalsTablewidget->setCellWidget(i, 0, new QCheckBox(edfhdr->edfparam[i].label)); ((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->setTristate(false); ((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->setCheckState(Qt::Checked); if(!edfhdr->edfparam[i].annotation) { SignalsTablewidget->setCellWidget(i, 1, new QDoubleSpinBox); ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setDecimals(3); ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setSuffix(" Hz"); ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setRange(0.001, 100.0); ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 1)))->setValue(spinBox1->value()); SignalsTablewidget->setCellWidget(i, 2, new QDoubleSpinBox); ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->setDecimals(3); ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->setRange(1.0, 256.0); ((QDoubleSpinBox *)(SignalsTablewidget->cellWidget(i, 2)))->setValue(spinBox2->value()); } else { ((QCheckBox *)(SignalsTablewidget->cellWidget(i, 0)))->setEnabled(false); } } pushButton3->setEnabled(true); pushButton4->setEnabled(true); pushButton5->setEnabled(true); }
void UI_ECGExport::Export_RR_intervals() { int i, len, signal_nr, type=-1, beat_cnt, samples_cnt, progress_steps, datarecords, whole_recording=0, import_as_annots=0, filenum=0; char path[MAX_PATH_LENGTH], str[2048]; double *beat_interval_list, *buf; long long *beat_onset_list, datrecs, smpls_left, l_time=0LL; struct signalcompblock *signalcomp; FILE *outputfile; QList<QListWidgetItem *> selectedlist; struct annotationblock *annotation; selectedlist = list->selectedItems(); if(selectedlist.size() < 1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Select a signal first."); messagewindow.exec(); return; } signal_nr = selectedlist.at(0)->data(Qt::UserRole).toInt(); if((signal_nr < 0) || (signal_nr >= mainwindow->signalcomps)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Invalid signalcomp number"); messagewindow.exec(); return; } signalcomp = mainwindow->signalcomp[signal_nr]; if(signalcomp->ecg_filter == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Heart Rate detection is not activated for the selected signal."); messagewindow.exec(); return; } if(checkBox2->checkState() == Qt::Checked) { import_as_annots = 1; } if(checkBox1->checkState() == Qt::Checked) { whole_recording = 1; class FilteredBlockReadClass blockrd; buf = blockrd.init_signalcomp(signalcomp, 1, 0); if(buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, can not initialize FilteredBlockReadClass."); messagewindow.exec(); return; } samples_cnt = blockrd.samples_in_buf(); if(samples_cnt < 1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, samples_cnt is < 1."); messagewindow.exec(); return; } filenum = signalcomp->filenum; reset_ecg_filter(signalcomp->ecg_filter); datarecords = signalcomp->edfhdr->datarecords; QProgressDialog progress("Processing file...", "Abort", 0, datarecords); progress.setWindowModality(Qt::WindowModal); progress.setMinimumDuration(200); progress_steps = datarecords / 100; if(progress_steps < 1) { progress_steps = 1; } for(i=0; i<signalcomp->edfhdr->datarecords; i++) { if(!(i%progress_steps)) { progress.setValue(i); qApp->processEvents(); if(progress.wasCanceled() == TRUE) { return; } } if(blockrd.process_signalcomp(i) != 0) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error while reading file."); messagewindow.exec(); return; } } progress.reset(); } beat_cnt = ecg_filter_get_beat_cnt(signalcomp->ecg_filter); beat_onset_list = ecg_filter_get_onset_beatlist(signalcomp->ecg_filter); beat_interval_list = ecg_filter_get_interval_beatlist(signalcomp->ecg_filter); if(beat_cnt < 4) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, not enough beats."); messagewindow.exec(); return; } if(import_as_annots) { for(i=0; i<beat_cnt; i++) { if(whole_recording) { l_time = 0LL; } else { l_time = signalcomp->edfhdr->viewtime; } if(l_time < 0LL) { l_time = 0LL; } datrecs = beat_onset_list[i] / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record; smpls_left = beat_onset_list[i] % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record; l_time += (datrecs * signalcomp->edfhdr->long_data_record_duration); l_time += ((smpls_left * signalcomp->edfhdr->long_data_record_duration) / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record); if(!whole_recording) { l_time += (mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime - signalcomp->edfhdr->viewtime); } annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock)); if(annotation == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred (annotation)."); messagewindow.exec(); return; } annotation->onset = l_time; strncpy(annotation->annotation, "R-onset", MAX_ANNOTATION_LEN); annotation->annotation[MAX_ANNOTATION_LEN] = 0; edfplus_annotation_add_item(&mainwindow->annotationlist[filenum], annotation); } if(mainwindow->annotations_dock[signalcomp->filenum] == NULL) { mainwindow->annotations_dock[filenum] = new UI_Annotationswindow(filenum, mainwindow); mainwindow->addDockWidget(Qt::RightDockWidgetArea, mainwindow->annotations_dock[filenum]->docklist, Qt::Vertical); if(!mainwindow->annotationlist[filenum]) { mainwindow->annotations_dock[filenum]->docklist->hide(); } } if(mainwindow->annotationlist[filenum]) { mainwindow->annotations_dock[filenum]->docklist->show(); mainwindow->annotations_edited = 1; mainwindow->annotations_dock[filenum]->updateList(); mainwindow->save_act->setEnabled(TRUE); } } else { path[0] = 0; if(mainwindow->recent_savedir[0]!=0) { strcpy(path, mainwindow->recent_savedir); strcat(path, "/"); } len = strlen(path); get_filename_from_path(path + len, signalcomp->edfhdr->filename, MAX_PATH_LENGTH - len); remove_extension_from_filename(path); strcat(path, "_RR_interval.txt"); strcpy(path, QFileDialog::getSaveFileName(0, "Export RR-interval to ASCII", QString::fromLocal8Bit(path), "Text files (*.txt *.TXT)").toLocal8Bit().data()); if(!strcmp(path, "")) { return; } get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH); outputfile = fopeno(path, "wb"); if(outputfile==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, can not open outputfile for writing."); messagewindow.exec(); return; } if(radioButton1->isChecked() == TRUE) { type = 1; } if(radioButton2->isChecked() == TRUE) { type = 2; } if(radioButton3->isChecked() == TRUE) { type = 3; } if(type == 1) { for(i=0; i<beat_cnt; i++) { fprintf(outputfile, "%.4f\n", beat_interval_list[i]); } } if((type == 2) || (type == 3)) { for(i=0; i<beat_cnt; i++) { if(whole_recording) { l_time = 0LL; } else { l_time = signalcomp->edfhdr->viewtime; } if(l_time < 0LL) { l_time = 0LL; } datrecs = beat_onset_list[i] / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record; smpls_left = beat_onset_list[i] % signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record; l_time += (datrecs * signalcomp->edfhdr->long_data_record_duration); l_time += ((smpls_left * signalcomp->edfhdr->long_data_record_duration) / signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record); if(!whole_recording) { l_time += (mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime - signalcomp->edfhdr->viewtime); } if(type == 2) { fprintf(outputfile, "%.4f\t%.4f\n", ((double)l_time) / TIME_DIMENSION, beat_interval_list[i]); } if(type == 3) { fprintf(outputfile, "%.4f\n", ((double)l_time) / TIME_DIMENSION); } } } fclose(outputfile); } myobjectDialog->close(); if(!import_as_annots) { sprintf(str, "Done. The R-onsets and/or RR-intervals are exported to:\n\n%s", path); QMessageBox messagewindow(QMessageBox::Information, "Ready", str); messagewindow.setIconPixmap(QPixmap(":/images/ok.png")); messagewindow.exec(); } reset_ecg_filter(signalcomp->ecg_filter); mainwindow->setup_viewbuf(); }
void UI_BIOSEMI2BDFPLUSwindow::SelectFileButton() { int i, j, k, error, hdl_in, hdl_out, edfsignals, status_signal=0, status_samples_in_datarecord=0, rising_edge, set_duration, status[24], totalSamplesInDatarecord, *buf, buf_offset[EDFLIB_MAXSIGNALS], sf, new_sf, samplerate_divider; char str[2048], triggerlabel[24][64], outputfilename[MAX_PATH_LENGTH]; long long datarecords, status_sample_duration, trigger_cnt, progress_steps; struct edf_hdr_struct hdr; struct annotationblock *annotlist=NULL; struct annotationblock *annotation; for(i=0; i<16; i++) { if(!lineEdit1[i]->text().length()) { sprintf(str, "Trigger Input label %i is empty!", i + 1); QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); return; } } for(i=0; i<16; i++) { for(j=0; j<16; j++) { if(i != j) { if(!strcmp(lineEdit1[i]->text().toLocal8Bit().data(), lineEdit1[j]->text().toLocal8Bit().data())) { sprintf(str, "Trigger Input labels %i and %i are the same!", i + 1, j + 1); QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); return; } } } } str[0] = 0; strcpy(inputpath, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "BDF files (*.bdf *.BDF)").toLocal8Bit().data()); if(!strcmp(inputpath, "")) { return; } get_directory_from_path(recent_opendir, inputpath, MAX_PATH_LENGTH); error = edfopen_file_readonly(inputpath, &hdr, EDFLIB_DO_NOT_READ_ANNOTATIONS); if(error < 0) { error = hdr.filetype; switch(error) { case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error."); break; case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory."); break; case EDFLIB_FILE_CONTAINS_FORMAT_ERRORS : strcpy(str, "EDFlib: file contains format errors.\nOpen the file in EDFbrowser to get more info."); break; case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum amount of files reached."); break; case EDFLIB_FILE_READ_ERROR : strcpy(str, "EDFlib: a file read error occurred."); break; case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file is already opened."); break; case EDFLIB_FILETYPE_ERROR : strcpy(str, "EDFlib: filetype error."); break; case EDFLIB_FILE_WRITE_ERROR : strcpy(str, "EDFlib: file write error."); break; case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: invalid number of signals."); break; case EDFLIB_FILE_IS_DISCONTINUOUS : strcpy(str, "EDFlib: file is discontinuous."); break; case EDFLIB_INVALID_READ_ANNOTS_VALUE : strcpy(str, "EDFlib: invalid read annotations argument."); break; default : strcpy(str, "EDFlib: unknown error."); } QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); return; } hdl_in = hdr.handle; /////////////////// check file ///////////////////////////////////////////// if(hdr.filetype == EDFLIB_FILETYPE_BDFPLUS) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is already a BDF-plus file."); messagewindow.exec(); edfclose_file(hdl_in); return; } if(hdr.filetype != EDFLIB_FILETYPE_BDF) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is not a BDF file."); messagewindow.exec(); edfclose_file(hdl_in); return; } if(hdr.datarecord_duration != EDFLIB_TIME_DIMENSION) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Datarecord duration of inputfile must be 1 second."); messagewindow.exec(); edfclose_file(hdl_in); return; } edfsignals = hdr.edfsignals; if(edfsignals < 1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There are no signals in the selected file."); messagewindow.exec(); edfclose_file(hdl_in); return; } sf = hdr.signalparam[0].smp_in_datarecord; for(i=1; i<edfsignals; i++) { if(hdr.signalparam[i].smp_in_datarecord != sf) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "All signals must have the same samplefrequency."); messagewindow.exec(); edfclose_file(hdl_in); return; } } error = 1; switch(sf) { case 16384 : error = 0; break; case 8192 : error = 0; break; case 4096 : error = 0; break; case 2048 : error = 0; break; case 1024 : error = 0; break; case 512 : error = 0; break; case 256 : error = 0; break; case 128 : error = 0; break; case 64 : error = 0; break; case 32 : error = 0; break; } if(error) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency must be 16384, 8192, 4096, 2048, 1024, 512, 256, 128, 64 or 32 Hz."); messagewindow.exec(); edfclose_file(hdl_in); return; } for(i=0; i<edfsignals; i++) { if(!(strcmp(hdr.signalparam[i].label, "Status "))) { status_signal = i; break; } } if(i == edfsignals) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There is no Status signal in the selected file."); messagewindow.exec(); edfclose_file(hdl_in); return; } totalSamplesInDatarecord = 0; for(i=0; i<edfsignals; i++) { buf_offset[i] = totalSamplesInDatarecord; if(i == status_signal) { status_samples_in_datarecord = hdr.signalparam[i].smp_in_datarecord; } totalSamplesInDatarecord += hdr.signalparam[i].smp_in_datarecord; } status_sample_duration = EDFLIB_TIME_DIMENSION / (long long)status_samples_in_datarecord; for(i=0; i<16; i++) { strcpy(&triggerlabel[i][0], lineEdit1[i]->text().toUtf8().data()); triggerlabel[i][16] = 0; } strcpy(&triggerlabel[16][0], "new epoch"); if(radioButton1->isChecked() == true) { rising_edge = 1; for(i=0; i<16; i++) { status[i] = 1; } } else { rising_edge = 0; for(i=0; i<16; i++) { status[i] = 0; } } if(checkBox1->isChecked() == true) { set_duration = 1; } else { set_duration = 0; } for(i=16; i<24; i++) { status[i] = 1; } strcpy(outputfilename, inputpath); remove_extension_from_filename(outputfilename); strcat(outputfilename, "_+.bdf"); outputpath[0] = 0; if(recent_savedir[0]!=0) { strcpy(outputpath, recent_savedir); strcat(outputpath, "/"); } strcat(outputpath, outputfilename); strcpy(outputpath, QFileDialog::getSaveFileName(0, "Output file", QString::fromLocal8Bit(outputpath), "BDF files (*.bdf *.BDF)").toLocal8Bit().data()); if(!strcmp(outputpath, "")) { edfclose_file(hdl_in); return; } get_directory_from_path(recent_savedir, outputpath, MAX_PATH_LENGTH); if(mainwindow->file_is_opened(outputpath)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Outputfile is already opened in EDFbrowser.\nClose the file and try again."); messagewindow.exec(); edfclose_file(hdl_in); return; } if(!(strcmp(inputpath, outputpath))) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Inputfile and outputfile are the same."); messagewindow.exec(); edfclose_file(hdl_in); return; } hdl_out = edfopen_file_writeonly(outputpath, EDFLIB_FILETYPE_BDFPLUS, edfsignals); if(hdl_out < 0) { switch(hdl_out) { case EDFLIB_MALLOC_ERROR : strcpy(str, "EDFlib: malloc error."); break; case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : strcpy(str, "EDFlib: no such file or directory."); break; case EDFLIB_MAXFILES_REACHED : strcpy(str, "EDFlib: maximum amount of files reached."); break; case EDFLIB_FILE_READ_ERROR : strcpy(str, "EDFlib: a file read error occurred."); break; case EDFLIB_FILE_ALREADY_OPENED : strcpy(str, "EDFlib: file is already opened."); break; case EDFLIB_FILETYPE_ERROR : strcpy(str, "EDFlib: filetype error."); break; case EDFLIB_FILE_WRITE_ERROR : strcpy(str, "EDFlib: file write error."); break; case EDFLIB_NUMBER_OF_SIGNALS_INVALID : strcpy(str, "EDFlib: invalid number of signals."); break; default : strcpy(str, "EDFlib: unknown error."); } QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); edfclose_file(hdl_in); return; } /////////////////// copy header ///////////////////////////////////////////// for(i=0; i<edfsignals; i++) { edf_set_samplefrequency(hdl_out, i, hdr.signalparam[i].smp_in_datarecord); edf_set_physical_maximum(hdl_out, i, hdr.signalparam[i].phys_max); edf_set_physical_minimum(hdl_out, i, hdr.signalparam[i].phys_min); edf_set_digital_maximum(hdl_out, i, hdr.signalparam[i].dig_max); edf_set_digital_minimum(hdl_out, i, hdr.signalparam[i].dig_min); edf_set_label(hdl_out, i, hdr.signalparam[i].label); edf_set_prefilter(hdl_out, i, hdr.signalparam[i].prefilter); edf_set_transducer(hdl_out, i, hdr.signalparam[i].transducer); edf_set_physical_dimension(hdl_out, i, hdr.signalparam[i].physdimension); } edf_set_startdatetime(hdl_out, hdr.startdate_year, hdr.startdate_month, hdr.startdate_day, hdr.starttime_hour, hdr.starttime_minute, hdr.starttime_second); edf_set_patientname(hdl_out, hdr.patient); edf_set_recording_additional(hdl_out, hdr.recording); /////////////////// collect triggers ///////////////////////////////////////////// buf = (int *)malloc(sizeof(int) * status_samples_in_datarecord); if(buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf)."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); return; } QProgressDialog progress("Collecting triggers...", "Abort", 0, (int)hdr.datarecords_in_file); progress.setWindowModality(Qt::WindowModal); progress.setMinimumDuration(200); progress_steps = hdr.datarecords_in_file / 100LL; if(progress_steps < 1LL) { progress_steps = 1LL; } trigger_cnt = 0; for(datarecords = 0LL; datarecords < hdr.datarecords_in_file; datarecords++) { if(trigger_cnt >= ((hdr.datarecords_in_file * 32) - 2)) { break; } if(trigger_cnt >= 100000) { break; } if(!(datarecords % progress_steps)) { progress.setValue((int)datarecords); qApp->processEvents(); if(progress.wasCanceled()) { edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); edfplus_annotation_delete_list(&annotlist); return; } } if(edfread_digital_samples(hdl_in, status_signal, status_samples_in_datarecord, buf) < 0) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during the collection of triggers."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); edfplus_annotation_delete_list(&annotlist); return; } for(i=0; i<status_samples_in_datarecord; i++) { for(j=0; j<17; j++) { if(((buf[i] & (1 << j)) && !status[j]) || (!(buf[i] & (1 << j)) && status[j])) // rising or falling edge detected { if(status[j]) // falling edge detected { if((!rising_edge) && (j < 16)) { annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock)); if(annotation == NULL) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (annotation)."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); edfplus_annotation_delete_list(&annotlist); return; } annotation->onset = (datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration); annotation->onset += hdr.starttime_subsecond; strcpy(annotation->annotation, triggerlabel[j]); edfplus_annotation_add_item(&annotlist, annotation); trigger_cnt++; } else { if(set_duration) { k = edfplus_annotation_count(&annotlist); for(; k>0; k--) { annotation = edfplus_annotation_item(&annotlist, k - 1); if(annotation == NULL) { break; } if(!strcmp(annotation->annotation, triggerlabel[j])) { sprintf(str, "%.4f", (double)((datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration) - annotation->onset) / (double)EDFLIB_TIME_DIMENSION); str[15] = 0; strcpy(annotation->duration, str); break; } } } } status[j] = 0; } else // rising edge detected { if(rising_edge || (j == 16)) { annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock)); if(annotation == NULL) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (annotation)."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); edfplus_annotation_delete_list(&annotlist); return; } annotation->onset = (datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration); annotation->onset += hdr.starttime_subsecond; strcpy(annotation->annotation, triggerlabel[j]); edfplus_annotation_add_item(&annotlist, annotation); trigger_cnt++; } else { if(set_duration) { k = edfplus_annotation_count(&annotlist); for(; k>0; k--) { annotation = edfplus_annotation_item(&annotlist, k - 1); if(annotation == NULL) { break; } if(!strcmp(annotation->annotation, triggerlabel[j])) { sprintf(str, "%.4f", (double)((datarecords * EDFLIB_TIME_DIMENSION) + ((long long)i * status_sample_duration) - annotation->onset) / (double)EDFLIB_TIME_DIMENSION); str[15] = 0; strcpy(annotation->duration, str); break; } } } } status[j] = 1; } } } } } edfwrite_annotation_latin1(hdl_out, 0LL, -1LL, "Recording starts"); j = edfplus_annotation_count(&annotlist); for(i=0; i<j; i++) { annotation = edfplus_annotation_item(&annotlist, i); if(annotation->duration[0] == 0) { edfwrite_annotation_utf8(hdl_out, annotation->onset / 1000LL, -1LL, annotation->annotation); } else { edfwrite_annotation_utf8(hdl_out, annotation->onset / 1000LL, (long long)(atof(annotation->duration) * 10000.0), annotation->annotation); } } free(buf); edfwrite_annotation_latin1(hdl_out, hdr.datarecords_in_file * 10000LL, -1LL, "Recording ends"); /////////////////// choose datarecord duration ///////////////////////////////////////////// samplerate_divider = 1; i = edfplus_annotation_count(&annotlist); edfplus_annotation_delete_list(&annotlist); annotlist = NULL; if(i % 2) { i++; } i += 2; while(i > hdr.datarecords_in_file) { samplerate_divider *= 2; i /= 2; if(samplerate_divider == 32) { break; } } if(samplerate_divider > 1) { for(i=0; i<edfsignals; i++) { edf_set_samplefrequency(hdl_out, i, hdr.signalparam[i].smp_in_datarecord / samplerate_divider); } if(edf_set_datarecord_duration(hdl_out, 100000 / samplerate_divider) == -1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_datarecord_duration() returned an error."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); return; } } new_sf = sf / samplerate_divider; /////////////////// start conversion ///////////////////////////////////////////// buf = (int *)malloc(sizeof(int) * totalSamplesInDatarecord); if(buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf)."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); return; } edfrewind(hdl_in, status_signal); progress.setLabelText("Converting..."); progress.setValue(0); for(datarecords = 0LL; datarecords < hdr.datarecords_in_file; datarecords++) { if(!(datarecords % progress_steps)) { progress.setValue((int)datarecords); qApp->processEvents(); if(progress.wasCanceled()) { edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); return; } } for(i=0; i<edfsignals; i++) { if(edfread_digital_samples(hdl_in, i, hdr.signalparam[i].smp_in_datarecord, buf + buf_offset[i]) < 0) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read error occurred during the conversion."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); return; } } for(j=0; j<samplerate_divider; j++) { for(i=0; i<edfsignals; i++) { if(edfwrite_digital_samples(hdl_out, buf + buf_offset[i] + (j * new_sf)) < 0) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "A write error occurred during the conversion."); messagewindow.exec(); edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); return; } } } } QApplication::setOverrideCursor(Qt::WaitCursor); edfclose_file(hdl_in); edfclose_file(hdl_out); free(buf); QApplication::restoreOverrideCursor(); progress.reset(); #ifdef Q_WS_WIN snprintf(str, 2048, "Done. Converted %I64d input trigger events to BDF+ annotations.\n" "\nBDF+ file is located at %s", trigger_cnt, outputpath); #else snprintf(str, 2048, "Done. Converted %lli input trigger events to BDF+ annotations.\n" "\nBDF+ file is located at %s", trigger_cnt, outputpath); #endif QMessageBox messagewindow(QMessageBox::Information, "Ready", str); messagewindow.setIconPixmap(QPixmap(":/images/ok.png")); messagewindow.exec(); }
void print_screen_to_edf(UI_Mainwindow *mainwindow) { int i, j, k, p, n=0, records, records_written, signalcomps, duration_factor[MAXFILES], temp=0, edfplus=0, tallen, annotationlist_nr=0, annotations_left=1, add_one_sec=0, annot_smp_per_record=16, type, len; long long duration, smpls_written[MAXSIGNALS], s2, preamble=0LL, smpls_preamble[MAXSIGNALS], taltime=0LL, l_temp, referencetime, annot_difftime=0LL; char path[MAX_PATH_LENGTH], scratchpad[512], datrecduration[8], *viewbuf; double frequency, frequency2, dig_value; FILE *outputfile; struct signalcompblock **signalcomp; union { signed int one_signed; signed short two_signed[2]; unsigned char four[4]; } wr_var; union { signed short one_signed; unsigned char two[2]; } null_bytes[MAXSIGNALS]; struct annotationblock *annotations_pntr; struct date_time_struct date_time; ///////////////////////////////////////////////////////////////////////// signalcomps = mainwindow->signalcomps; signalcomp = mainwindow->signalcomp; viewbuf = mainwindow->viewbuf; annotations_pntr = mainwindow->annotationlist[0]; if((!mainwindow->files_open)||(!signalcomps)) { QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "Put a signal on the screen and try again."); messagewindow.exec(); return; } for(i=0; i<mainwindow->files_open; i++) { if(mainwindow->edfheaderlist[i]->bdf) { QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "BDF files can not be printed to EDF."); messagewindow.exec(); return; } if(mainwindow->edfheaderlist[i]->discontinuous) { QMessageBox messagewindow(QMessageBox::Critical, "Print to EDF", "Sorry, discontinues EDF files can not be printed to EDF."); messagewindow.exec(); return; } if(mainwindow->edfheaderlist[i]->edfplus) { edfplus = 1; for(j=0; j<mainwindow->edfheaderlist[i]->nr_annot_chns; j++) { if(mainwindow->edfheaderlist[i]->edfparam[mainwindow->edfheaderlist[i]->annot_ch[j]].smp_per_record>annot_smp_per_record) { annot_smp_per_record = mainwindow->edfheaderlist[i]->edfparam[mainwindow->edfheaderlist[i]->annot_ch[j]].smp_per_record; } } } } annot_smp_per_record += 16; taltime = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset; duration = 0; for(i=0; i<signalcomps; i++) { if(signalcomp[i]->edfhdr->long_data_record_duration>duration) { duration = signalcomp[i]->edfhdr->long_data_record_duration; n = i; } } fseeko(signalcomp[n]->edfhdr->file_hdl, 244LL, SEEK_SET); if(fread(datrecduration, 8, 1, signalcomp[n]->edfhdr->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); return; } temp = 0; for(i=0; i<signalcomps; i++) { if(duration % signalcomp[i]->edfhdr->long_data_record_duration) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "This combination of files can not be printed to EDF\n" "because the quotient of the datarecordblock durations is not an integer."); messagewindow.exec(); return; } duration_factor[signalcomp[i]->filenum] = duration / signalcomp[i]->edfhdr->long_data_record_duration; temp += signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record; } path[0] = 0; if(mainwindow->recent_savedir[0]!=0) { strcpy(path, mainwindow->recent_savedir); strcat(path, "/"); } len = strlen(path); get_filename_from_path(path + len, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->filename, MAX_PATH_LENGTH - len); remove_extension_from_filename(path); strcat(path, "_screenprint.edf"); strcpy(path, QFileDialog::getSaveFileName(0, "Print to EDF", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data()); if(!strcmp(path, "")) { return; } get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH); if(mainwindow->file_is_opened(path)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Error, selected file is in use."); messagewindow.exec(); return; } outputfile = fopeno(path, "wb"); if(outputfile==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not create a file for writing."); messagewindow.exec(); return; } referencetime = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime; if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime<0) { if((-mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime) % TIME_DIMENSION) { preamble = TIME_DIMENSION - ((-mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime) % TIME_DIMENSION); referencetime--; add_one_sec = 1; } } else { preamble = mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime % TIME_DIMENSION; if(preamble) add_one_sec = 1; } for(i=0; i<signalcomps; i++) { smpls_preamble[i] = preamble / (signalcomp[i]->edfhdr->long_data_record_duration / signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record); } referencetime += (mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime / TIME_DIMENSION); utc_to_date_time(referencetime, &date_time); /************************* write EDF-header ***************************************/ rewind(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl); rewind(outputfile); if(edfplus) { if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->edfplus) { if(fread(scratchpad, 88, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); fclose(outputfile); return; } if(fwrite(scratchpad, 88, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } else { fprintf(outputfile, "0 X X X X "); if(fread(scratchpad, 88, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); fclose(outputfile); return; } if(fwrite(scratchpad + 8, 72, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } fprintf(outputfile, "Startdate %02i-", date_time.day); switch(date_time.month) { case 1 : fprintf(outputfile, "JAN"); break; case 2 : fprintf(outputfile, "FEB"); break; case 3 : fprintf(outputfile, "MAR"); break; case 4 : fprintf(outputfile, "APR"); break; case 5 : fprintf(outputfile, "MAY"); break; case 6 : fprintf(outputfile, "JUN"); break; case 7 : fprintf(outputfile, "JUL"); break; case 8 : fprintf(outputfile, "AUG"); break; case 9 : fprintf(outputfile, "SEP"); break; case 10 : fprintf(outputfile, "OCT"); break; case 11 : fprintf(outputfile, "NOV"); break; case 12 : fprintf(outputfile, "DEC"); break; default : fprintf(outputfile, "ERR"); break; } fprintf(outputfile, "-%04i ", date_time.year); if(mainwindow->edfheaderlist[mainwindow->sel_viewtime]->edfplus) { if(fread(scratchpad, 80, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); fclose(outputfile); return; } if(scratchpad[10]=='X') { if(fwrite(scratchpad + 12, 58, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } else { if(fwrite(scratchpad + 22, 58, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } } else { fprintf(outputfile, "X X X "); if(fread(scratchpad, 80, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); fclose(outputfile); return; } if(fwrite(scratchpad + 28, 52, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } } else { if(fread(scratchpad, 168, 1, mainwindow->edfheaderlist[mainwindow->sel_viewtime]->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); fclose(outputfile); return; } if(fwrite(scratchpad, 168, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } fprintf(outputfile, "%02i.%02i.%02i%02i.%02i.%02i", date_time.day, date_time.month, date_time.year % 100, date_time.hour, date_time.minute, date_time.second); fprintf(outputfile, "%-8i", (signalcomps + edfplus) * 256 + 256); if(edfplus) { fprintf(outputfile, "EDF+C"); for(i=0; i<39; i++) fputc(' ', outputfile); } else for(i=0; i<44; i++) fputc(' ', outputfile); records = (int)(mainwindow->pagetime / duration); if(add_one_sec) { records += TIME_DIMENSION / duration; } fprintf(outputfile, "%-8i", records); if(fwrite(datrecduration, 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } fprintf(outputfile, "%-4i", signalcomps + edfplus); for(i=0; i<signalcomps; i++) { strcpy(scratchpad, signalcomp[i]->signallabel); strcat(scratchpad, " "); if(fwrite(scratchpad, 16, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(edfplus) { if(fwrite("EDF Annotations ", 16, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } for(i=0; i<signalcomps; i++) { if(fwrite(signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].transducer, 80, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(edfplus) { for(i=0; i<80; i++) fputc(' ', outputfile); } for(i=0; i<signalcomps; i++) { strcpy(scratchpad, signalcomp[i]->physdimension); strcat(scratchpad, " "); if(fwrite(scratchpad, 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(edfplus) { for(i=0; i<8; i++) fputc(' ', outputfile); } for(i=0; i<signalcomps; i++) { if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL)) { fseeko(signalcomp[i]->edfhdr->file_hdl, (long long)((signalcomp[i]->edfsignal[0] * 8) + (104 * signalcomp[i]->edfhdr->edfsignals) + 256), SEEK_SET); if(fread(scratchpad, 8, 1, signalcomp[i]->edfhdr->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); fclose(outputfile); return; } if(fwrite(scratchpad, 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(signalcomp[i]->ecg_filter != NULL) { if(fwrite("0 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(signalcomp[i]->zratio_filter != NULL) { if(fwrite("-1 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } } if(edfplus) { if(fwrite("-1 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } for(i=0; i<signalcomps; i++) { if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL)) { fseeko(signalcomp[i]->edfhdr->file_hdl, (long long)((signalcomp[i]->edfsignal[0] * 8) + (112 * signalcomp[i]->edfhdr->edfsignals) + 256), SEEK_SET); if(fread(scratchpad, 8, 1, signalcomp[i]->edfhdr->file_hdl)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading from inputfile."); messagewindow.exec(); fclose(outputfile); return; } if(fwrite(scratchpad, 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(signalcomp[i]->ecg_filter != NULL) { if(fwrite("1000 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(signalcomp[i]->zratio_filter != NULL) { if(fwrite("1 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } } if(edfplus) { if(fwrite("1 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } for(i=0; i<signalcomps; i++) { if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL)) { fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min); if(signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min<0) { null_bytes[i].one_signed = 0; } else { null_bytes[i].one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min; } } else { if(fwrite("-32768 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } null_bytes[i].one_signed = -32768; } } if(edfplus) { if(fwrite("-32768 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } for(i=0; i<signalcomps; i++) { if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL)) { fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max); } else { if(fwrite("32767 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } } if(edfplus) { if(fwrite("32767 ", 8, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } for(i=0; i<signalcomps; i++) { strcpy(scratchpad, signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].prefilter); strcat(scratchpad, " "); for(p = strlen(scratchpad) - 1; p>=0; p--) { if(scratchpad[p]!=' ') break; } p++; if(p) p++; for(j=0; j<signalcomp[i]->filter_cnt; j++) { if(signalcomp[i]->filter[j]->is_LPF == 1) { p += sprintf(scratchpad + p, "LP:%f", signalcomp[i]->filter[j]->cutoff_frequency); } if(signalcomp[i]->filter[j]->is_LPF == 0) { p += sprintf(scratchpad + p, "HP:%f", signalcomp[i]->filter[j]->cutoff_frequency); } for(k=(p-1); k>0; k--) { if(scratchpad[k]!='0') break; } if(scratchpad[k]=='.') scratchpad[k] = 0; else scratchpad[k+1] = 0; strcat(scratchpad, "Hz "); p = strlen(scratchpad); if(p>80) break; } for(j=0; j<signalcomp[i]->fidfilter_cnt; j++) { type = signalcomp[i]->fidfilter_type[j]; frequency = signalcomp[i]->fidfilter_freq[j]; frequency2 = signalcomp[i]->fidfilter_freq2[j]; if(type == 0) { p += sprintf(scratchpad + p, "HP:%f", frequency); } if(type == 1) { p += sprintf(scratchpad + p, "LP:%f", frequency); } if(type == 2) { p += sprintf(scratchpad + p, "N:%f", frequency); } if(type == 3) { p += sprintf(scratchpad + p, "BP:%f", frequency); } if(type == 4) { p += sprintf(scratchpad + p, "BS:%f", frequency); } for(k=(p-1); k>0; k--) { if(scratchpad[k]!='0') break; } if(scratchpad[k]=='.') scratchpad[k] = 0; else scratchpad[k+1] = 0; p = strlen(scratchpad); if((type == 3) || (type == 4)) { p += sprintf(scratchpad + p, "-%f", frequency2); for(k=(p-1); k>0; k--) { if(scratchpad[k]!='0') break; } if(scratchpad[k]=='.') scratchpad[k] = 0; else scratchpad[k+1] = 0; } strcat(scratchpad, "Hz "); p = strlen(scratchpad); if(p>80) break; } for(j=0; j<signalcomp[i]->ravg_filter_cnt; j++) { if(signalcomp[i]->ravg_filter_type[j] == 0) { p += sprintf(scratchpad + p, "HP:%iSmpls ", signalcomp[i]->ravg_filter[j]->size); } if(signalcomp[i]->ravg_filter_type[j] == 1) { p += sprintf(scratchpad + p, "LP:%iSmpls ", signalcomp[i]->ravg_filter[j]->size); } p = strlen(scratchpad); if(p>80) break; } if(signalcomp[i]->ecg_filter != NULL) { p += sprintf(scratchpad + p, "ECG:HR "); } if(signalcomp[i]->zratio_filter != NULL) { p += sprintf(scratchpad + p, "Z-ratio "); } for(;p<81; p++) { scratchpad[p] = ' '; } if(fwrite(scratchpad, 80, 1, outputfile)!=1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } if(edfplus) { for(i=0; i<80; i++) fputc(' ', outputfile); } for(i=0; i<signalcomps; i++) { fprintf(outputfile, "%-8i", signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record * duration_factor[signalcomp[i]->filenum]); } if(edfplus) { fprintf(outputfile, "%-8i", annot_smp_per_record); } for(i=0; i<signalcomps; i++) { for(j=0; j<32; j++) fputc(' ', outputfile); } if(edfplus) { for(i=0; i<32; i++) fputc(' ', outputfile); } ///////////////////////////////////////////////////////////////////// for(i=0; i<MAXSIGNALS; i++) smpls_written[i] = 0; mainwindow->print_to_edf_active = 1; mainwindow->setup_viewbuf(); viewbuf = mainwindow->viewbuf; if(viewbuf==NULL) { fclose(outputfile); return; } QApplication::setOverrideCursor(Qt::WaitCursor); for(records_written=0; records_written<records; records_written++) { qApp->processEvents(); for(i=0; i<signalcomps; i++) { for(k=0; k<signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].smp_per_record * duration_factor[signalcomp[i]->filenum]; k++) { if(smpls_preamble[i]) { smpls_preamble[i]--; fputc(null_bytes[i].two[0], outputfile); if(fputc(null_bytes[i].two[1], outputfile)==EOF) { QApplication::restoreOverrideCursor(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } else { dig_value = 0; s2 = smpls_written[i] + signalcomp[i]->sample_timeoffset - signalcomp[i]->sample_start; for(j=0; j<signalcomp[i]->num_of_signals; j++) { if((smpls_written[i]<signalcomp[i]->sample_stop)&&(s2>=0)) { if(signalcomp[i]->edfhdr->edf) { temp = *(((short *)( viewbuf + signalcomp[i]->viewbufoffset + (signalcomp[i]->edfhdr->recordsize * (s2 / signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].smp_per_record)) + signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].buf_offset)) + (s2 % signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].smp_per_record)); } temp += signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].offset; temp *= signalcomp[i]->factor[j]; temp -= signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[j]].offset; } else { temp = 0; } dig_value += temp; } for(p=0; p<signalcomp[i]->filter_cnt; p++) { if(smpls_written[i]==signalcomp[i]->sample_start) { if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime==0) { reset_filter(dig_value, signalcomp[i]->filter[p]); } else { signalcomp[i]->filter[p]->old_input = signalcomp[i]->filterpreset_a[p]; signalcomp[i]->filter[p]->old_output = signalcomp[i]->filterpreset_b[p]; } } dig_value = first_order_filter(dig_value, signalcomp[i]->filter[p]); } for(p=0; p<signalcomp[i]->ravg_filter_cnt; p++) { if(smpls_written[i]==signalcomp[i]->sample_start) { if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime!=0) { ravg_filter_restore_buf(signalcomp[i]->ravg_filter[p]); } } dig_value = run_ravg_filter(dig_value, signalcomp[i]->ravg_filter[p]); } for(p=0; p<signalcomp[i]->fidfilter_cnt; p++) { if(smpls_written[i]==signalcomp[i]->sample_start) { if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime!=0) { memcpy(signalcomp[i]->fidbuf[p], signalcomp[i]->fidbuf2[p], fid_run_bufsize(signalcomp[i]->fid_run[p])); } } dig_value = signalcomp[i]->fidfuncp[p](signalcomp[i]->fidbuf[p], dig_value); } if(signalcomp[i]->ecg_filter != NULL) { if(smpls_written[i]==signalcomp[i]->sample_start) { if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime != 0) { ecg_filter_restore_buf(signalcomp[i]->ecg_filter); } } dig_value = run_ecg_filter(dig_value, signalcomp[i]->ecg_filter); dig_value = (dig_value * signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].bitvalue * 65.536) - 32768.0; } if(signalcomp[i]->zratio_filter != NULL) { if(smpls_written[i]==signalcomp[i]->sample_start) { if(mainwindow->edfheaderlist[signalcomp[i]->filenum]->viewtime != 0) { zratio_filter_restore_buf(signalcomp[i]->zratio_filter); } } dig_value = run_zratio_filter(dig_value, signalcomp[i]->zratio_filter); dig_value = dig_value * signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].bitvalue * 32768.0; } if((smpls_written[i]>=signalcomp[i]->sample_start)&&(smpls_written[i]<signalcomp[i]->sample_stop)) { wr_var.one_signed = dig_value; if((signalcomp[i]->ecg_filter == NULL) && (signalcomp[i]->zratio_filter == NULL)) { if(wr_var.one_signed>signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max) { wr_var.one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_max; } if(wr_var.one_signed<signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min) { wr_var.one_signed = signalcomp[i]->edfhdr->edfparam[signalcomp[i]->edfsignal[0]].dig_min; } } else { if(wr_var.one_signed > 32767) { wr_var.one_signed = 32767; } if(wr_var.one_signed < -32768) { wr_var.one_signed = -32768; } } fputc(wr_var.four[0], outputfile); if(fputc(wr_var.four[1], outputfile)==EOF) { QApplication::restoreOverrideCursor(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } else { fputc(null_bytes[i].two[0], outputfile); if(fputc(null_bytes[i].two[1], outputfile)==EOF) { QApplication::restoreOverrideCursor(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while writing to outputfile."); messagewindow.exec(); fclose(outputfile); return; } } smpls_written[i]++; } } } if(edfplus) { tallen = fprintf(outputfile, "+%i.%07i", (int)(taltime / TIME_DIMENSION), (int)(taltime % TIME_DIMENSION)); fputc(20, outputfile); fputc(20, outputfile); fputc(0, outputfile); tallen += 3; if(annotations_left) { if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_ABSOLUT) { annot_difftime = (referencetime - mainwindow->edfheaderlist[annotationlist_nr]->utc_starttime) * TIME_DIMENSION; } if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_OFFSET) { annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION; } if((mainwindow->viewtime_sync==VIEWTIME_UNSYNCED) || (mainwindow->viewtime_sync==VIEWTIME_USER_DEF_SYNCED)) { annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION; annot_difftime += (mainwindow->edfheaderlist[annotationlist_nr]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime); } if(annotationlist_nr != mainwindow->sel_viewtime) { annot_difftime -= mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset; annot_difftime += mainwindow->edfheaderlist[annotationlist_nr]->starttime_offset; } } while(annotations_left) { while(!annotations_pntr) { annotationlist_nr++; if(annotationlist_nr>=mainwindow->files_open) { annotations_left = 0; annotations_pntr = NULL; break; } annotations_pntr = mainwindow->annotationlist[annotationlist_nr]; if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_ABSOLUT) { annot_difftime = (referencetime - mainwindow->edfheaderlist[annotationlist_nr]->utc_starttime) * TIME_DIMENSION; } if(mainwindow->viewtime_sync==VIEWTIME_SYNCED_OFFSET) { annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION; } if((mainwindow->viewtime_sync==VIEWTIME_UNSYNCED) || (mainwindow->viewtime_sync==VIEWTIME_USER_DEF_SYNCED)) { annot_difftime = (referencetime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->utc_starttime) * TIME_DIMENSION; annot_difftime += (mainwindow->edfheaderlist[annotationlist_nr]->viewtime - mainwindow->edfheaderlist[mainwindow->sel_viewtime]->viewtime); } if(annotationlist_nr != mainwindow->sel_viewtime) { annot_difftime -= mainwindow->edfheaderlist[mainwindow->sel_viewtime]->starttime_offset; annot_difftime += mainwindow->edfheaderlist[annotationlist_nr]->starttime_offset; } } if(!annotations_left) break; if(annotations_pntr) { l_temp = annotations_pntr->onset - annot_difftime; if((l_temp >= 0LL) && (l_temp < (mainwindow->pagetime + TIME_DIMENSION))) { tallen += fprintf(outputfile, "%+i.%07i", (int)(l_temp / TIME_DIMENSION), (int)(l_temp % TIME_DIMENSION)); if(annotations_pntr->duration[0]!=0) { fputc(21, outputfile); tallen++; tallen += fprintf(outputfile, "%s", annotations_pntr->duration); } fputc(20, outputfile); tallen++; tallen += fprintf(outputfile, "%s", annotations_pntr->annotation); fputc(20, outputfile); fputc(0, outputfile); tallen += 2; annotations_pntr = annotations_pntr->next_annotation; break; } else { annotations_pntr = annotations_pntr->next_annotation; continue; } } } for(j=tallen; j<(annot_smp_per_record * 2); j++) { fputc(0, outputfile); } taltime += duration; } } QApplication::restoreOverrideCursor(); fclose(outputfile); }
void UI_ZScoreWindow::startButtonClicked() { int i, datrec_offset, total_datrecs, smpls, smp_per_record, smpls_in_epoch, dftblocksize, fft_outputbufsize, smpls_in_inputbuf, smpls_copied, epochs, f1, f2, f3, f4, power_neg_cnt, power_pos_cnt, progress_steps; double *buf, *fft_inputbuf, *fft_outputbuf, samplefreq, freqstep, power_delta, power_theta, power_alpha, power_beta, power_total, power_neg, power_pos; struct edfhdrblock *hdr; struct signalcompblock *signalcomp; crossoverfreq = crossoverSpinbox->value(); mainwindow->z_score_var.crossoverfreq = crossoverfreq; z_threshold = thresholdSpinbox->value(); mainwindow->z_score_var.z_threshold = z_threshold; zscore_page_len = pagelenSpinbox->value() / 2; mainwindow->z_score_var.zscore_page_len = zscore_page_len * 2; // zscore_error_detection = errordetectionSpinbox->value(); // mainwindow->z_score_var.zscore_error_detection = zscore_error_detection; z_hysteresis = hysteresisSpinbox->value(); mainwindow->z_score_var.z_hysteresis = z_hysteresis; z_hysteresis /= 2.0; signalcomp = mainwindow->signalcomp[signalnr]; hdr = signalcomp->edfhdr; total_datrecs = hdr->datarecords; smp_per_record = hdr->edfparam[signalcomp->edfsignal[0]].smp_per_record; dftblocksize = ((long long)smp_per_record * (ZSCORE_EPOCH_LEN * TIME_DIMENSION)) / hdr->long_data_record_duration; if(dftblocksize < (ZSCORE_EPOCH_LEN * 100)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplerate of selected signal is too low"); messagewindow.exec(); curve1->clear(); return; } smpls_in_epoch = dftblocksize; epochs = (hdr->datarecords * (long long)smp_per_record) / (long long)smpls_in_epoch; samplefreq = (double)smp_per_record / ((double)hdr->long_data_record_duration / TIME_DIMENSION); if(samplefreq < 99.9999999) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Samplefrequency of the selected signal must be at least 100 Hz."); messagewindow.exec(); curve1->clear(); return; } fft_outputbufsize = dftblocksize / 2; freqstep = samplefreq / (double)dftblocksize; if(freqstep > 1.0001) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Frequency bin of FFT is more than 1 Hz."); messagewindow.exec(); curve1->clear(); return; } f2 = crossoverfreq / freqstep; f1 = ZSCORE_F1 / freqstep; f3 = ZSCORE_F3 / freqstep; f4 = ZSCORE_F4 / freqstep; fft_inputbuf = (double *)malloc(sizeof(double) * dftblocksize); if(fft_inputbuf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action."); messagewindow.exec(); curve1->clear(); return; } fft_outputbuf = (double *)calloc(1, sizeof(double) * fft_outputbufsize); if(fft_outputbuf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action."); messagewindow.exec(); curve1->clear(); free(fft_inputbuf); return; } if(zscore_epoch_buf != NULL) { free(zscore_epoch_buf); } zscore_epoch_buf = (double *)calloc(1, sizeof(double) * epochs); if(zscore_epoch_buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action."); messagewindow.exec(); curve1->clear(); free(fft_inputbuf); free(fft_outputbuf); return; } if(zscore_page_buf != NULL) { free(zscore_page_buf); } zscore_page_buf = (double *)calloc(1, sizeof(double) * ((epochs / zscore_page_len) + 1)); if(zscore_page_buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action."); messagewindow.exec(); curve1->clear(); free(fft_inputbuf); free(fft_outputbuf); return; } if(zscore_sleepstage_buf != NULL) { free(zscore_sleepstage_buf); } zscore_sleepstage_buf = (int *)calloc(1, sizeof(int) * ((epochs / zscore_page_len) + 1)); if(zscore_sleepstage_buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action."); messagewindow.exec(); curve1->clear(); free(fft_inputbuf); free(fft_outputbuf); return; } // printf("epochs / zscore_page_len is %i\n", // epochs / zscore_page_len); 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(); curve1->clear(); free(fft_inputbuf); free(fft_outputbuf); return; } cfg = kiss_fftr_alloc(dftblocksize, 0, NULL, NULL); FilteredBlockReadClass blockread; buf = blockread.init_signalcomp(signalcomp, 1, 0); if(buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Internal error: init_signalcomp()"); messagewindow.exec(); curve1->clear(); free(fft_inputbuf); free(fft_outputbuf); free(cfg); free(kiss_fftbuf); return; } QProgressDialog progress("Processing ...", "Abort", 0, (int)hdr->datarecords, zscore_dialog); progress.setWindowModality(Qt::WindowModal); progress.setMinimumDuration(200); progress_steps = total_datrecs / 100; if(progress_steps < 1) { progress_steps = 1; } if(progress_steps > 50) { progress_steps = 50; } // printf("total_datrecs is %i\n" // "smp_per_record is %i\n" // "dftblocksize is %i\n" // "smpls_in_epoch is %i\n" // "epochs is %i\n" // "samplefreq is %f\n" // "fft_outputbufsize is %i\n" // "freqstep is %f\n" // "f1 is %i\n" // "f2 is %i\n" // "f3 is %i\n" // "f4 is %i\n" // "z_hysteresis is %f\n", // total_datrecs, // smp_per_record, // dftblocksize, // smpls_in_epoch, // epochs, // samplefreq, // fft_outputbufsize, // freqstep, // f1, // f2, // f3, // f4, // z_hysteresis); epoch_cntr = 0; smpls_in_inputbuf = 0; // FILE *test_file1 = fopen("testfile1.dat", "wb"); // if(test_file1 == NULL) // { // printf("error opening file\n"); // return; // } // // FILE *test_file2 = fopen("testfile2.dat", "wb"); // if(test_file2 == NULL) // { // printf("error opening file\n"); // return; // } for(datrec_offset=0; datrec_offset < total_datrecs; datrec_offset++) // for(datrec_offset=0; datrec_offset < 2; datrec_offset++) { // printf("\ndatrec_offset is %i\n", datrec_offset); // printf("smpls_in_inputbuf is %i\n", smpls_in_inputbuf); if(!(datrec_offset % progress_steps)) { progress.setValue(datrec_offset); qApp->processEvents(); if(progress.wasCanceled() == true) { break; } } if(blockread.process_signalcomp(datrec_offset)) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "A read-error occurred."); messagewindow.exec(); curve1->clear(); free(fft_inputbuf); free(fft_outputbuf); free(cfg); free(kiss_fftbuf); return; } smpls = blockread.samples_in_buf(); // fwrite(buf, smpls * sizeof(double), 1, test_file1); // printf("smpls is %i\n", smpls); // for(k=0; k<smpls; k++) // { // printf("%4.4f ", buf[k]); // if((!(k%4)) && k) // { // putchar('\n'); // } // } // putchar('\n'); smpls_copied = 0; while(smpls > 0) { // printf("while(smpls > 0)\n"); if(smpls < (dftblocksize - smpls_in_inputbuf)) { memcpy(fft_inputbuf + smpls_in_inputbuf, buf, smpls * sizeof(double)); // for(j=0; j<smpls; j++) // { // fft_inputbuf[j + smpls_in_inputbuf] = buf[j]; // } // printf("copy:\n"); // for(k=0; k<smpls; k++) // { // printf("%4.4f ", fft_inputbuf[k + smpls_in_inputbuf]); // if((!(k%4)) && k) // { // putchar('\n'); // } // } // putchar('\n'); smpls_in_inputbuf += smpls; smpls = 0; // printf("break\n"); break; } memcpy(fft_inputbuf + smpls_in_inputbuf, buf + smpls_copied, (dftblocksize - smpls_in_inputbuf) * sizeof(double)); // for(j=0; j<(dftblocksize - smpls_in_inputbuf); j++) // { // fft_inputbuf[j + smpls_in_inputbuf] = buf[j + smpls_copied]; // } // printf("smpls_copied is %i\n", smpls_copied); smpls_copied += (dftblocksize - smpls_in_inputbuf); // printf("smpls_copied is %i\n", smpls_copied); smpls -= (dftblocksize - smpls_in_inputbuf); // printf("smpls is %i\n", smpls); smpls_in_inputbuf = 0; // fwrite(fft_inputbuf, dftblocksize * sizeof(double), 1, test_file2); kiss_fftr(cfg, fft_inputbuf, kiss_fftbuf); power_delta = 0.0; power_theta = 0.0; power_alpha = 0.0; power_beta = 0.0; power_total = 0.0; for(i=0; i<fft_outputbufsize; i++) { fft_outputbuf[i] = (((kiss_fftbuf[i].r * kiss_fftbuf[i].r) + (kiss_fftbuf[i].i * kiss_fftbuf[i].i)) / fft_outputbufsize); // if(epoch_cntr == 0) // { // printf("fft_outputbuf[%i] is %.14f\n", i, fft_outputbuf[i]); // } if((i > 0) && (i < f1)) { power_delta += fft_outputbuf[i]; } if((i >= f1) && (i < f2)) { power_theta += fft_outputbuf[i]; } if((i >= f2) && (i < f3)) { power_alpha += fft_outputbuf[i]; } if((i >= f3) && (i <= f4)) { power_beta += fft_outputbuf[i]; } power_total += fft_outputbuf[i]; } if(power_total <= 0.0) { zscore_epoch_buf[epoch_cntr++] = 0.0; } else { zscore_epoch_buf[epoch_cntr++] = ((power_delta + power_theta) - (power_alpha + power_beta)) / power_total; } // if(epoch_cntr < 3) // { // printf("zscore_epoch_buf[%i] is %f\n", epoch_cntr - 1, zscore_epoch_buf[epoch_cntr - 1]); // printf("power_delta is %f\n" // "power_theta is %f\n" // "power_alpha is %f\n" // "power_beta is %f\n" // "power_total is %f\n\n", // power_delta, power_theta, power_alpha, power_beta, power_total); // } if(epoch_cntr >= epochs) { break; } } if(epoch_cntr >= epochs) { break; } } power_pos = 0.0; power_neg = 0.0; power_pos_cnt = 0; power_neg_cnt = 0; zscore_pages = 0; for(i=0; i<epoch_cntr; i++) { if(i && (!(i % zscore_page_len))) { if(power_neg_cnt) { power_neg /= power_neg_cnt; } if(power_pos_cnt) { power_pos /= power_pos_cnt; } if(power_neg_cnt >= power_pos_cnt) { zscore_page_buf[zscore_pages] = power_neg; zscore_sleepstage_buf[zscore_pages] = 0; } else { zscore_page_buf[zscore_pages] = power_pos; zscore_sleepstage_buf[zscore_pages] = 1; } zscore_pages++; power_pos = 0.0; power_neg = 0.0; power_pos_cnt = 0; power_neg_cnt = 0; } if(zscore_epoch_buf[i] < ZSCORE_ERRORLEVEL) { if(zscore_pages > 0) { if(zscore_sleepstage_buf[zscore_pages - 1] == 0) { // printf("if(zscore_sleepstage_buf[zscore_pages - 1] == 0) : %f < %f + %f\n", // zscore_epoch_buf[i], z_threshold, z_hysteresis); if(zscore_epoch_buf[i] < (z_threshold + z_hysteresis)) { power_neg += zscore_epoch_buf[i]; power_neg_cnt++; } else { power_pos += zscore_epoch_buf[i]; power_pos_cnt++; } } else { // printf("else : %f < %f + %f\n", // zscore_epoch_buf[i], z_threshold, z_hysteresis); if(zscore_epoch_buf[i] < (z_threshold - z_hysteresis)) { power_neg += zscore_epoch_buf[i]; power_neg_cnt++; } else { power_pos += zscore_epoch_buf[i]; power_pos_cnt++; } } } else { if(zscore_epoch_buf[i] < z_threshold) { power_neg += zscore_epoch_buf[i]; power_neg_cnt++; } else { power_pos += zscore_epoch_buf[i]; power_pos_cnt++; } } } } // printf("epoch_cntr is %i zscore_pages is %i\n", // epoch_cntr, zscore_pages); // Delta: 0.5 - 2.0 Hz // Theta: 2.5 - 7.0 Hz // Alpha: 7.5 - 11.5 Hz // Beta: 12.0 - 25.0 Hz // Stage Z ratio (mean +-SD) // ---------------------------- // Wake -0.181 +- .055 // REM 0.156 +- .043 // 1 0.066 +- .101 // 2 0.207 +- .067 // 3 0.443 +- .034 // 4 0.527 +- .039 // ZRatio = ((Delta + Theta) - (Alpha + Beta)) / (Delta + Theta + Alpha + Beta) progress.reset(); RadioButtonsClicked(true); free(fft_inputbuf); free(fft_outputbuf); free(cfg); free(kiss_fftbuf); mainwindow->setup_viewbuf(); // printf("epoch_cntr is %i epochs is %i\n", epoch_cntr, epochs); // fclose(test_file1); // fclose(test_file2); }
void UI_ZScoreWindow::get_annotationsButtonClicked() { int i, awake = 1, filenum, marker_start, marker_end; struct annotationblock *annotation; if((epoch_cntr < 2) || (zscore_pages < 1)) { return; } marker_start = curve1->getMarker1Position() * zscore_pages; if(marker_start < 0) { marker_start = 0; } marker_end = curve1->getMarker2Position() * zscore_pages; if(marker_end > zscore_pages) { marker_end = zscore_pages; } filenum = mainwindow->signalcomp[signalnr]->edfhdr->file_num; for(i=0; i<marker_end; i++) { if(zscore_sleepstage_buf[i] != awake) { awake = zscore_sleepstage_buf[i]; if(i >= marker_start) { annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock)); if(annotation == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred (annotation)."); messagewindow.exec(); return; } annotation->onset = i * zscore_page_len * 2LL * TIME_DIMENSION; if(awake) { strcpy(annotation->annotation, "Wake"); } else { strcpy(annotation->annotation, "Sleep"); } edfplus_annotation_add_item(&mainwindow->annotationlist[filenum], annotation); } } } if(mainwindow->annotations_dock[filenum] == NULL) { mainwindow->annotations_dock[filenum] = new UI_Annotationswindow(filenum, mainwindow); mainwindow->addDockWidget(Qt::RightDockWidgetArea, mainwindow->annotations_dock[filenum]->docklist, Qt::Vertical); if(!mainwindow->annotationlist[filenum]) { mainwindow->annotations_dock[filenum]->docklist->hide(); } } if(mainwindow->annotationlist[filenum]) { mainwindow->annotations_dock[filenum]->docklist->show(); mainwindow->annotations_edited = 1; mainwindow->annotations_dock[filenum]->updateList(); mainwindow->save_act->setEnabled(true); } mainwindow->maincurve->update(); }
void UI_LoadMontagewindow::LoadButtonClicked() { int i, k, n, p, tmp, skip, found, signalcomps_read=0, signals_read, signal_cnt, filters_read, filter_cnt=0, ravg_filter_cnt=0, fidfilter_cnt=0, len, order=1, type=0, model=0, size=0, amp_cat[3], f_ruler_cnt=0; char *result, scratchpad[2048], str[128], *err, *filter_spec, spec_str[256]; double frequency=1.0, frequency2=2.0, ripple=1.0; struct xml_handle *xml_hdl; struct signalcompblock *newsignalcomp; if(mainwindow->files_open==1) n = 0; else n = filelist->currentRow(); if(mtg_path[0]==0) { strcpy(mtg_path, QFileDialog::getOpenFileName(0, "Load montage", QString::fromLocal8Bit(mainwindow->recent_montagedir), "Montage files (*.mtg *.MTG)").toLocal8Bit().data()); if(!strcmp(mtg_path, "")) { return; } get_directory_from_path(mainwindow->recent_montagedir, mtg_path, MAX_PATH_LENGTH); } xml_hdl = xml_get_handle(mtg_path); if(xml_hdl==NULL) { sprintf(scratchpad, "Can not open montage file:\n%s", mtg_path); QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(scratchpad)); messagewindow.exec(); mainwindow->remove_recent_file_mtg_path(mtg_path); return; } if(strcmp(xml_hdl->elementname, PROGRAM_NAME "_montage")) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); xml_close(xml_hdl); return; } //////////////////////////////////////////// for(k=0; k<mainwindow->signalcomps; ) { if(mainwindow->signalcomp[k]->filenum==n) { if(mainwindow->spectrumdock->signalcomp == mainwindow->signalcomp[k]) { mainwindow->spectrumdock->clear(); mainwindow->spectrumdock->dock->hide(); } for(i=0; i<MAXSPECTRUMDIALOGS; i++) { p = mainwindow->signalcomp[k]->spectr_dialog[i]; if(p != 0) { delete mainwindow->spectrumdialog[p - 1]; mainwindow->spectrumdialog[p - 1] = NULL; } } for(i=0; i<MAXAVERAGECURVEDIALOGS; i++) { p = mainwindow->signalcomp[k]->avg_dialog[i]; if(p != 0) { delete mainwindow->averagecurvedialog[p - 1]; mainwindow->averagecurvedialog[p - 1] = NULL; } } if(mainwindow->signalcomp[k]->hascursor2) { /* crosshair_2_active = 0; crosshair_2_moving = 0;*/ } if(mainwindow->signalcomp[k]->hascursor1) { // crosshair_1_active = 0; // crosshair_2_active = 0; // crosshair_1_moving = 0; // crosshair_2_moving = 0; for(i=0; i<mainwindow->signalcomps; i++) { mainwindow->signalcomp[i]->hascursor2 = 0; } } for(i=0; i<mainwindow->signalcomp[k]->filter_cnt; i++) { free(mainwindow->signalcomp[k]->filter[i]); } mainwindow->signalcomp[k]->filter_cnt = 0; for(i=0; i<mainwindow->signalcomp[k]->ravg_filter_cnt; i++) { free_ravg_filter(mainwindow->signalcomp[k]->ravg_filter[i]); } mainwindow->signalcomp[k]->ravg_filter_cnt = 0; for(i=0; i<mainwindow->signalcomp[k]->fidfilter_cnt; i++) { free(mainwindow->signalcomp[k]->fidfilter[i]); fid_run_free(mainwindow->signalcomp[k]->fid_run[i]); fid_run_freebuf(mainwindow->signalcomp[k]->fidbuf[i]); fid_run_freebuf(mainwindow->signalcomp[k]->fidbuf2[i]); } mainwindow->signalcomp[k]->fidfilter_cnt = 0; if(mainwindow->signalcomp[k]->ecg_filter != NULL) { free_ecg_filter(mainwindow->signalcomp[k]->ecg_filter); mainwindow->signalcomp[k]->ecg_filter = NULL; strcpy(mainwindow->signalcomp[k]->signallabel, mainwindow->signalcomp[k]->signallabel_bu); mainwindow->signalcomp[k]->signallabellen = mainwindow->signalcomp[k]->signallabellen_bu; } free(mainwindow->signalcomp[k]); for(i=k; i<mainwindow->signalcomps - 1; i++) { mainwindow->signalcomp[i] = mainwindow->signalcomp[i + 1]; } mainwindow->signalcomps--; k = 0; } else { k++; } } //////////////////////////////////////////// while(1) { skip = 0; xml_goto_root(xml_hdl); signals_read = 0; if(xml_goto_nth_element_inside(xml_hdl, "signalcomposition", signalcomps_read)) { break; } newsignalcomp = (struct signalcompblock *)calloc(1, sizeof(struct signalcompblock)); if(newsignalcomp==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Internal error: Memory allocation error:\n\"new signal composition\""); messagewindow.exec(); xml_close(xml_hdl); return; } if(xml_goto_nth_element_inside(xml_hdl, "num_of_signals", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); signal_cnt = atoi(result); free(result); if((signal_cnt<1)||(signal_cnt>MAXSIGNALS)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } newsignalcomp->edfhdr = mainwindow->edfheaderlist[n]; newsignalcomp->filenum = n; newsignalcomp->num_of_signals = signal_cnt; newsignalcomp->hascursor1 = 0; newsignalcomp->hascursor2 = 0; newsignalcomp->hasoffsettracking = 0; newsignalcomp->hasgaintracking = 0; newsignalcomp->screen_offset = 0; newsignalcomp->filter_cnt = 0; newsignalcomp->ravg_filter_cnt = 0; newsignalcomp->ecg_filter = NULL; newsignalcomp->fidfilter_cnt = 0; newsignalcomp->hasruler = 0; newsignalcomp->polarity = 1; newsignalcomp->type = -1; xml_go_up(xml_hdl); if(!(xml_goto_nth_element_inside(xml_hdl, "alias", 0))) { result = xml_get_content_of_element(xml_hdl); if(result[0] != 0) { strncpy(newsignalcomp->alias, result, 16); newsignalcomp->alias[16] = 0; latin1_to_ascii(newsignalcomp->alias, 16); remove_trailing_spaces(newsignalcomp->alias); remove_leading_spaces(newsignalcomp->alias); } free(result); xml_go_up(xml_hdl); } if(xml_goto_nth_element_inside(xml_hdl, "voltpercm", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); newsignalcomp->voltpercm = atof(result); if(newsignalcomp->voltpercm==0.0) newsignalcomp->voltpercm = 0.000000001; free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "screen_offset", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); newsignalcomp->screen_offset = atof(result); free(result); xml_go_up(xml_hdl); if(!(xml_goto_nth_element_inside(xml_hdl, "polarity", 0))) { result = xml_get_content_of_element(xml_hdl); newsignalcomp->polarity = atoi(result); if(newsignalcomp->polarity != -1) { newsignalcomp->polarity = 1; } free(result); xml_go_up(xml_hdl); } if(xml_goto_nth_element_inside(xml_hdl, "color", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); newsignalcomp->color = atoi(result); if((newsignalcomp->color < 2) || (newsignalcomp->color > 18)) { newsignalcomp->color = 2; } free(result); xml_go_up(xml_hdl); if(!(xml_goto_nth_element_inside(xml_hdl, "filter_cnt", 0))) { result = xml_get_content_of_element(xml_hdl); filter_cnt = atoi(result); if(filter_cnt < 0) filter_cnt = 0; if(filter_cnt > MAXFILTERS) filter_cnt = MAXFILTERS; free(result); xml_go_up(xml_hdl); } if(!(xml_goto_nth_element_inside(xml_hdl, "ravg_filter_cnt", 0))) { result = xml_get_content_of_element(xml_hdl); ravg_filter_cnt = atoi(result); if(ravg_filter_cnt < 0) filter_cnt = 0; if(ravg_filter_cnt > MAXFILTERS) ravg_filter_cnt = MAXFILTERS; free(result); xml_go_up(xml_hdl); } if(filter_cnt) { fidfilter_cnt = 0; } else { if(!(xml_goto_nth_element_inside(xml_hdl, "fidfilter_cnt", 0))) { result = xml_get_content_of_element(xml_hdl); fidfilter_cnt = atoi(result); if(fidfilter_cnt < 0) fidfilter_cnt = 0; if(fidfilter_cnt > MAXFILTERS) fidfilter_cnt = MAXFILTERS; free(result); xml_go_up(xml_hdl); } } for(signals_read=0; signals_read<signal_cnt; signals_read++) { if(xml_goto_nth_element_inside(xml_hdl, "signal", signals_read)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(xml_goto_nth_element_inside(xml_hdl, "factor", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); newsignalcomp->factor[signals_read] = atoi(result); if(newsignalcomp->factor[signals_read] < -128) { newsignalcomp->factor[signals_read] = -128; } if(newsignalcomp->factor[signals_read] > 128) { newsignalcomp->factor[signals_read] = 128; } if(newsignalcomp->factor[signals_read] == 0) { newsignalcomp->factor[signals_read] = 1; } free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "edfindex", 0)) { if(xml_goto_nth_element_inside(xml_hdl, "label", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); remove_trailing_spaces(result); found = 0; for(i=0; i<newsignalcomp->edfhdr->edfsignals; i++) { strcpy(scratchpad, newsignalcomp->edfhdr->edfparam[i].label); remove_trailing_spaces(scratchpad); if(!strcmp(scratchpad, result)) { newsignalcomp->edfsignal[signals_read] = i; if(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].annotation) { found = 0; } else { found = 1; } break; } } } else { result = xml_get_content_of_element(xml_hdl); newsignalcomp->edfsignal[signals_read] = atoi(result); if((newsignalcomp->edfsignal[signals_read] < 0) || (newsignalcomp->edfsignal[signals_read] >= newsignalcomp->edfhdr->edfsignals)) { found = 0; } else { if(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].annotation) { found = 0; } else { found = 1; } } } free(result); if(!found) { free(newsignalcomp); skip = 1; signalcomps_read++; xml_go_up(xml_hdl); xml_go_up(xml_hdl); break; } if(signals_read) { if(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].smp_per_record != newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record) { free(newsignalcomp); skip = 1; signalcomps_read++; xml_go_up(xml_hdl); xml_go_up(xml_hdl); break; } } newsignalcomp->sensitivity[signals_read] = newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].bitvalue / (newsignalcomp->voltpercm * mainwindow->pixelsizefactor); if(!signals_read) { newsignalcomp->signallabel[0] = 0; } if(signal_cnt>1) { if(newsignalcomp->factor[signals_read]<0) { strcat(newsignalcomp->signallabel, "- "); } else { if(signals_read) { strcat(newsignalcomp->signallabel, "+ "); } } } strcpy(str, newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[signals_read]].label); strip_types_from_label(str); strcat(newsignalcomp->signallabel, str); strcat(newsignalcomp->signallabel, " "); len = strlen(newsignalcomp->signallabel); for(k=(len-1); k>0; k--) { if(newsignalcomp->signallabel[k]!=' ') break; } newsignalcomp->signallabel[k+2] = 0; newsignalcomp->file_duration = newsignalcomp->edfhdr->long_data_record_duration * newsignalcomp->edfhdr->datarecords; newsignalcomp->signallabellen = strlen(newsignalcomp->signallabel); xml_go_up(xml_hdl); xml_go_up(xml_hdl); } if(skip) continue; strcpy(newsignalcomp->physdimension, newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].physdimension); remove_trailing_spaces(newsignalcomp->physdimension); for(filters_read=0; filters_read<filter_cnt; filters_read++) { if(xml_goto_nth_element_inside(xml_hdl, "filter", filters_read)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(xml_goto_nth_element_inside(xml_hdl, "LPF", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); type = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "frequency", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); frequency = atof(result); free(result); if((type < 0) || (type > 1) || (frequency < 0.0001)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (filter values)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(frequency >= ((newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record / newsignalcomp->edfhdr->data_record_duration) / 2.0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The frequency of the filter(s) must be less than: samplerate / 2"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(type == 0) { sprintf(spec_str, "HpBu1/%f", frequency); } if(type == 1) { sprintf(spec_str, "LpBu1/%f", frequency); } filter_spec = spec_str; err = fid_parse(((double)(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record)) / newsignalcomp->edfhdr->data_record_duration, &filter_spec, &newsignalcomp->fidfilter[filters_read]); if(err != NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", err); messagewindow.exec(); free(err); free(newsignalcomp); xml_close(xml_hdl); return; } newsignalcomp->fid_run[filters_read] = fid_run_new(newsignalcomp->fidfilter[filters_read], &newsignalcomp->fidfuncp[filters_read]); newsignalcomp->fidbuf[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]); newsignalcomp->fidbuf2[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]); newsignalcomp->fidfilter_freq[filters_read] = frequency; newsignalcomp->fidfilter_freq2[filters_read] = frequency * 1.12; newsignalcomp->fidfilter_ripple[filters_read] = -1.0; newsignalcomp->fidfilter_order[filters_read] = 1; newsignalcomp->fidfilter_type[filters_read] = type; newsignalcomp->fidfilter_model[filters_read] = 0; newsignalcomp->fidfilter_setup[filters_read] = 1; newsignalcomp->fidfilter_cnt = filters_read + 1; xml_go_up(xml_hdl); xml_go_up(xml_hdl); } for(filters_read=0; filters_read<ravg_filter_cnt; filters_read++) { if(xml_goto_nth_element_inside(xml_hdl, "ravg_filter", filters_read)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(xml_goto_nth_element_inside(xml_hdl, "type", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); type = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "size", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); size = atoi(result); free(result); if((type < 0) || (type > 1) || (size < 2) || (size > 10000)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (ravg_filter values)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } newsignalcomp->ravg_filter[filters_read] = create_ravg_filter(type, size); if(newsignalcomp->ravg_filter[filters_read] == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred when creating an ravg filter."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } newsignalcomp->ravg_filter_size[filters_read] = size; newsignalcomp->ravg_filter_type[filters_read] = type; newsignalcomp->ravg_filter_cnt = filters_read + 1; xml_go_up(xml_hdl); xml_go_up(xml_hdl); } for(filters_read=0; filters_read<fidfilter_cnt; filters_read++) { if(xml_goto_nth_element_inside(xml_hdl, "fidfilter", filters_read)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (fidfilter)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(xml_goto_nth_element_inside(xml_hdl, "type", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (type)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); type = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "model", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (model)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); model = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "frequency", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (frequency)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); frequency = atof(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "frequency2", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (frequency2)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); frequency2 = atof(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "ripple", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (ripple)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); ripple = atof(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "order", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (order)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); order = atoi(result); free(result); if((model < 0) || (model > 2) || (order < 1) || (order > 100) || (type < 0) || (type > 4) || (ripple < (-6.0)) || (ripple > (-0.1)) || (frequency < 0.0001) || (frequency2 < 0.0001)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file. (fidfilter values)"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(frequency >= ((newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record / newsignalcomp->edfhdr->data_record_duration) / 2.0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The frequency of the filter(s) must be less than: samplerate / 2"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } if(type > 2) { if(frequency2 >= ((newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record / newsignalcomp->edfhdr->data_record_duration) / 2.0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The frequency of the filter(s) must be less than: samplerate / 2"); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } } if((type == 0) || (type == 1)) { if(order > 8) { order = 8; } } if(type == 0) { if(model == 0) { sprintf(spec_str, "HpBu%i/%f", order, frequency); } if(model == 1) { sprintf(spec_str, "HpCh%i/%f/%f", order, ripple, frequency); } if(model == 2) { sprintf(spec_str, "HpBe%i/%f", order, frequency); } } if(type == 1) { if(model == 0) { sprintf(spec_str, "LpBu%i/%f", order, frequency); } if(model == 1) { sprintf(spec_str, "LpCh%i/%f/%f", order, ripple, frequency); } if(model == 2) { sprintf(spec_str, "LpBe%i/%f", order, frequency); } } if(type == 2) { if(order > 100) { order = 100; } if(order < 3) { order = 3; } if(model == 0) { sprintf(spec_str, "BsRe/%i/%f", order, frequency); } } if((type == 3) || (type == 4)) { if(order < 2) { order = 2; } if(order % 2) { order++; } if(order > 16) { order = 16; } } if(type == 3) { if(model == 0) { sprintf(spec_str, "BpBu%i/%f-%f", order, frequency, frequency2); } if(model == 1) { sprintf(spec_str, "BpCh%i/%f/%f-%f", order, ripple, frequency, frequency2); } if(model == 2) { sprintf(spec_str, "BpBe%i/%f-%f", order, frequency, frequency2); } } if(type == 4) { if(model == 0) { sprintf(spec_str, "BsBu%i/%f-%f", order, frequency, frequency2); } if(model == 1) { sprintf(spec_str, "BsCh%i/%f/%f-%f", order, ripple, frequency, frequency2); } if(model == 2) { sprintf(spec_str, "BsBe%i/%f-%f", order, frequency, frequency2); } } filter_spec = spec_str; err = fid_parse(((double)(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record)) / newsignalcomp->edfhdr->data_record_duration, &filter_spec, &newsignalcomp->fidfilter[filters_read]); if(err != NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", err); messagewindow.exec(); free(err); free(newsignalcomp); xml_close(xml_hdl); return; } newsignalcomp->fid_run[filters_read] = fid_run_new(newsignalcomp->fidfilter[filters_read], &newsignalcomp->fidfuncp[filters_read]); newsignalcomp->fidbuf[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]); newsignalcomp->fidbuf2[filters_read] = fid_run_newbuf(newsignalcomp->fid_run[filters_read]); newsignalcomp->fidfilter_freq[filters_read] = frequency; newsignalcomp->fidfilter_freq2[filters_read] = frequency2; newsignalcomp->fidfilter_ripple[filters_read] = ripple; newsignalcomp->fidfilter_order[filters_read] = order; newsignalcomp->fidfilter_type[filters_read] = type; newsignalcomp->fidfilter_model[filters_read] = model; newsignalcomp->fidfilter_setup[filters_read] = 1; newsignalcomp->fidfilter_cnt = filters_read + 1; xml_go_up(xml_hdl); xml_go_up(xml_hdl); } if(!xml_goto_nth_element_inside(xml_hdl, "ecg_filter", 0)) { if(xml_goto_nth_element_inside(xml_hdl, "type", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); type = atoi(result); free(result); if(type == 1) { newsignalcomp->ecg_filter = create_ecg_filter(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record / newsignalcomp->edfhdr->data_record_duration, newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].bitvalue, mainwindow->powerlinefreq); if(newsignalcomp->ecg_filter == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred when creating an ECG filter."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } strcpy(newsignalcomp->signallabel_bu, newsignalcomp->signallabel); newsignalcomp->signallabellen_bu = newsignalcomp->signallabellen; strcpy(newsignalcomp->signallabel, "HR"); newsignalcomp->signallabellen = strlen(newsignalcomp->signallabel); strcpy(newsignalcomp->physdimension_bu, newsignalcomp->physdimension); strcpy(newsignalcomp->physdimension, "bpm"); } xml_go_up(xml_hdl); xml_go_up(xml_hdl); } if(newsignalcomp->ecg_filter == NULL) { if(!xml_goto_nth_element_inside(xml_hdl, "zratio_filter", 0)) { if(xml_goto_nth_element_inside(xml_hdl, "type", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); type = atoi(result); free(result); xml_go_up(xml_hdl); if(type == 1) { if(xml_goto_nth_element_inside(xml_hdl, "crossoverfreq", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); newsignalcomp->zratio_crossoverfreq = atof(result); free(result); if((newsignalcomp->zratio_crossoverfreq < 5.0) || (newsignalcomp->zratio_crossoverfreq > 9.5)) { newsignalcomp->zratio_crossoverfreq = 7.5; } newsignalcomp->zratio_filter = create_zratio_filter(newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].smp_per_record, newsignalcomp->edfhdr->long_data_record_duration, newsignalcomp->zratio_crossoverfreq, newsignalcomp->edfhdr->edfparam[newsignalcomp->edfsignal[0]].bitvalue); if(newsignalcomp->zratio_filter == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred when creating a Z-ratio filter."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } strcpy(newsignalcomp->signallabel_bu, newsignalcomp->signallabel); newsignalcomp->signallabellen_bu = newsignalcomp->signallabellen; strcpy(newsignalcomp->signallabel, "Z-ratio "); strcat(newsignalcomp->signallabel, newsignalcomp->signallabel_bu); newsignalcomp->signallabellen = strlen(newsignalcomp->signallabel); strcpy(newsignalcomp->physdimension_bu, newsignalcomp->physdimension); strcpy(newsignalcomp->physdimension, ""); xml_go_up(xml_hdl); } xml_go_up(xml_hdl); } } if(f_ruler_cnt == 0) { if(!xml_goto_nth_element_inside(xml_hdl, "floating_ruler", 0)) { if(xml_goto_nth_element_inside(xml_hdl, "hasruler", 0)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this montage file."); messagewindow.exec(); free(newsignalcomp); xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); tmp = atoi(result); free(result); xml_go_up(xml_hdl); if(tmp == 1) { f_ruler_cnt = 1; mainwindow->maincurve->ruler_x_position = 200; mainwindow->maincurve->ruler_y_position = 200; mainwindow->maincurve->floating_ruler_value = 0; if(!xml_goto_nth_element_inside(xml_hdl, "ruler_x_position", 0)) { result = xml_get_content_of_element(xml_hdl); tmp = atoi(result); free(result); if((tmp >= 0) && (tmp < 5000)) { mainwindow->maincurve->ruler_x_position = tmp; } xml_go_up(xml_hdl); } if(!xml_goto_nth_element_inside(xml_hdl, "ruler_y_position", 0)) { result = xml_get_content_of_element(xml_hdl); tmp = atoi(result); free(result); if((tmp >= 0) && (tmp < 5000)) { mainwindow->maincurve->ruler_y_position = tmp; } xml_go_up(xml_hdl); } if(!xml_goto_nth_element_inside(xml_hdl, "floating_ruler_value", 0)) { result = xml_get_content_of_element(xml_hdl); tmp = atoi(result); free(result); if((tmp >= 0) && (tmp < 2)) { mainwindow->maincurve->floating_ruler_value = tmp; } xml_go_up(xml_hdl); } newsignalcomp->hasruler = 1; } xml_go_up(xml_hdl); } } mainwindow->signalcomp[mainwindow->signalcomps] = newsignalcomp; mainwindow->signalcomps++; signalcomps_read++; } xml_goto_root(xml_hdl); if(!(xml_goto_nth_element_inside(xml_hdl, "pagetime", 0))) { result = xml_get_content_of_element(xml_hdl); mainwindow->pagetime = atoll(result); if(mainwindow->pagetime < 10000LL) { mainwindow->pagetime = 10000LL; } free(result); } xml_close(xml_hdl); if(LoadMontageDialog!=NULL) LoadMontageDialog->close(); mainwindow->setMainwindowTitle(mainwindow->edfheaderlist[mainwindow->sel_viewtime]); if(mainwindow->files_open == 1) { strcpy(&mainwindow->recent_file_mtg_path[0][0], mtg_path); } for(i=0; i<3; i++) { amp_cat[i] = 0; } for(i=0; i<mainwindow->signalcomps; i++) { tmp = round_125_cat(mainwindow->signalcomp[i]->voltpercm); switch(tmp) { case 10 : amp_cat[0]++; break; case 20 : amp_cat[1]++; break; case 50 : amp_cat[2]++; break; } } mainwindow->amplitude_doubler = 10; if((amp_cat[1] > amp_cat[0]) && (amp_cat[1] >= amp_cat[2])) { mainwindow->amplitude_doubler = 20; } if((amp_cat[2] > amp_cat[0]) && (amp_cat[2] > amp_cat[1])) { mainwindow->amplitude_doubler = 50; } if(f_ruler_cnt == 1) { mainwindow->maincurve->ruler_active = 1; } mainwindow->setup_viewbuf(); }
void UI_AverageCurveWindow::export_edf(void) { int i, j, k, p, type, edf_hdl, smp_per_record, datarecords, smpls_left; char path[MAX_PATH_LENGTH], str[512]; double *buf, frequency, frequency2; smp_per_record = signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].smp_per_record; datarecords = avg_samples_on_screen / smp_per_record; smpls_left = avg_samples_on_screen % smp_per_record; path[0] = 0; if(mainwindow->recent_savedir[0]!=0) { strcpy(path, mainwindow->recent_savedir); strcat(path, "/"); } get_filename_from_path(path + strlen(path), signalcomp->edfhdr->filename, 512); remove_extension_from_filename(path); sprintf(path + strlen(path), " averaging %s %i triggers [%s]", signalcomp->signallabel, avg_cnt, avg_annotation); if(signalcomp->edfhdr->edf) { strcat(path, ".edf"); strcpy(path, QFileDialog::getSaveFileName(0, "Save as EDF", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data()); } else { strcat(path, ".bdf"); strcpy(path, QFileDialog::getSaveFileName(0, "Save as BDF", QString::fromLocal8Bit(path), "BDF files (*.bdf *.BDF)").toLocal8Bit().data()); } if(!strcmp(path, "")) { return; } get_directory_from_path(mainwindow->recent_savedir, path, MAX_PATH_LENGTH); if(signalcomp->edfhdr->edf) { edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, 1); } else { edf_hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_BDFPLUS, 1); } if(edf_hdl < 0) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open output file for writing."); messagewindow.exec(); return; } edf_set_samplefrequency(edf_hdl, 0, smp_per_record); if(edf_set_datarecord_duration(edf_hdl, signalcomp->edfhdr->long_data_record_duration / 100LL)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Datarecordduration out of range."); messagewindow.exec(); return; } if(signalcomp->edfhdr->edf) { edf_set_digital_maximum(edf_hdl, 0, 32767); edf_set_digital_minimum(edf_hdl, 0, -32768); } else { edf_set_digital_maximum(edf_hdl, 0, 8388607); edf_set_digital_minimum(edf_hdl, 0, -8388608); } edf_set_physical_maximum(edf_hdl, 0, avg_max_value); edf_set_physical_minimum(edf_hdl, 0, avg_min_value); edf_set_label(edf_hdl, 0, signalcomp->signallabel); edf_set_physical_dimension(edf_hdl, 0, signalcomp->physdimension); p = 0; for(j=0; j<signalcomp->fidfilter_cnt; j++) { type = signalcomp->fidfilter_type[j]; frequency = signalcomp->fidfilter_freq[j]; frequency2 = signalcomp->fidfilter_freq2[j]; if(type == 0) { p += sprintf(str + p, "HP:%f", frequency); } if(type == 1) { p += sprintf(str + p, "LP:%f", frequency); } if(type == 2) { p += sprintf(str + p, "N:%f", frequency); } if(type == 3) { p += sprintf(str + p, "BP:%f", frequency); } if(type == 4) { p += sprintf(str + p, "BS:%f", frequency); } for(k=(p-1); k>0; k--) { if(str[k]!='0') break; } if(str[k]=='.') str[k] = 0; else str[k+1] = 0; p = strlen(str); if((type == 3) || (type == 4)) { p += sprintf(str + p, "-%f", frequency2); for(k=(p-1); k>0; k--) { if(str[k]!='0') break; } if(str[k]=='.') str[k] = 0; else str[k+1] = 0; } strcat(str, "Hz "); p = strlen(str); if(p>80) break; } for(j=0; j<signalcomp->ravg_filter_cnt; j++) { if(signalcomp->ravg_filter_type[j] == 0) { p += sprintf(str + p, "HP:%iSmpls ", signalcomp->ravg_filter[j]->size); } if(signalcomp->ravg_filter_type[j] == 1) { p += sprintf(str + p, "LP:%iSmpls ", signalcomp->ravg_filter[j]->size); } p = strlen(str); if(p>80) break; } strcat(str, signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].prefilter); edf_set_prefilter(edf_hdl, 0, str); edf_set_transducer(edf_hdl, 0, signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].transducer); if((signalcomp->edfhdr->edfplus) || (signalcomp->edfhdr->bdfplus)) { edf_set_patientname(edf_hdl, signalcomp->edfhdr->plus_patient_name); sprintf(str, "%i triggers \"%s\" averaged. %s", avg_cnt, avg_annotation, signalcomp->edfhdr->plus_recording_additional); edf_set_recording_additional(edf_hdl, str); edf_set_patientcode(edf_hdl, signalcomp->edfhdr->plus_patientcode); if(signalcomp->edfhdr->plus_gender[0] == 'M') { edf_set_gender(edf_hdl, 1); } if(signalcomp->edfhdr->plus_gender[0] == 'F') { edf_set_gender(edf_hdl, 0); } edf_set_patient_additional(edf_hdl, signalcomp->edfhdr->plus_patient_additional); edf_set_admincode(edf_hdl, signalcomp->edfhdr->plus_admincode); edf_set_technician(edf_hdl, signalcomp->edfhdr->plus_technician); edf_set_equipment(edf_hdl, signalcomp->edfhdr->plus_equipment); } else { edf_set_patientname(edf_hdl, signalcomp->edfhdr->patient); sprintf(str, "%i triggers \"%s\" averaged. %s", avg_cnt, avg_annotation, signalcomp->edfhdr->recording); edf_set_recording_additional(edf_hdl, str); } for(i=0; i<datarecords; i++) { edfwrite_physical_samples(edf_hdl, avgbuf + (i * smp_per_record)); } if(smpls_left) { buf = (double *)calloc(1, smp_per_record * sizeof(double)); if(buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error (buf)."); messagewindow.exec(); } else { for(i=0; i<smpls_left; i++) { buf[i] = avgbuf[(datarecords * smp_per_record) + i]; } edfwrite_physical_samples(edf_hdl, buf); free(buf); } } edfwrite_annotation_latin1(edf_hdl, (avg_period * 10000.0) / (double)avg_trigger_position_ratio, -1, avg_annotation); edfclose_file(edf_hdl); }
void UI_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_BDF2EDFwindow::showpopupmessage(const char *str1, const char *str2) { QMessageBox messagewindow(QMessageBox::NoIcon, str1, str2); messagewindow.exec(); }
void UI_ZScoreWindow::addTraceButtonClicked() { int i; struct edfhdrblock *hdr; struct signalcompblock *signalcomp, *original_signalcomp; original_signalcomp = mainwindow->signalcomp[signalnr]; hdr = original_signalcomp->edfhdr; if(original_signalcomp->ecg_filter != NULL) { return; } if(original_signalcomp->zratio_filter != NULL) { return; } signalcomp = mainwindow->create_signalcomp_copy(original_signalcomp); if(signalcomp == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Internal error: can not create a signalcomp copy."); messagewindow.exec(); return; } signalcomp->zratio_filter = create_zratio_filter(hdr->edfparam[signalcomp->edfsignal[0]].smp_per_record, hdr->long_data_record_duration, crossoverSpinbox->value(), signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue); if(signalcomp->zratio_filter == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not create a Z-ratio-filter, malloc() error?"); messagewindow.exec(); free(signalcomp); return; } strcpy(signalcomp->signallabel_bu, signalcomp->signallabel); signalcomp->signallabellen_bu = signalcomp->signallabellen; strcpy(signalcomp->signallabel, "Z-ratio "); strcat(signalcomp->signallabel, signalcomp->signallabel_bu); signalcomp->signallabellen = strlen(signalcomp->signallabel); strcpy(signalcomp->physdimension_bu, signalcomp->physdimension); strcpy(signalcomp->physdimension, ""); signalcomp->polarity = -1; if(signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue < 0.0) { for(i=0; i<signalcomp->num_of_signals; i++) { signalcomp->sensitivity[i] = signalcomp->edfhdr->edfparam[signalcomp->edfsignal[i]].bitvalue / -1.0 / mainwindow->pixelsizefactor; } signalcomp->voltpercm = -1.0; } else { for(i=0; i<signalcomp->num_of_signals; i++) { signalcomp->sensitivity[i] = signalcomp->edfhdr->edfparam[signalcomp->edfsignal[i]].bitvalue / 1.0 / mainwindow->pixelsizefactor; } signalcomp->voltpercm = 1.0; } signalcomp->zratio_crossoverfreq = crossoverSpinbox->value(); signalcomp->screen_offset = 0.0; mainwindow->setup_viewbuf(); }
void UI_RAW2EDFapp::gobuttonpressed() { int i, j, k, r, hdl, chns, sf, *buf, datarecords, tmp, straightbinary, samplesize, skipblocksize, skipbytes, skipblockcntr, bytecntr; char str[256], path[MAX_PATH_LENGTH]; double phys_max; long long d_offset; FILE *inputfile; sf = SamplefreqSpinbox->value(); raw2edf_var->sf = sf; chns = SignalsSpinbox->value(); raw2edf_var->chns = chns; phys_max = PhysicalMaximumSpinbox->value(); raw2edf_var->phys_max = phys_max; straightbinary = EncodingCombobox->currentIndex(); raw2edf_var->straightbinary = straightbinary; samplesize = SampleSizeSpinbox->value(); raw2edf_var->samplesize = samplesize; d_offset = OffsetSpinbox->value(); raw2edf_var->offset = d_offset; skipblocksize = skipblocksizeSpinbox->value(); raw2edf_var->skipblocksize = skipblocksize; skipbytes = skipbytesSpinbox->value(); raw2edf_var->skipbytes = skipbytes; strcpy(raw2edf_var->phys_dim, PhysicalDimensionLineEdit->text().toLatin1().data()); remove_leading_spaces(raw2edf_var->phys_dim); remove_trailing_spaces(raw2edf_var->phys_dim); if(!(strlen(PatientnameLineEdit->text().toLatin1().data()))) { QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a subjectname."); messagewindow.exec(); return; } if(!(strlen(RecordingLineEdit->text().toLatin1().data()))) { QMessageBox messagewindow(QMessageBox::Critical, "Invalid input", "Please enter a recording description."); messagewindow.exec(); return; } strcpy(path, QFileDialog::getOpenFileName(0, "Open data file", QString::fromLocal8Bit(recent_opendir), "All files (*)").toLocal8Bit().data()); if(!strcmp(path, "")) { return; } get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH); inputfile = fopeno(path, "rb"); if(inputfile==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for reading."); messagewindow.exec(); return; } remove_extension_from_filename(path); strcat(path, ".edf"); hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, chns); if(hdl<0) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for writing.\nedfopen_file_writeonly()"); messagewindow.exec(); fclose(inputfile); return; } for(i=0; i<chns; i++) { if(edf_set_samplefrequency(hdl, i, sf)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_samplefrequency()"); messagewindow.exec(); fclose(inputfile); return; } } if(samplesize == 2) { for(i=0; i<chns; i++) { if(edf_set_digital_maximum(hdl, i, 32767)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_maximum()"); messagewindow.exec(); fclose(inputfile); return; } } for(i=0; i<chns; i++) { if(edf_set_digital_minimum(hdl, i, -32768)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_minimum()"); messagewindow.exec(); fclose(inputfile); return; } } } if(samplesize == 1) { for(i=0; i<chns; i++) { if(edf_set_digital_maximum(hdl, i, 255)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_maximum()"); messagewindow.exec(); fclose(inputfile); return; } } for(i=0; i<chns; i++) { if(edf_set_digital_minimum(hdl, i, -256)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_digital_minimum()"); messagewindow.exec(); fclose(inputfile); return; } } } for(i=0; i<chns; i++) { if(edf_set_physical_maximum(hdl, i, phys_max)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_maximum()"); messagewindow.exec(); fclose(inputfile); return; } } for(i=0; i<chns; i++) { if(edf_set_physical_minimum(hdl, i, -phys_max)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_minimum()"); messagewindow.exec(); fclose(inputfile); return; } } for(i=0; i<chns; i++) { if(edf_set_physical_dimension(hdl, i, raw2edf_var->phys_dim)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_physical_dimension()"); messagewindow.exec(); fclose(inputfile); return; } } for(i=0; i<chns; i++) { sprintf(str, "ch. %i", i + 1); if(edf_set_label(hdl, i, str)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_label()"); messagewindow.exec(); fclose(inputfile); return; } } if(edf_set_startdatetime(hdl, StartDatetimeedit->date().year(), StartDatetimeedit->date().month(), StartDatetimeedit->date().day(), StartDatetimeedit->time().hour(), StartDatetimeedit->time().minute(), StartDatetimeedit->time().second())) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "edf_set_startdatetime()"); messagewindow.exec(); fclose(inputfile); edfclose_file(hdl); return; } buf = (int *)malloc(sizeof(int) * sf * chns); if(buf == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "malloc()"); messagewindow.exec(); fclose(inputfile); edfclose_file(hdl); return; } // printf("samplefrequency: %14i Hz\n" // "channels: %14i\n" // "physical maximum: %14.6f uV\n" // "straightbinary: %14i\n" // "samplesize: %14i byte(s)\n" // "offset: %14lli bytes\n" // "skip blocksize: %14i bytes\n" // "skip bytes: %14i bytes\n\n", // sf, // chns, // phys_max, // straightbinary, // samplesize, // d_offset, // skipblocksize, // skipbytes); fseeko(inputfile, d_offset, SEEK_SET); datarecords = 0; union{ int one[1]; signed short two[2]; char four[4]; } var; skipblockcntr = 0; bytecntr = 0; while(1) { for(j=0; j<sf; j++) { for(k=0; k<chns; k++) { // tmp = fgetc(inputfile); // if(tmp == EOF) // { // edfclose_file(hdl); // fclose(inputfile); // free(buf); // return; // } // // tmp += (fgetc(inputfile) * 256); // // buf[j + (k * sf)] = tmp - 32768; if(samplesize == 2) { tmp = fgetc(inputfile); if(tmp == EOF) { edfclose_file(hdl); fclose(inputfile); free(buf); return; } bytecntr++; // printf("1: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr); if(skipblocksize) { if(++skipblockcntr > skipblocksize) { for(r=0; r<skipbytes; r++) { tmp = fgetc(inputfile); if(tmp == EOF) { edfclose_file(hdl); fclose(inputfile); free(buf); return; } // bytecntr++; // printf("2: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr); } skipblockcntr = 1; } } var.four[0] = tmp; } if(samplesize == 1) { var.four[0] = 0; } tmp = fgetc(inputfile); if(tmp == EOF) { edfclose_file(hdl); fclose(inputfile); free(buf); return; } // bytecntr++; // printf("3: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr); if(skipblocksize) { if(++skipblockcntr > skipblocksize) { for(r=0; r<skipbytes; r++) { tmp = fgetc(inputfile); if(tmp == EOF) { edfclose_file(hdl); fclose(inputfile); free(buf); return; } bytecntr++; // printf("4: skipblockcntr is %i tmp is %02X bytecntr is %i\n", skipblockcntr, tmp, bytecntr); } skipblockcntr = 1; } } var.four[1] = tmp; if(straightbinary) { var.two[0] -= 32768; } if(samplesize == 1) { var.two[0] >>= 8; } buf[j + (k * sf)] = var.two[0]; } } if(edf_blockwrite_digital_samples(hdl, buf)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Write error during conversion.\nedf_blockwrite_digital_samples()"); messagewindow.exec(); edfclose_file(hdl); fclose(inputfile); free(buf); return; } datarecords++; // if(datarecords == 1) break; }
int EDF_annotations::get_annotations(int file_num, struct edfhdrblock *edf_hdr, struct annotationblock **annotslist, int read_nk_trigger_signal) { int i, j, k, p, r=0, n, edfsignals, datarecords, recordsize, discontinuous, *annot_ch, nr_annot_chns, max, onset, duration, duration_start, zero, max_tal_ln, error, annots_in_record, annots_in_tal, samplesize=2, nk_triggers_smpls=0, nk_triggers_bufoffset=0, nk_triggers_enabled=0, nk_triggers_channel=0, nk_triggers_cnt=0, sf, progress_steps; unsigned short nk_triggerfields=0, nk_old_triggerfields=0; char *scratchpad, *cnv_buf, *time_in_txt, *duration_in_txt, nk_triggerlabel[16][32]; long long data_record_duration, elapsedtime, time_tmp=0LL, nk_trigger_sample_duration=0LL; FILE *inputfile; struct edfparamblock *edfparam; struct annotationblock *new_annotation=NULL, *temp_annotation; inputfile = edf_hdr->file_hdl; edfsignals = edf_hdr->edfsignals; recordsize = edf_hdr->recordsize; edfparam = edf_hdr->edfparam; nr_annot_chns = edf_hdr->nr_annot_chns; datarecords = edf_hdr->datarecords; data_record_duration = edf_hdr->long_data_record_duration; discontinuous = edf_hdr->discontinuous; annot_ch = edf_hdr->annot_ch; if(edf_hdr->edfplus) { samplesize = 2; } if(edf_hdr->bdfplus) { samplesize = 3; } if((edf_hdr->edfplus) && (read_nk_trigger_signal)) { if(data_record_duration == 1000000LL) { if(check_device(edf_hdr->plus_equipment) == 0) { for(i=0; i<edfsignals; i++) { if(!strcmp(edfparam[i].label, "Events/Markers ")) { sf = edf_hdr->edfparam[i].smp_per_record; error = 1; switch(sf) { case 10 : error = 0; break; case 20 : error = 0; break; case 50 : error = 0; break; case 100 : error = 0; break; } for(j=0; j<edfsignals; j++) { if(edf_hdr->edfparam[j].smp_per_record != sf) { if(!edf_hdr->edfparam[j].annotation) { error = 1; } } } if(edf_hdr->nr_annot_chns != 1) error = 1; if(!error) { nk_triggers_channel = i; nk_triggers_bufoffset = edfparam[nk_triggers_channel].buf_offset; nk_triggers_smpls = edfparam[nk_triggers_channel].smp_per_record; nk_trigger_sample_duration = data_record_duration / (long long)nk_triggers_smpls; strcpy(nk_triggerlabel[0], "CAL mode"); strcpy(nk_triggerlabel[1], "RESET condition"); strcpy(nk_triggerlabel[2], "External mark"); strcpy(nk_triggerlabel[3], "Photo/HV mark"); strcpy(nk_triggerlabel[4], "Remote mark"); strcpy(nk_triggerlabel[5], "HV mark"); strcpy(nk_triggerlabel[6], "DC trigger 9"); strcpy(nk_triggerlabel[7], "DC trigger 10"); strcpy(nk_triggerlabel[8], "DC trigger 11"); strcpy(nk_triggerlabel[9], "DC trigger 12"); strcpy(nk_triggerlabel[10], "DC trigger 13"); strcpy(nk_triggerlabel[11], "DC trigger 14"); strcpy(nk_triggerlabel[12], "DC trigger 15"); strcpy(nk_triggerlabel[13], "DC trigger 16"); strcpy(nk_triggerlabel[14], ""); strcpy(nk_triggerlabel[15], ""); nk_triggers_enabled = 1; edf_hdr->genuine_nk = 1; break; } } } } } } cnv_buf = (char *)calloc(1, recordsize); if(cnv_buf==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Memory allocation error occurred when trying to read annotations.\n(cnv_buf)"); messagewindow.exec(); return(1); } max_tal_ln = 0; for(i=0; i<nr_annot_chns; i++) { if(max_tal_ln<edfparam[annot_ch[i]].smp_per_record * samplesize) max_tal_ln = edfparam[annot_ch[i]].smp_per_record * samplesize; } if(max_tal_ln<128) max_tal_ln = 128; scratchpad = (char *)calloc(1, max_tal_ln + 3); if(scratchpad==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Memory allocation error occurred when trying to read annotations.\n(scratchpad)"); messagewindow.exec(); free(cnv_buf); return(1); } time_in_txt = (char *)calloc(1, max_tal_ln + 3); if(time_in_txt==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Memory allocation error occurred when trying to read annotations.\n(time_in_txt)"); messagewindow.exec(); free(cnv_buf); free(scratchpad); return(1); } duration_in_txt = (char *)calloc(1, max_tal_ln + 3); if(duration_in_txt==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Memory allocation error occurred when trying to read annotations.\n(duration_in_txt)"); messagewindow.exec(); free(cnv_buf); free(scratchpad); free(time_in_txt); return(1); } if(fseeko(inputfile, (long long)((edfsignals + 1) * 256), SEEK_SET)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred when reading inputfile annotations. (fseek())"); messagewindow.exec(); free(cnv_buf); free(scratchpad); free(time_in_txt); free(duration_in_txt); return(2); } QProgressDialog progress("Scanning file for annotations...", "Abort", 0, datarecords); progress.setWindowModality(Qt::WindowModal); progress.setMinimumDuration(200); progress_steps = datarecords / 100; if(progress_steps < 1) { progress_steps = 1; } elapsedtime = 0; for(i=0; i<datarecords; i++) { if(!(i%progress_steps)) { progress.setValue(i); qApp->processEvents(); if(progress.wasCanceled() == true) { edf_hdr->annots_not_read = 1; free(cnv_buf); free(scratchpad); free(time_in_txt); free(duration_in_txt); return(11); } } if(fread(cnv_buf, recordsize, 1, inputfile)!=1) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "An error occurred while reading inputfile annotations. (fread())"); messagewindow.exec(); free(cnv_buf); free(scratchpad); free(time_in_txt); free(duration_in_txt); return(2); } /************** process annotationsignals (if any) **************/ error = 0; for(r=0; r<nr_annot_chns; r++) { n = 0; zero = 0; onset = 0; duration = 0; duration_start = 0; scratchpad[0] = 0; annots_in_tal = 0; annots_in_record = 0; p = edfparam[annot_ch[r]].buf_offset; max = edfparam[annot_ch[r]].smp_per_record * samplesize; /************** process one annotation signal ****************/ if(cnv_buf[p + max - 1]!=0) { error = 5; goto END; } if(!r) /* if it's the first annotation signal, then check */ { /* the timekeeping annotation */ error = 1; for(k=0; k<(max-2); k++) { scratchpad[k] = cnv_buf[p + k]; if(scratchpad[k]==20) { if(cnv_buf[p + k + 1]!=20) { error = 6; goto END; } scratchpad[k] = 0; if(is_onset_number(scratchpad)) { error = 36; goto END; } else { time_tmp = get_long_time(scratchpad); if(i) { if(discontinuous) { if((time_tmp-elapsedtime)<data_record_duration) { error = 4; goto END; } } else { if((time_tmp-elapsedtime)!=data_record_duration) { error = 3; goto END; } } } else { if(time_tmp>=TIME_DIMENSION) { error = 2; goto END; } else { edf_hdr->starttime_offset = time_tmp; } } elapsedtime = time_tmp; error = 0; break; } } } } for(k=0; k<max; k++) { scratchpad[n] = cnv_buf[p + k]; if(!scratchpad[n]) { if(!zero) { if(k) { if(cnv_buf[p + k - 1]!=20) { error = 33; goto END; } } n = 0; onset = 0; duration = 0; duration_start = 0; scratchpad[0] = 0; annots_in_tal = 0; } zero++; continue; } if(zero>1) { error = 34; goto END; } zero = 0; if((scratchpad[n]==20)||(scratchpad[n]==21)) { if(scratchpad[n]==21) { if(duration||duration_start||onset||annots_in_tal) { /* it's not allowed to have multiple duration fields */ error = 35; /* in one TAL or to have a duration field which is */ goto END; /* not immediately behind the onsetfield */ } duration_start = 1; } if((scratchpad[n]==20)&&onset&&(!duration_start)) { if(r||annots_in_record) { if(n >= 0) { new_annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock)); if(new_annotation==NULL) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred while reading annotations."); messagewindow.exec(); free(cnv_buf); free(scratchpad); free(time_in_txt); free(duration_in_txt); return(1); } new_annotation->next_annotation = NULL; new_annotation->file_num = file_num; new_annotation->annotation[0] = 0; if(duration) strcpy(new_annotation->duration, duration_in_txt); else new_annotation->duration[0] = 0; for(j=0; j<n; j++) { if(j==MAX_ANNOTATION_LEN) break; new_annotation->annotation[j] = scratchpad[j]; } new_annotation->annotation[j] = 0; new_annotation->file_num = edf_hdr->file_num; new_annotation->onset = get_long_time(time_in_txt); if(*annotslist!=NULL) { temp_annotation = *annotslist; while(temp_annotation->next_annotation) temp_annotation = temp_annotation->next_annotation; new_annotation->former_annotation = temp_annotation; temp_annotation->next_annotation = new_annotation; } else { new_annotation->former_annotation = NULL; *annotslist = new_annotation; } } } annots_in_tal++; annots_in_record++; n = 0; continue; } if(!onset) { scratchpad[n] = 0; if(is_onset_number(scratchpad)) { error = 36; goto END; } onset = 1; n = 0; strcpy(time_in_txt, scratchpad); continue; } if(duration_start) { scratchpad[n] = 0; if(is_duration_number(scratchpad)) { error = 37; goto END; } for(j=0; j<n; j++) { if(j==15) break; duration_in_txt[j] = scratchpad[j]; if((duration_in_txt[j]<32)||(duration_in_txt[j]>126)) { duration_in_txt[j] = '.'; } } duration_in_txt[j] = 0; duration = 1; duration_start = 0; n = 0; continue; } } n++; } END: /****************** end ************************/ if(error) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not read annotations because there is an EDF or BDF incompatibility in this file.\n" "For more information, run the EDF/BDF compatibility checker in the Tools menu."); messagewindow.exec(); free(cnv_buf); free(scratchpad); free(time_in_txt); free(duration_in_txt); return(9); } } /************** process NK triggers ****************/ if(nk_triggers_enabled) { if(nk_triggers_cnt < 100000) { for(k=0; k<nk_triggers_smpls; k++) { nk_triggerfields = *((unsigned char *)cnv_buf + nk_triggers_bufoffset + (k * 2) + 1); nk_triggerfields <<= 8; nk_triggerfields += *((unsigned char *)cnv_buf + nk_triggers_bufoffset + (k * 2)); for(j=0; j<14; j++) { if((nk_triggerfields & (1 << j)) && (!(nk_old_triggerfields & (1 << j)))) { nk_triggers_cnt++; new_annotation = (struct annotationblock *)calloc(1, sizeof(struct annotationblock)); if(new_annotation==NULL) { progress.reset(); QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred while reading annotations."); messagewindow.exec(); free(cnv_buf); free(scratchpad); free(time_in_txt); free(duration_in_txt); return(1); } new_annotation->file_num = edf_hdr->file_num; new_annotation->next_annotation = NULL; new_annotation->file_num = file_num; strcpy(new_annotation->annotation, nk_triggerlabel[j]); new_annotation->onset = ((long long)i * data_record_duration) + ((long long)k * nk_trigger_sample_duration); new_annotation->onset += edf_hdr->starttime_offset; new_annotation->ident = (1 << ANNOT_ID_NK_TRIGGER); if(*annotslist!=NULL) { temp_annotation = *annotslist; while(temp_annotation->next_annotation) temp_annotation = temp_annotation->next_annotation; new_annotation->former_annotation = temp_annotation; temp_annotation->next_annotation = new_annotation; } else { new_annotation->former_annotation = NULL; *annotslist = new_annotation; } } } nk_old_triggerfields = nk_triggerfields; } } edf_hdr->nk_triggers_read = 1; } } edfplus_annotation_sort(&annotslist[file_num]); progress.reset(); free(cnv_buf); free(scratchpad); free(time_in_txt); free(duration_in_txt); return(0); }
void ColorOptions::saveColorSchemaButtonClicked() { char path[MAX_PATH_LENGTH]; FILE *colorfile; strcpy(path, mainwindow->recent_colordir); strcat(path, "/my_colorscheme.color"); strcpy(path, QFileDialog::getSaveFileName(0, "Save color scheme", QString::fromLocal8Bit(path), "Color scheme files (*.color *.COLOR)").toLocal8Bit().data()); if(!strcmp(path, "")) { return; } if(strlen(path) > 4) { if(strcmp(path + strlen(path) - 6, ".color")) // check if the ending is '.color' { strcat(path, ".color"); // if not : append it to the string. } } get_directory_from_path(mainwindow->recent_colordir, path, MAX_PATH_LENGTH); colorfile = fopen(path, "wb"); if(colorfile == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file for writing."); messagewindow.exec(); return; } fprintf(colorfile, "<?xml version=\"1.0\"?>\n<" PROGRAM_NAME "_colorschema>\n"); fprintf(colorfile, " <backgroundcolor>\n" " <red>%i</red>\n" " <green>%i</green>\n" " <blue>%i</blue>\n" " </backgroundcolor>\n", mainwindow->maincurve->backgroundcolor.red(), mainwindow->maincurve->backgroundcolor.green(), mainwindow->maincurve->backgroundcolor.blue()); fprintf(colorfile, " <small_ruler_color>\n" " <red>%i</red>\n" " <green>%i</green>\n" " <blue>%i</blue>\n" " </small_ruler_color>\n", mainwindow->maincurve->small_ruler_color.red(), mainwindow->maincurve->small_ruler_color.green(), mainwindow->maincurve->small_ruler_color.blue()); fprintf(colorfile, " <big_ruler_color>\n" " <red>%i</red>\n" " <green>%i</green>\n" " <blue>%i</blue>\n" " </big_ruler_color>\n", mainwindow->maincurve->big_ruler_color.red(), mainwindow->maincurve->big_ruler_color.green(), mainwindow->maincurve->big_ruler_color.blue()); fprintf(colorfile, " <mouse_rect_color>\n" " <red>%i</red>\n" " <green>%i</green>\n" " <blue>%i</blue>\n" " </mouse_rect_color>\n", mainwindow->maincurve->mouse_rect_color.red(), mainwindow->maincurve->mouse_rect_color.green(), mainwindow->maincurve->mouse_rect_color.blue()); fprintf(colorfile, " <text_color>\n" " <red>%i</red>\n" " <green>%i</green>\n" " <blue>%i</blue>\n" " </text_color>\n", mainwindow->maincurve->text_color.red(), mainwindow->maincurve->text_color.green(), mainwindow->maincurve->text_color.blue()); fprintf(colorfile, " <baseline_color>\n" " <red>%i</red>\n" " <green>%i</green>\n" " <blue>%i</blue>\n" " </baseline_color>\n", mainwindow->maincurve->baseline_color.red(), mainwindow->maincurve->baseline_color.green(), mainwindow->maincurve->baseline_color.blue()); fprintf(colorfile, " <annot_marker_color>\n" " <red>%i</red>\n" " <green>%i</green>\n" " <blue>%i</blue>\n" " </annot_marker_color>\n", mainwindow->maincurve->annot_marker_color.red(), mainwindow->maincurve->annot_marker_color.green(), mainwindow->maincurve->annot_marker_color.blue()); fprintf(colorfile, " <signal_color>%i</signal_color>\n", mainwindow->maincurve->signal_color); fprintf(colorfile, " <crosshair_1_color>%i</crosshair_1_color>\n", mainwindow->maincurve->crosshair_1.color); fprintf(colorfile, " <crosshair_2_color>%i</crosshair_2_color>\n", mainwindow->maincurve->crosshair_2.color); fprintf(colorfile, " <floating_ruler_color>%i</floating_ruler_color>\n", mainwindow->maincurve->floating_ruler_color); fprintf(colorfile, " <blackwhite_printing>%i</blackwhite_printing>\n", mainwindow->maincurve->blackwhite_printing); fprintf(colorfile, " <show_annot_markers>%i</show_annot_markers>\n", mainwindow->show_annot_markers); fprintf(colorfile, " <show_baselines>%i</show_baselines>\n", mainwindow->show_baselines); fprintf(colorfile, " <clip_to_pane>%i</clip_to_pane>\n", mainwindow->clip_to_pane); fprintf(colorfile, "</" PROGRAM_NAME "_colorschema>\n"); fclose(colorfile); }
void Check_for_updates::replyFinished() { long long int n; char buf[128]; int this_version, latest_version; QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender()); if(reply->error() != QNetworkReply::NoError) { reply->deleteLater(); return; } if(reply->bytesAvailable() < 31) { reply->deleteLater(); return; } n = reply->read(buf, 100); if(n < 31) { reply->deleteLater(); return; } reply->deleteLater(); buf[30] = 0; if(strncmp(buf, "EDFbrowser latest version: ", 27)) { return; } if(is_integer_number(buf + 27)) { return; } latest_version = atoi(buf + 27); if((latest_version < 1) || (latest_version > 1000000)) { return; } sprintf(buf, PROGRAM_VERSION); buf[1] = buf[0]; this_version = atoi(buf + 1); if(this_version >= latest_version) { return; } QMessageBox messagewindow(QMessageBox::Information, "New version available", "A newer version of EDFbrowser is available.\n" "Do you want to download the new version now?", QMessageBox::Yes | QMessageBox::No); if(messagewindow.exec() != QMessageBox::Yes) { return; } QDesktopServices::openUrl(QUrl("http://www.teuniz.net/edfbrowser/")); }
void ColorOptions::loadColorSchemaButtonClicked() { char path[MAX_PATH_LENGTH], scratchpad[2048], *result; struct xml_handle *xml_hdl; strcpy(path, QFileDialog::getOpenFileName(0, "Load colorschema", QString::fromLocal8Bit(mainwindow->recent_colordir), "Montage files (*.color *.COLOR)").toLocal8Bit().data()); if(!strcmp(path, "")) { return; } get_directory_from_path(mainwindow->recent_colordir, path, MAX_PATH_LENGTH); xml_hdl = xml_get_handle(path); if(xml_hdl==NULL) { sprintf(scratchpad, "Can not open colorschema:\n%s", path); QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(scratchpad)); messagewindow.exec(); return; } if(strcmp(xml_hdl->elementname, PROGRAM_NAME "_colorschema")) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "There seems to be an error in this colorschema."); messagewindow.exec(); xml_close(xml_hdl); return; } mainwindow->get_rgbcolor_settings(xml_hdl, "backgroundcolor", 0, &mainwindow->maincurve->backgroundcolor); mainwindow->get_rgbcolor_settings(xml_hdl, "small_ruler_color", 0, &mainwindow->maincurve->small_ruler_color); mainwindow->get_rgbcolor_settings(xml_hdl, "big_ruler_color", 0, &mainwindow->maincurve->big_ruler_color); mainwindow->get_rgbcolor_settings(xml_hdl, "mouse_rect_color", 0, &mainwindow->maincurve->mouse_rect_color); mainwindow->get_rgbcolor_settings(xml_hdl, "text_color", 0, &mainwindow->maincurve->text_color); mainwindow->get_rgbcolor_settings(xml_hdl, "baseline_color", 0, &mainwindow->maincurve->baseline_color); mainwindow->get_rgbcolor_settings(xml_hdl, "annot_marker_color", 0, &mainwindow->maincurve->annot_marker_color); if(xml_goto_nth_element_inside(xml_hdl, "signal_color", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->maincurve->signal_color = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "floating_ruler_color", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->maincurve->floating_ruler_color = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "blackwhite_printing", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->maincurve->blackwhite_printing = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "show_annot_markers", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->show_annot_markers = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "show_baselines", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->show_baselines = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "clip_to_pane", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->clip_to_pane = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "crosshair_1_color", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->maincurve->crosshair_1.color = atoi(result); free(result); xml_go_up(xml_hdl); if(xml_goto_nth_element_inside(xml_hdl, "crosshair_2_color", 0)) { xml_close(xml_hdl); return; } result = xml_get_content_of_element(xml_hdl); if(result==NULL) { xml_close(xml_hdl); return; } mainwindow->maincurve->crosshair_2.color = atoi(result); free(result); xml_close(xml_hdl); update_interface(); }
void UI_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; }
UI_StatisticWindow::UI_StatisticWindow(struct signalcompblock *signalcomp, long long pagetime) { int i, tmp, NN50, pNN50; char stat_str[2048]; double d_tmp, average_bpm, average_rr, sdnn_bpm, sdnn_rr, *buf_bpm, rmssd_rr, *beat_interval_list; StatDialog = new QDialog; StatDialog->setWindowTitle("Statistics"); StatDialog->setModal(true); StatDialog->setAttribute(Qt::WA_DeleteOnClose, true); StatDialog->setWindowFlags(Qt::Window | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint); StatDialog->setWindowIcon(QIcon(":/images/edf.png")); if(signalcomp->ecg_filter != NULL) { StatDialog->setMinimumSize(600, 400); StatDialog->setSizeGripEnabled(true); startSlider = new QSlider; startSlider->setOrientation(Qt::Horizontal); startSlider->setMinimum(0); startSlider->setMaximum(295); startSlider->setValue(0); stopSlider = new QSlider; stopSlider->setOrientation(Qt::Horizontal); stopSlider->setMinimum(5); stopSlider->setMaximum(300); stopSlider->setValue(300); curve1 = new SignalCurve(StatDialog); curve1->setSignalColor(Qt::darkGreen); curve1->setBackgroundColor(Qt::black); curve1->setRasterColor(Qt::gray); curve1->setTraceWidth(0); curve1->setH_label(signalcomp->physdimension); curve1->setLowerLabel("HR (beats/min)"); curve1->setDashBoardEnabled(false); curve1->setUpperLabel1("Distribution"); curve1->setFillSurfaceEnabled(true); vlayout2_1 = new QVBoxLayout; vlayout2_1->setSpacing(20); vlayout2_1->addWidget(curve1); vlayout2_1->addWidget(startSlider); vlayout2_1->addWidget(stopSlider); } else { StatDialog->setMinimumSize(300, 400); StatDialog->setMaximumSize(300, 400); } Label1 = new QLabel(StatDialog); Label1->setAlignment(Qt::AlignLeft | Qt::AlignTop); pushButton1 = new QPushButton(StatDialog); pushButton1->setMinimumSize(100, 25); pushButton1->setText("&Close"); hlayout1_1_1 = new QHBoxLayout; hlayout1_1_1->addWidget(pushButton1); hlayout1_1_1->addStretch(100); vlayout1_1 = new QVBoxLayout; vlayout1_1->setSpacing(20); vlayout1_1->addWidget(Label1); vlayout1_1->addStretch(100); vlayout1_1->addLayout(hlayout1_1_1); hlayout1 = new QHBoxLayout; hlayout1->addLayout(vlayout1_1, 1); if(signalcomp->ecg_filter != NULL) { hlayout1->addLayout(vlayout2_1, 100); } StatDialog->setLayout(hlayout1); QObject::connect(pushButton1, SIGNAL(clicked()), StatDialog, SLOT(close())); for(i=0; i<300; i++) { bpm_distribution[i] = 0; } if(signalcomp->ecg_filter == NULL) { if((signalcomp->stat_cnt < 1) || (pagetime < 10LL)) { if(signalcomp->alias[0] != 0) { sprintf(stat_str, "Signal: %s\n\nSamples: 0\n\nSum: 0 %s\n\nMean: 0 %s\n\nRMS: 0 %s\n\nMRS: 0 %s\n\nZero crossings: 0\n\nFrequency: 0 Hz", signalcomp->alias, signalcomp->physdimension, signalcomp->physdimension, signalcomp->physdimension, signalcomp->physdimension); } else { sprintf(stat_str, "Signal: %s\n\nSamples: 0\n\nSum: 0 %s\n\nMean: 0 %s\n\nRMS: 0 %s\n\nMRS: 0 %s\n\nZero crossings: 0\n\nFrequency: 0 Hz", signalcomp->signallabel, signalcomp->physdimension, signalcomp->physdimension, signalcomp->physdimension, signalcomp->physdimension); } } else { if(signalcomp->alias[0] != 0) { sprintf(stat_str, "Signal: %s\n\nSamples: %i\n\nSum: %f %s\n\nMean: %f %s\n\nRMS: %f %s\n\nMRS: %f %s\n\nZero crossings: %i\n\nFrequency: %f Hz", signalcomp->alias, signalcomp->stat_cnt, signalcomp->stat_sum * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue, signalcomp->physdimension, (signalcomp->stat_sum * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue) / signalcomp->stat_cnt, signalcomp->physdimension, sqrt(signalcomp->stat_sum_sqr / signalcomp->stat_cnt) * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue, signalcomp->physdimension, (signalcomp->stat_sum_rectified / signalcomp->stat_cnt) * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue, signalcomp->physdimension, signalcomp->stat_zero_crossing_cnt, (((double)signalcomp->stat_zero_crossing_cnt / 2.0)) / ((double)pagetime / (double)TIME_DIMENSION) ); } else { sprintf(stat_str, "Signal: %s\n\nSamples: %i\n\nSum: %f %s\n\nMean: %f %s\n\nRMS: %f %s\n\nMRS: %f %s\n\nZero crossings: %i\n\nFrequency: %f Hz", signalcomp->signallabel, signalcomp->stat_cnt, signalcomp->stat_sum * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue, signalcomp->physdimension, (signalcomp->stat_sum * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue) / signalcomp->stat_cnt, signalcomp->physdimension, sqrt(signalcomp->stat_sum_sqr / signalcomp->stat_cnt) * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue, signalcomp->physdimension, (signalcomp->stat_sum_rectified / signalcomp->stat_cnt) * signalcomp->edfhdr->edfparam[signalcomp->edfsignal[0]].bitvalue, signalcomp->physdimension, signalcomp->stat_zero_crossing_cnt, (((double)signalcomp->stat_zero_crossing_cnt / 2.0)) / ((double)pagetime / (double)TIME_DIMENSION) ); } } } else { beat_cnt = ecg_filter_get_beat_cnt(signalcomp->ecg_filter); beat_interval_list = ecg_filter_get_interval_beatlist(signalcomp->ecg_filter); if(beat_cnt < 3) { sprintf(stat_str, "Not enough beats."); } else { average_bpm = 0.0; average_rr = 0.0; sdnn_bpm = 0.0; sdnn_rr = 0.0; rmssd_rr = 0.0; NN50 = 0; buf_bpm = (double *)malloc(sizeof(double) * beat_cnt); if(buf_bpm == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "The system was not able to provide enough resources (memory) to perform the requested action."); messagewindow.exec(); return; } for(i=0; i<beat_cnt; i++) { buf_bpm[i] = 60.0 / beat_interval_list[i]; average_bpm += buf_bpm[i]; average_rr += beat_interval_list[i]; if(i < (beat_cnt - 1)) { d_tmp = (beat_interval_list[i] - beat_interval_list[i + 1]) * 1000.0; rmssd_rr += (d_tmp * d_tmp); if(((beat_interval_list[i] - beat_interval_list[i + 1]) > 0.05 ) || ((beat_interval_list[i + 1] - beat_interval_list[i]) > 0.05 )) { NN50++; } } } average_bpm /= beat_cnt; average_rr /= beat_cnt; rmssd_rr /= beat_cnt; rmssd_rr = sqrt(rmssd_rr); pNN50 = (NN50 * 100) / (beat_cnt - 1); for(i=0; i<beat_cnt; i++) { sdnn_bpm += (buf_bpm[i] - average_bpm) * (buf_bpm[i] - average_bpm); sdnn_rr += (beat_interval_list[i] - average_rr) * (beat_interval_list[i] - average_rr); } sdnn_bpm = sqrt(sdnn_bpm / beat_cnt); sdnn_rr = sqrt(sdnn_rr / beat_cnt); sprintf(stat_str, "Heart Rate\n\n" "Beats: %3i\n\n" "Mean RR: %3i ms\n\n" "SDNN RR: %3i ms\n\n" "RMSSD RR: %3i ms\n\n" "Mean HR: %3.3f bpm\n\n" "SDNN HR: %3.3f bpm\n\n" "NN50: %3i\n\n" "pNN50: %3i %%\n\n", beat_cnt, (int)(average_rr * 1000.0), (int)(sdnn_rr * 1000.0), (int)rmssd_rr, average_bpm, sdnn_bpm, NN50, pNN50); free(buf_bpm); for(i=0; i<beat_cnt; i++) { tmp = 60.0 / beat_interval_list[i]; if((tmp > 0) && (tmp < 301)) { bpm_distribution[tmp-1]++; } } max_val = 1; for(i=0; i<300; i++) { if(bpm_distribution[i] > max_val) { max_val = bpm_distribution[i]; } } for(i=0; i<300; i++) { if(bpm_distribution[i] > (max_val / 70)) { start_ruler = i; break; } } for(i=299; i>=0; i--) { if(bpm_distribution[i] > (max_val / 70)) { end_ruler = i + 1; if(end_ruler > 300) { end_ruler = 300; } break; } } if(start_ruler >= end_ruler) { start_ruler = 0; end_ruler = 300; } startSlider->setValue(start_ruler); stopSlider->setValue(end_ruler); curve1->setH_RulerValues(start_ruler + 1, end_ruler + 1); curve1->drawCurve(bpm_distribution + start_ruler, end_ruler - start_ruler, (int)(max_val * 1.1) + 1, 0.0); QObject::connect(startSlider, SIGNAL(valueChanged(int)), this, SLOT(startSliderMoved(int))); QObject::connect(stopSlider, SIGNAL(valueChanged(int)), this, SLOT(stopSliderMoved(int))); } } Label1->setText(stat_str); StatDialog->exec(); }
void UI_BI98002EDFwindow::SelectFileButton() { int i, j, n, tmp, end_of_file, samplefreq=0, chns = 3, hdl, samplesize=1, bufsize, *buf2, datablocks, blocks_written, checked_modelnumber=0, checked_samplerate=0, checked_recordhours=0, checked_recorddate=0, checked_recordtime=0, startdate_year=0, startdate_month=0, startdate_day=0, starttime_hour=0, starttime_minute=0, starttime_second=0, progress_steps; char path[MAX_PATH_LENGTH], outputfilename[MAX_PATH_LENGTH], str[2048], str2[128], *buf1, tmp2, modelnumber_str[32]; FILE *dcmfile, *evtfile; strcpy(path, QFileDialog::getOpenFileName(0, "Select inputfile", QString::fromLocal8Bit(recent_opendir), "DCM files (*.dcm *.DCM)").toLocal8Bit().data()); if(!strcmp(path, "")) { return; } get_directory_from_path(recent_opendir, path, MAX_PATH_LENGTH); get_filename_from_path(outputfilename, path, MAX_PATH_LENGTH); dcmfile = fopeno(path, "rb"); if(dcmfile==NULL) { snprintf(str, 2048, "Can not open file %s for reading.", path); QMessageBox messagewindow(QMessageBox::Critical, "Error", QString::fromLocal8Bit(str)); messagewindow.exec(); return; } remove_extension_from_filename(path); strcat(path, ".EVT"); evtfile = fopeno(path, "rb"); if(evtfile==NULL) { remove_extension_from_filename(path); strcat(path, ".evt"); evtfile = fopeno(path, "rb"); if(evtfile==NULL) { snprintf(str, 2048, "Can not open file %s for reading.", path); QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); fclose(dcmfile); return; } } /***************** check if the file is valid ******************************/ for(end_of_file=0; end_of_file == 0; ) { for(i=0; i<256; i++) { tmp = fgetc(evtfile); if(tmp == '\n') { break; } if(tmp == EOF) { end_of_file = 1; break; } str[i] = tmp; } str[i] = 0; if(!(strncmp(str, "Sampling Rate=", 14))) { samplefreq = atoi(str + 14); switch(samplefreq) { case 128 : break; case 256 : break; case 512 : break; case 1024 : break; default : QMessageBox messagewindow(QMessageBox::Critical, "Error", "Unknown samplerate."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); return; } checked_samplerate = 1; } if(!(strncmp(str, "Model number=", 13))) { strncpy(modelnumber_str, str + 13, 8); modelnumber_str[8] = 0; if(strcmp(modelnumber_str, "TM SD01G") && strcmp(modelnumber_str, "SD SD02G")) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong modelnumber."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); return; } checked_modelnumber = 1; } if(!(strncmp(str, "Record Date=", 12))) { strncpy(str2, str + 12, 10); str2[10] = 0; startdate_year = atoi(str2); startdate_month = atoi(str2 + 5); startdate_day = atoi(str2 + 8); if((startdate_year < 1970) || (startdate_year > 3000) || (startdate_month < 1) || (startdate_month > 12) || (startdate_day < 1) || (startdate_day > 31)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong record date."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); return; } checked_recorddate = 1; } if(!(strncmp(str, "Record Time=", 12))) { strncpy(str2, str + 12, 10); str2[8] = 0; starttime_hour = atoi(str2); starttime_minute = atoi(str2 + 3); starttime_second = atoi(str2 + 6); if((starttime_hour < 0) || (starttime_hour > 23) || (starttime_minute < 0) || (starttime_minute > 59) || (starttime_second < 0) || (starttime_second > 59)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong recordtime."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); return; } checked_recordtime = 1; } if(!(strncmp(str, "Record Hours=", 13))) { strncpy(str2, str + 13, 10); str2[2] = 0; if((atoi(str2) != 24) && (atoi(str2) != 48)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Wrong record hours."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); return; } checked_recordhours = 1; } } if(!checked_modelnumber || !checked_samplerate || !checked_recordhours || !checked_recorddate || !checked_recordtime) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Missing line."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); return; } /////////////////////////////////////////////////////////////////////////////////// bufsize = chns * samplesize * samplefreq; buf1 = (char *)malloc(bufsize); if(buf1 == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); return; } buf2 = (int *)malloc(bufsize * sizeof(int)); if(buf2 == NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Malloc error."); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); free(buf1); return; } /////////////////////////////////////////////////////////////////////////////////// path[0] = 0; if(recent_savedir[0]!=0) { strcpy(path, recent_savedir); strcat(path, "/"); } strcat(path, outputfilename); remove_extension_from_filename(path); strcat(path, ".edf"); strcpy(path, QFileDialog::getSaveFileName(0, "Select outputfile", QString::fromLocal8Bit(path), "EDF files (*.edf *.EDF)").toLocal8Bit().data()); if(!strcmp(path, "")) { fclose(dcmfile); fclose(evtfile); free(buf1); free(buf2); return; } get_directory_from_path(recent_savedir, path, MAX_PATH_LENGTH); hdl = edfopen_file_writeonly(path, EDFLIB_FILETYPE_EDFPLUS, chns); if(hdl<0) { snprintf(str, 2048, "Can not open file %s for writing.", path); QMessageBox messagewindow(QMessageBox::Critical, "Error", str); messagewindow.exec(); fclose(dcmfile); fclose(evtfile); free(buf1); free(buf2); return; } for(i=0; i<chns; i++) { edf_set_samplefrequency(hdl, i, samplefreq); } for(i=0; i<chns; i++) { edf_set_digital_maximum(hdl, i, 127); } for(i=0; i<chns; i++) { edf_set_digital_minimum(hdl, i, -128); } for(i=0; i<chns; i++) { edf_set_physical_maximum(hdl, i, 2442.307692); } for(i=0; i<chns; i++) { edf_set_physical_minimum(hdl, i, -2461.538462); } for(i=0; i<chns; i++) { edf_set_physical_dimension(hdl, i, "uV"); } edf_set_label(hdl, 0, "channel 1"); edf_set_label(hdl, 1, "channel 2"); edf_set_label(hdl, 2, "channel 3"); edf_set_equipment(hdl, modelnumber_str); edf_set_patientname(hdl, "BI9800"); edf_set_startdatetime(hdl, startdate_year, startdate_month, startdate_day, starttime_hour, starttime_minute, starttime_second); fseeko(dcmfile, 0LL, SEEK_END); datablocks = ftello(dcmfile) / bufsize; fseeko(dcmfile, 0LL, SEEK_SET); QProgressDialog progress("Converting...", "Cancel", 0, datablocks, myobjectDialog); progress.setWindowModality(Qt::WindowModal); progress.setMinimumDuration(200); progress_steps = datablocks / 100; if(progress_steps < 1) { progress_steps = 1; } for(blocks_written=0; ; blocks_written++) { if(!(blocks_written % progress_steps)) { progress.setValue(blocks_written); qApp->processEvents(); if(progress.wasCanceled() == true) { break; } } n = fread(buf1, bufsize, 1, dcmfile); if(n != 1) { break; } for(i=0; i<samplefreq; i++) { for(j=0; j<chns; j++) { tmp2 = buf1[(i * chns) + j] + 128; buf2[(j * samplefreq) + i] = tmp2; } } edf_blockwrite_digital_samples(hdl, buf2); } progress.reset(); edfwrite_annotation_latin1(hdl, 0LL, -1LL, "Recording starts"); fseeko(evtfile, 0LL, SEEK_SET); for(end_of_file=0; end_of_file == 0; ) { for(i=0; i<256; i++) { tmp = fgetc(evtfile); if((tmp == '\n') || (tmp == '\r')) { break; } if(tmp == EOF) { end_of_file = 1; break; } str[i] = tmp; } str[i] = 0; if((isdigit(str[0])) && (isdigit(str[1]))) { starttime_hour = atoi(str); starttime_minute = atoi(str + 3); starttime_second = atoi(str + 6); if((starttime_hour < 0) || (starttime_hour > 23) || (starttime_minute < 0) || (starttime_minute > 59) || (starttime_second < 0) || (starttime_second > 59)) { } else { if(strlen(str) > 9) { edfwrite_annotation_latin1(hdl, (starttime_second + (starttime_minute * 60) + (starttime_hour * 3600)) * 10000, -1, str + 9); } } } } edfwrite_annotation_latin1(hdl, blocks_written * 10000LL, -1LL, "Recording ends"); edfclose_file(hdl); fclose(dcmfile); fclose(evtfile); free(buf1); free(buf2); }
void UI_headerEditorWindow::open_file() { long long filesize; if(file != NULL) { fclose(file); file = NULL; } edf = 0; bdf = 0; edfplus = 0; bdfplus = 0; edfsignals = 0; disconnect(lineEdit3, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &))); disconnect(lineEdit4, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &))); disconnect(lineEdit5, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_name(const QString &))); disconnect(lineEdit6, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); disconnect(lineEdit7, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); disconnect(lineEdit8, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); disconnect(lineEdit9, SIGNAL(textEdited(const QString &)), this, SLOT(calculate_chars_left_recording(const QString &))); lineEdit3->setMaxLength(80); lineEdit4->setMaxLength(80); lineEdit5->setMaxLength(80); lineEdit6->setMaxLength(80); lineEdit7->setMaxLength(80); lineEdit8->setMaxLength(80); lineEdit9->setMaxLength(80); lineEdit1->clear(); lineEdit2->clear(); lineEdit3->clear(); lineEdit4->clear(); lineEdit5->clear(); lineEdit6->clear(); lineEdit7->clear(); lineEdit8->clear(); lineEdit9->clear(); signallist->setRowCount(0); fileNameLabel->clear(); if(hdr==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "A memory allocation error occurred. (hdr)"); messagewindow.exec(); return; } strcpy(path, QFileDialog::getOpenFileName(0, "Open file", QString::fromLocal8Bit(mainwindow->recent_opendir), "EDF/BDF files (*.edf *.EDF *.bdf *.BDF)").toLocal8Bit().data()); if(!strcmp(path, "")) { return; } get_directory_from_path(mainwindow->recent_opendir, path, MAX_PATH_LENGTH); if(mainwindow->file_is_opened(path)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Selected file is in use."); messagewindow.exec(); return; } file = fopeno(path, "r+b"); if(file==NULL) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not open file."); messagewindow.exec(); return; } rewind(file); if(fread(hdr, 256, 1, file) != 1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Can not read from file."); messagewindow.exec(); fclose(file); file = NULL; return; } if(!(strncmp(hdr, "0 ", 8))) edf = 1; if((!(strncmp(hdr + 1, "BIOSEMI", 7))) && (((unsigned char *)hdr)[0] == 255)) { bdf = 1; } if((!edf) && (!bdf)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "File is not a valid EDF or BDF file.\n" "Invalid version."); messagewindow.exec(); fclose(file); file = NULL; return; } edfsignals = antoi(hdr + 252, 4); if(edfsignals < 1) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Invalid number of signals in header (less than 1)"); messagewindow.exec(); fclose(file); file = NULL; return; } if(edfsignals > 2049) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Number of signals in header is more than 2048.\n" "This tool can not process more than 2048 signals."); messagewindow.exec(); fclose(file); file = NULL; return; } fseeko(file, 0LL, SEEK_END); filesize = ftello(file); if(filesize < (((edfsignals + 1LL) * 256LL) + edfsignals)) { QMessageBox messagewindow(QMessageBox::Critical, "Error", "Filesize is too small.\n" "Can not fix this file."); messagewindow.exec(); fclose(file); file = NULL; return; } if((!(strncmp(hdr + 192, "EDF+C", 5))) || (!(strncmp(hdr + 192, "EDF+D", 5)))) { edfplus = 1; } if((!(strncmp(hdr + 192, "BDF+C", 5))) || (!(strncmp(hdr + 192, "BDF+D", 5)))) { bdfplus = 1; } read_header(); }