All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Brief description of class still missing. More...
#include <SignalFileFormat.h>
Brief description of class still missing.
Full description of class still missing
{
Unknown=0,
Seg2,
SuLittleEndian,
SuBigEndian,
Tomo,
RD3,
NiSismo,
SacLittleEndian,
SacBigEndian,
Radan,
Gse2,
City2,
Ascii,
GeopsySignal,
Saf,
MultiGse2,
Sismalp,
Wav,
SegYLittleEndian,
SegYBigEndian,
Temporary,
SyscomXmr,
SyscomSmr,
SyscomVmrx,
GuralpGcf,
AsciiGeoSig,
MiniSeed,
AsciiOneColumn,
PasscalSegYBigEndian,
PasscalSegYLittleEndian,
SegD,
Custom,
Fourier,
FormatCount // Must be the last one, used to count the available file formats
};
| GeopsyCore::SignalFileFormat::SignalFileFormat | ( | Format | f = Unknown, |
| AbstractFileFormat * | customFormat = 0 |
||
| ) |
References QGpCoreTools::SharedObject::addReference(), and customFormat().
{
_id=f;
_customFormat=customFormat;
if(_customFormat) {
_customFormat->addReference();
}
}
References QGpCoreTools::SharedObject::addReference().
{
_id=o._id;
_customFormat=o._customFormat;
if(_customFormat) {
_customFormat->addReference();
}
}
{
if(_customFormat) {
SharedObject::removeReference(_customFormat);
}
}
| QString GeopsyCore::SignalFileFormat::caption | ( | ) | const |
References Ascii, AsciiGeoSig, AsciiOneColumn, City2, Custom, FormatCount, Fourier, GeopsySignal, Gse2, GuralpGcf, MiniSeed, MultiGse2, GeopsyCore::AbstractFileFormat::name(), NiSismo, PasscalSegYBigEndian, PasscalSegYLittleEndian, Radan, RD3, SacBigEndian, SacLittleEndian, Saf, Seg2, SegD, SegYBigEndian, SegYLittleEndian, Sismalp, SuBigEndian, SuLittleEndian, SyscomSmr, SyscomVmrx, SyscomXmr, Temporary, Tomo, QGpCoreTools::tr(), TRACE, Unknown, and Wav.
Referenced by captionFilter(), GeopsyMainWindow::exportSignal(), and importList().
{
TRACE;
switch (_id) {
case Seg2: return tr("SEG-2");
case SegD: return tr("SEG-D");
case SuLittleEndian: return tr("SU Little Endian");
case SuBigEndian: return tr("SU Big Endian");
case Tomo: return tr("Arrival times");
case RD3: return tr("RD3 Ramac");
case NiSismo: return tr("NiSismo");
case SacLittleEndian: return tr("Sac Little Endian");
case SacBigEndian: return tr("Sac Big Endian");
case Radan: return tr("Radan");
case Gse2: return tr("GSE 2.0 Single signal");
case MultiGse2: return tr("GSE 2.0 Multi signals");
case City2: return tr("CityShark 1 or 2");
case Ascii:
if(_customFormat) {
return _customFormat->name();
} else {
return tr("Ascii multi columns (no header)");
}
case AsciiOneColumn: return tr("Ascii one column (no header)");
case GeopsySignal: return tr("Geopsy Signal");
case Saf: return tr("SAF Sesame");
case Sismalp: return tr("Sismalp");
case Wav: return tr("WAVE PCM soundfile");
case SegYLittleEndian: return tr("SEGY Little Endian");
case SegYBigEndian: return tr("SEGY Big Endian");
case PasscalSegYLittleEndian: return tr("PASSCAL SEGY Little Endian");
case PasscalSegYBigEndian: return tr("PASSCAL SEGY Big Endian");
case SyscomXmr: return tr("SYSCOM XMR");
case SyscomSmr: return tr("SYSCOM SMR");
case SyscomVmrx: return tr("SYSCOM VMR/VMX");
case GuralpGcf: return tr("Guralp");
case AsciiGeoSig: return tr("GeoSIG ASCII");
case MiniSeed: return tr("Mini seed");
case Fourier: return tr("Fourier spectrum");
case Custom:
if(_customFormat) {
return _customFormat->name();
}
break;
case Temporary:
case FormatCount:
case Unknown:
break;
};
return tr("Automatic recognition");
}
| QString GeopsyCore::SignalFileFormat::captionFilter | ( | ) | const |
References caption(), filter(), and TRACE.
Referenced by importList(), GeopsyCore::GeopsyPreferences::load(), Preferences::on_fileDefaults_clicked(), and ExportFileType::setFormatList().
| const AbstractFileFormat* GeopsyCore::SignalFileFormat::customFormat | ( | ) | const [inline] |
Referenced by GeopsyCore::SignalFile::load(), GeopsyCore::SubSignalPool::save(), and SignalFileFormat().
{return _customFormat;}
| QString GeopsyCore::SignalFileFormat::filter | ( | ) | const |
References Ascii, AsciiGeoSig, AsciiOneColumn, City2, Custom, GeopsyCore::AbstractFileFormat::extensionFilter(), GeopsyCore::AbstractFileFormat::extensions(), FormatCount, Fourier, GeopsySignal, Gse2, GuralpGcf, MiniSeed, MultiGse2, NiSismo, PasscalSegYBigEndian, PasscalSegYLittleEndian, Radan, RD3, SacBigEndian, SacLittleEndian, Saf, Seg2, SegD, SegYBigEndian, SegYLittleEndian, Sismalp, SuBigEndian, SuLittleEndian, SyscomSmr, SyscomVmrx, SyscomXmr, Temporary, Tomo, TRACE, Unknown, and Wav.
Referenced by captionFilter(), and GeopsyMainWindow::exportSignal().
{
TRACE;
switch (_id) {
case Seg2: return "*.seg2 *.dat *";
case SegD: return "*.segd *";
case SuLittleEndian:
case SuBigEndian:
return "*.su";
case Tomo: return "*.arr *";
case RD3: return "*.rd3";
case Ascii:
case Custom:
if(_customFormat && !_customFormat->extensions().isEmpty()) {
return _customFormat->extensionFilter()+" *";
}
break;
case NiSismo:
case City2:
case AsciiOneColumn:
case GeopsySignal:
case Unknown:
case Temporary:
case FormatCount:
break;
case SacLittleEndian:
case SacBigEndian:
return "*.sac *";
case Radan: return "*.dzt";
case Gse2:
case MultiGse2:
return "*.gse *";
case Saf: return "*.saf *";
case Sismalp: return "*.ndx *.sis";
case Wav: return "*.wav";
case SegYLittleEndian:
case SegYBigEndian:
case PasscalSegYLittleEndian:
case PasscalSegYBigEndian:
return "*.segy *.sgy";
case SyscomXmr: return "*.xmr";
case SyscomSmr: return "*.smr";
case SyscomVmrx: return "*.vmr *.vmx";
case GuralpGcf: return "*.gcf *";
case AsciiGeoSig: return "*.txt *";
case MiniSeed: return "*.mseed *.msd *";
case Fourier: return "*.fourier";
};
return "*";
}
| SignalFileFormat GeopsyCore::SignalFileFormat::fromContent | ( | QString | fileName | ) | [static] |
Get file format from an existing file. Two methods are used:
References Ascii, AsciiGeoSig, City2, GeopsyCore::GeopsyCoreEngine::customFileFormats(), GeopsyCore::SACHeader::determineByteOrder(), GeopsyCore::PasscalSegYHeader::determineByteOrder(), GeopsyCore::SEGYTraceHeader::determineByteOrderSEGY(), GeopsyCore::SEGYTraceHeader::determineByteOrderSU(), QGpCoreTools::endl(), GeopsyCore::CustomFileFormats::fromContent(), fromSuffix(), GeopsyCore::geopsyCore, GeopsySignal, GEOPSYSIGNAL_HEADERSIZE, GuralpGcf, id(), GeopsyCore::GuralpCompressedBlock::isData(), GeopsyCore::MiniSeedVolume::isValid(), GeopsyCore::GeopsySignalHeader::isValid(), MiniSeed, MultiGse2, NiSismo, GeopsyCore::GeopsySignalHeader::raw, GeopsyCore::GuralpCompressedBlock::readBody(), GeopsyCore::GuralpCompressedBlock::readHeader(), Saf, Seg2, str, Tomo, QGpCoreTools::tr(), TRACE, Unknown, and Wav.
Referenced by GeopsyCore::SignalFilePool::load().
{
TRACE;
SignalFileFormat fmt;
// First, fast determination from extension
fmt=fromSuffix(fileName, false);
if(fmt.id()!=Unknown) return fmt;
// Test file content
QFile f(fileName);
if(!f.open(QIODevice::ReadOnly)) {
App::stream() << tr("Determining format: cannot open file %1").arg(fileName) << endl;
return Unknown;
}
// Test DBSignal format
GeopsySignalHeader h;
QDataStream sd(&f);
sd.readRawData(h.raw, GEOPSYSIGNAL_HEADERSIZE);
App::freezeStream(true);
bool ret=h.isValid();
App::freezeStream(false);
if(ret) return GeopsySignal;
f.seek(0); // reset to begin of file
// Other formats
QTextStream st(&f);
QString str=st.readLine();
if(str.indexOf( "Arrival_times_file" ) > -1) {
return Tomo;
}
if(( str[ 0 ]==0x55) && (str[ 1 ]==0x3A) ) {
return Seg2;
}
if(str.indexOf( "f_n" ) > -1) {
return NiSismo;
}
if(str.left(4)=="WID2" ) {
return MultiGse2;
}
if(str.left(18)=="Original file name" ) {
return City2;
}
if(str.left(35)=="SESAME ASCII data format (saf) v. 1" ) {
return Saf;
}
if(str.left(4)=="RIFF" ) {
return Wav;
}
if(str.left(12)=="Station_code" ) {
return AsciiGeoSig;
}
// Test simple multi-column ascii file without header
bool ok;
while(str[0]=='#') {
str=st.readLine();
}
QString field=str.trimmed().simplified().section(QRegExp( "[ \t]" ), 0, 0);
field.toDouble(&ok);
if(ok) return Ascii;
f.seek(0); // reset to begin of file
// Testing Guralp format
App::freezeStream(true);
GuralpCompressedBlock b;
while(!f.atEnd()) {
if(!b.readHeader(f)) {
break;
}
if(b.isData()) {
if(b.readBody(f)) {
return GuralpGcf;
}
}
}
App::freezeStream(false);
f.close();
// Test if SAC format
fmt=SACHeader::determineByteOrder(fileName);
if(fmt.id()!=Unknown) return fmt;
// Testing mini seed
if(MiniSeedVolume::isValid(fileName)) return MiniSeed;
// Testing PASSCAL SEGY (before SU because it is more strict)
fmt=PasscalSegYHeader::determineByteOrder(fileName);
if(fmt.id()!=Unknown) return fmt;
// Testing SU
fmt=SEGYTraceHeader::determineByteOrderSU(fileName);
if(fmt.id()!=Unknown) return fmt;
// Testing SEGY
fmt=SEGYTraceHeader::determineByteOrderSEGY(fileName);
if(fmt.id()!=Unknown) return fmt;
// User custom formats
fmt=geopsyCore->customFileFormats()->fromContent(fileName);
if(fmt.id()!=Unknown) return fmt;
return Unknown;
}
| SignalFileFormat GeopsyCore::SignalFileFormat::fromString | ( | QString | f | ) | [static] |
References Ascii, AsciiGeoSig, AsciiOneColumn, City2, GeopsyCore::GeopsyCoreEngine::customFileFormats(), GeopsyCore::CustomFileFormats::fromString(), GeopsyCore::geopsyCore, GeopsySignal, Gse2, GuralpGcf, MiniSeed, MultiGse2, NiSismo, Radan, RD3, SacBigEndian, SacLittleEndian, Saf, Seg2, SegYBigEndian, SegYLittleEndian, Sismalp, SuBigEndian, SuLittleEndian, SyscomSmr, SyscomVmrx, SyscomXmr, Temporary, Tomo, TRACE, Unknown, and Wav.
Referenced by GeopsyCore::SignalFile::setFormat().
{
TRACE;
if(f.length()<3) return Unknown;
f=f.toLower();
switch (f[0].unicode()) {
case 'a':
if(f.startsWith("ascii")) {
if(f=="asciigeosig") return AsciiGeoSig;
else if(f=="ascii") return Ascii;
else if(f=="asciionecolumn") return AsciiOneColumn;
else return geopsyCore->customFileFormats()->fromString(f);
}
break;
case 'c':
if(f=="city2") return City2;
break;
case 'g':
if(f=="gse2") return Gse2;
else if(f=="geopsysignal") return GeopsySignal;
else if(f=="guralpgcf") return GuralpGcf;
break;
case 'm':
if(f=="multigse2") return MultiGse2;
else if(f=="miniseed") return MiniSeed;
break;
case 'n':
if(f=="nisismo") return NiSismo;
break;
case 'r':
if(f=="rd3") return RD3;
else if(f=="radan") return Radan;
break;
case 's':
switch (f[2].unicode()) {
case 'f':
if(f=="saf") return Saf;
break;
case 'l':
if(f=="sulittleendian") return SuLittleEndian;
break;
case 'b':
if(f=="subigendian") return SuBigEndian;
case 'c':
if(f=="saclittleendian") return SacLittleEndian;
else if(f=="sacbigendian") return SacBigEndian;
break;
case 'g':
if(f=="seg2") return Seg2;
else if(f=="segylittleendian") return SegYLittleEndian;
else if(f=="segybigendian") return SegYBigEndian;
break;
case 's':
if(f=="sismalp") return Sismalp;
else if(f=="syscomxmr") return SyscomXmr;
else if(f=="syscomsmr") return SyscomSmr;
else if(f=="syscomvmrx") return SyscomVmrx;
break;
default:
break;
}
break;
case 't':
if(f=="tomo") return Tomo;
else if(f=="temporary") return Temporary;
break;
case 'u':
if(f=="unknown") return Unknown;
break;
case 'w':
if(f=="wav") return Wav;
break;
default:
break;
}
return geopsyCore->customFileFormats()->fromString(f);
}
| SignalFileFormat GeopsyCore::SignalFileFormat::fromSuffix | ( | QString | fileName, |
| bool | defaultEndianess = true |
||
| ) | [static] |
Get file format from a non-existing file, only from extension. For format that can be Big or Little endian, if defaultEndianess is false, the file content is checked.
References Ascii, GeopsyCore::GeopsyCoreEngine::customFileFormats(), GeopsyCore::SACHeader::determineByteOrder(), GeopsyCore::PasscalSegYHeader::determineByteOrder(), GeopsyCore::SEGYTraceHeader::determineByteOrderSEGY(), GeopsyCore::SEGYTraceHeader::determineByteOrderSU(), Fourier, GeopsyCore::CustomFileFormats::fromExtension(), GeopsyCore::geopsyCore, GuralpGcf, id(), MiniSeed, MultiGse2, Radan, RD3, SacBigEndian, SacLittleEndian, Saf, Seg2, SegD, SegYBigEndian, SegYLittleEndian, Sismalp, SuBigEndian, SuLittleEndian, SyscomSmr, SyscomVmrx, SyscomXmr, Tomo, TRACE, Unknown, and Wav.
Referenced by fromContent(), and GeopsyCore::SubSignalPool::save().
{
TRACE;
QFileInfo finfo(fileName);
QString ext=finfo.suffix().toLower();
if(!ext.isEmpty()) {
switch(ext[0].unicode()) {
case 'a':
if(ext=="arr" ) {
return Tomo;
}
break;
case 'd':
if(ext=="dzt" ) {
return Radan;
}
break;
case 'f':
if(ext=="fourier" ) {
return Fourier;
}
break;
case 'g':
if(ext== "gse") {
return MultiGse2;
}
if(ext== "gcf") {
return GuralpGcf;
}
break;
case 'm':
if(ext=="msd" || ext=="mseed") {
return MiniSeed;
}
break;
case 'n':
if(ext=="ndx" ) {
return Sismalp;
}
break;
case 'r':
if(ext=="rd3" ) {
return RD3;
}
break;
case 's':
switch(ext.count()) {
case 2:
if(ext=="su" ) {
if(defaultEndianess || !finfo.exists()) {
#if Q_BYTE_ORDER==Q_BIG_ENDIAN
return SuBigEndian;
#else
return SuLittleEndian;
#endif
} else {
return SEGYTraceHeader::determineByteOrderSU(fileName);
}
}
break;
case 3:
switch(ext[2].unicode()) {
case '2':
if(ext=="sg2") {
return Seg2;
}
break;
case 'c':
if(ext=="sac" ) {
if(defaultEndianess || !finfo.exists()) {
#if Q_BYTE_ORDER==Q_BIG_ENDIAN
return SacBigEndian;
#else
return SacLittleEndian;
#endif
} else {
return SACHeader::determineByteOrder(fileName);
}
}
break;
case 'd':
if(ext=="sgd") {
return SegD;
}
break;
case 'f':
if(ext=="saf") {
return Saf;
}
break;
case 'r':
if(ext=="smr") {
return SyscomSmr;
}
break;
case 's':
if(ext=="sis") {
return Sismalp;
}
break;
case 'y':
if(ext=="sgy" ) {
if(defaultEndianess || !finfo.exists()) {
#if Q_BYTE_ORDER==Q_BIG_ENDIAN
return SegYBigEndian;
#else
return SegYLittleEndian;
#endif
} else {
SignalFileFormat fmt;
fmt=SEGYTraceHeader::determineByteOrderSEGY(fileName);
if(fmt.id()!=Unknown) return fmt;
// Probably PASSCAL SEGY
fmt=PasscalSegYHeader::determineByteOrder(fileName);
if(fmt.id()!=Unknown) return fmt;
}
}
break;
}
break;
case 4:
switch(ext[3].unicode()) {
case '2':
if(ext=="seg2") {
return Seg2;
}
break;
case 'd':
if(ext=="segd") {
return SegD;
}
break;
case 'y':
if(ext=="segy") {
if(defaultEndianess || !finfo.exists()) {
#if Q_BYTE_ORDER==Q_BIG_ENDIAN
return SegYBigEndian;
#else
return SegYLittleEndian;
#endif
} else {
SignalFileFormat fmt;
fmt=SEGYTraceHeader::determineByteOrderSEGY(fileName);
if(fmt.id()!=Unknown) return fmt;
// Probably PASSCAL SEGY
fmt=PasscalSegYHeader::determineByteOrder(fileName);
if(fmt.id()!=Unknown) return fmt;
}
}
break;
}
break;
}
break;
case 't':
if(ext=="txt" || ext=="text") {
return Ascii;
}
break;
case 'v':
if(ext=="vmr" || ext=="vmx") {
return SyscomVmrx;
}
break;
case 'w':
if(ext=="wav" ) {
return Wav;
}
break;
case 'x':
if(ext=="xmr" ) {
return SyscomXmr;
}
break;
}
}
SignalFileFormat fmt=geopsyCore->customFileFormats()->fromExtension(ext);
if(fmt.id()!=Unknown) return fmt;
return Unknown;
}
| Format GeopsyCore::SignalFileFormat::id | ( | ) | const [inline] |
Referenced by GeopsyMainWindow::exportSignal(), fromContent(), fromSuffix(), getExportFormat(), getImportFormat(), importList(), GeopsyCore::SignalDB::isModified(), GeopsyCore::SignalFilePool::load(), GeopsyCore::GeopsyCoreEngine::load(), GeopsyCore::SignalFile::load(), GeopsyCore::SubSignalPool::save(), and GeopsyCore::XMLSignal::xml_writeProperties().
{return _id;}
| QList< QPair< QString, SignalFileFormat > > GeopsyCore::SignalFileFormat::importList | ( | ) | [static] |
Return a list of available formats for import, suitable for all input dialog boxes.
References caption(), captionFilter(), Custom, GeopsyCore::GeopsyCoreEngine::customFileFormats(), format, FormatCount, GeopsyCore::geopsyCore, id(), GeopsyCore::CustomFileFormats::list(), Temporary, and TRACE.
Referenced by GeopsyCore::GeopsyCoreEngine::askLoadFormat(), and GeopsyCore::GeopsyPreferences::load().
{
TRACE;
QList< QPair<QString, SignalFileFormat> > formats;
// Add conventional formats
for(int i=1; i<FormatCount; i++) {
SignalFileFormat format((Format)i);
if(format.id()!=Temporary && format.id()!=Custom) {
formats.append(QPair<QString, SignalFileFormat>(format.captionFilter(), format));
}
}
// Add custom formats
QList<SignalFileFormat> customList= geopsyCore->customFileFormats()->list();
for(QList<SignalFileFormat>::iterator it=customList.begin(); it!=customList.end(); it++) {
SignalFileFormat& format=*it;
formats.append(QPair<QString, SignalFileFormat>(format.captionFilter(), format));
}
qSort(formats);
// Make sure that "Automatic recognition" is the first one
SignalFileFormat f;
formats.prepend(QPair<QString, SignalFileFormat>(f.caption(), f));
return formats;
}
| bool GeopsyCore::SignalFileFormat::isReadOnly | ( | ) | const |
References Ascii, AsciiOneColumn, Custom, GeopsySignal, Gse2, GeopsyCore::AbstractFileFormat::isReadOnly(), MiniSeed, MultiGse2, SacBigEndian, SacLittleEndian, Saf, Seg2, SegYBigEndian, SegYLittleEndian, SIGNALFILEFORMAT_READONLY, SuBigEndian, SuLittleEndian, Tomo, TRACE, and Wav.
Referenced by getExportFormat(), listExportFormats(), and ExportFileType::setFormatList().
{
TRACE;
switch (_id) {
case Ascii:
if(_customFormat) {
return true;
} else {
return false;
}
case Custom:
if(_customFormat) {
return _customFormat->isReadOnly();
}
break;
case Seg2:
case SuLittleEndian:
case SuBigEndian:
case SegYLittleEndian:
case SegYBigEndian:
case SacLittleEndian:
case SacBigEndian:
case Gse2:
case MultiGse2:
case GeopsySignal:
case Tomo:
case AsciiOneColumn:
case MiniSeed:
case Saf:
case Wav:
return false;
SIGNALFILEFORMAT_READONLY
break;
};
return true;
}
| bool GeopsyCore::SignalFileFormat::operator< | ( | const SignalFileFormat & | o | ) | const |
{
return _id<o._id;
}
| void GeopsyCore::SignalFileFormat::operator= | ( | const SignalFileFormat & | o | ) |
References QGpCoreTools::SharedObject::addReference().
{
_id=o._id;
if(_customFormat) {
SharedObject::removeReference(_customFormat);
}
_customFormat=o._customFormat;
if(_customFormat) {
_customFormat->addReference();
}
}
| bool GeopsyCore::SignalFileFormat::operator== | ( | const SignalFileFormat & | o | ) | const |
{
return _id==o._id && _customFormat==o._customFormat;
}
Returns true if it is a one signal per file format (GSE, SAC)
References Gse2, Multi, SacBigEndian, SacLittleEndian, and Single.
{
switch (_id) {
case SacLittleEndian:
case SacBigEndian:
case Gse2:
return Single;
default:
return Multi;
}
}
| QString GeopsyCore::SignalFileFormat::suffix | ( | ) | const |
Returns default suffix for exporting with format f
References Ascii, AsciiGeoSig, AsciiOneColumn, City2, Custom, GeopsyCore::AbstractFileFormat::extensions(), FormatCount, Fourier, GeopsySignal, Gse2, GuralpGcf, MiniSeed, MultiGse2, NiSismo, PasscalSegYBigEndian, PasscalSegYLittleEndian, Radan, RD3, SacBigEndian, SacLittleEndian, Saf, Seg2, SegD, SegYBigEndian, SegYLittleEndian, Sismalp, SuBigEndian, SuLittleEndian, SyscomSmr, SyscomVmrx, SyscomXmr, Temporary, Tomo, TRACE, Unknown, and Wav.
{
TRACE;
switch (_id) {
case Seg2: return ".seg2";
case SegD: return ".segd";
case SuLittleEndian:
case SuBigEndian:
return ".su";
case Tomo: return ".arr";
case RD3: return ".rd3";
case Ascii:
case Custom:
if(_customFormat && !_customFormat->extensions().isEmpty()) {
return "."+_customFormat->extensions().first();
}
break;
case NiSismo:
case City2:
case AsciiOneColumn:
case GeopsySignal:
case Unknown:
case Temporary:
case FormatCount:
case Sismalp:
break;
case SacLittleEndian:
case SacBigEndian:
return ".sac";
case Radan: return ".dzt";
case Gse2:
case MultiGse2:
return ".gse";
case Saf: return ".saf";
case Wav: return ".wav";
case SegYLittleEndian:
case SegYBigEndian:
case PasscalSegYLittleEndian:
case PasscalSegYBigEndian:
return ".sgy";
case SyscomXmr: return ".xmr";
case SyscomSmr: return ".smr";
case SyscomVmrx: return ".vmx";
case GuralpGcf: return ".gcf";
case AsciiGeoSig: return ".txt";
case MiniSeed: return ".mseed";
case Fourier: return ".fourier";
};
return QString::null;
}
| QString GeopsyCore::SignalFileFormat::toString | ( | ) | const |
References Ascii, AsciiGeoSig, AsciiOneColumn, City2, Custom, FormatCount, Fourier, GeopsySignal, Gse2, GuralpGcf, MiniSeed, MultiGse2, NiSismo, PasscalSegYBigEndian, PasscalSegYLittleEndian, Radan, RD3, SacBigEndian, SacLittleEndian, Saf, Seg2, SegD, SegYBigEndian, SegYLittleEndian, Sismalp, SuBigEndian, SuLittleEndian, SyscomSmr, SyscomVmrx, SyscomXmr, Temporary, Tomo, GeopsyCore::AbstractFileFormat::toString(), TRACE, Unknown, and Wav.
Referenced by GeopsyCore::Signal::compare(), GeopsyCore::SignalProcess::exportFile(), GeopsyCore::Signal::header(), listExportFormats(), listImportFormats(), GeopsyCore::SubSignalPool::save(), and GeopsyCore::SignalFile::xml_writeProperties().
{
TRACE;
switch (_id) {
case Seg2: return "Seg2";
case SegD: return "SegD";
case SuLittleEndian: return "SuLittleEndian";
case SuBigEndian: return "SuBigEndian";
case Tomo: return "Tomo";
case RD3: return "RD3";
case NiSismo: return "NiSismo";
case SacLittleEndian: return "SacLittleEndian";
case SacBigEndian: return "SacBigEndian";
case Radan: return "Radan";
case Gse2: return "Gse2";
case City2: return "City2";
case Ascii:
if(_customFormat) {
return _customFormat->toString();
} else {
return "Ascii";
}
case AsciiOneColumn: return "AsciiOneColumn";
case GeopsySignal: return "GeopsySignal";
case Saf: return "Saf";
case MultiGse2: return "MultiGse2";
case Sismalp: return "Sismalp";
case Wav: return "Wav";
case SegYLittleEndian: return "SegYLittleEndian";
case SegYBigEndian: return "SegYBigEndian";
case PasscalSegYLittleEndian: return "PasscalSegYLittleEndian";
case PasscalSegYBigEndian: return "PasscalSegYBigEndian";
case Temporary: return "Temporary";
case SyscomXmr: return "SyscomXmr";
case SyscomSmr: return "SyscomSmr";
case SyscomVmrx: return "SyscomVmrx";
case GuralpGcf: return "GuralpGcf";
case AsciiGeoSig: return "AsciiGeoSIG";
case MiniSeed: return "MiniSeed";
case Fourier: return "Fourier";
case Custom:
if(_customFormat) {
return _customFormat->toString();
}
break;
case FormatCount:
case Unknown:
break;
};
return "Unknown";
}
