/// <summary>
/// Private constructor. The point of this is to limit the number of ways a sgy file can be opened. Either it must be created from scratch with header properties as
/// input arguments, or it must be opened from a preexisting file and header information must be inferred from the contents.
/// </summary>
/// <param name="stream">The file stream</param>
/// <param name="textHeader">The ebcdic or ascii encoded (worthless to have different encodings) text header </param>
/// <param name="textHeaderEncoding">The encoding type for the text header</param>
/// <param name="header">The file binary header</param>
/// <param name="endianBitconverter">A converter to accomodate little endian vs big endian bit conversion</param>
protected SgyFile(FileStream stream, IEnumerable <string> textHeaders, Encoding textHeaderEncoding, FileHeader header, EndianBitConverter endianBitconverter)
{
// Reset stream
stream.Seek(0, SeekOrigin.Begin);
this.stream = stream;
this.FileInfo = new FileInfo(stream.Name);
this.TextHeaders = textHeaders;
this.TextHeaderEncoding = textHeaderEncoding;
this.header = header;
this.BitConverter = endianBitconverter;
this.binaryReader = endianBitconverter.Endianness == Endianness.BigEndian ? (IBinaryReader) new BigEndianBinaryReader(stream) : (IBinaryReader) new LittleEndianBinaryReader(stream);
this.binaryWriter = endianBitconverter.Endianness == Endianness.BigEndian ? (IBinaryWriter) new BigEndianBinaryWriter(stream) : (IBinaryWriter) new LittleEndianBinaryWriter(stream);
this.dataSampleSize = SizeFrom((FormatCode)this.header.DataSampleFormatCode);
this.TraceCount = (stream.Length - (3600 + ((TextHeaders.Count() - 1) * TextHeaderBytesCount))) / (240 + (BinaryFileHeader.SamplesPerTraceOfFile * this.dataSampleSize));
switch ((FormatCode)this.header.DataSampleFormatCode)
{
case FormatCode.IbmFloatingPoint4:
traceDataReadingFunc = (count) => binaryReader.ReadIbmSingles(count);
traceDataWritingFunc = (floats) => binaryWriter.WriteIbm(floats);
break;
case FormatCode.IeeeFloatingPoint4:
traceDataReadingFunc = (count) => binaryReader.ReadSingles(count);
traceDataWritingFunc = (floats) => binaryWriter.Write(floats);
break;
default: throw new NotImplementedException($"Bit converter not implemented yet for format code: {this.header.DataSampleFormatCode}");
}
}
public void Write(IEnumerable <float[]> traceDatas, long startTraceIndex)
{
var traceStartBytePosition = (TextHeaders.Count() * TextHeaderBytesCount) + BinaryHeaderBytesCount + (startTraceIndex * (TraceHeaderBytesCount + (BinaryFileHeader.SamplesPerTraceOfFile * dataSampleSize)));
binaryWriter.BaseStream.Seek(traceStartBytePosition, SeekOrigin.Begin);
foreach (float[] traceData in traceDatas)
{
binaryWriter.BaseStream.Seek(TraceHeaderBytesCount, SeekOrigin.Current);
traceDataWritingFunc(traceData);
}
}
public void Write(IEnumerable <Trace> traces, long startTraceIndex)
{
var traceStartBytePosition = (TextHeaders.Count() * TextHeaderBytesCount) + BinaryHeaderBytesCount + (startTraceIndex * (TraceHeaderBytesCount + (BinaryFileHeader.SamplesPerTraceOfFile * dataSampleSize)));
binaryWriter.BaseStream.Seek(traceStartBytePosition, SeekOrigin.Begin);
foreach (var trace in traces)
{
var traceHeaderBytes = trace.Header.ToBytes(this.BitConverter);
binaryWriter.Write(traceHeaderBytes);
traceDataWritingFunc(trace.Data);
}
}
public void Write(TraceHeader traceHeader, long traceIndex)
{
if (TraceCount < traceIndex)
{
throw new ArgumentException("There are fewer traces in the file then intended trace headers to write");
}
var traceStartBytePosition = (TextHeaders.Count() * TextHeaderBytesCount) + BinaryHeaderBytesCount + (traceIndex * (TraceHeaderBytesCount + (BinaryFileHeader.SamplesPerTraceOfFile * dataSampleSize)));
binaryWriter.BaseStream.Seek(traceStartBytePosition, SeekOrigin.Begin);
var traceHeaderBytes = traceHeader.ToBytes(this.BitConverter);
binaryWriter.Write(traceHeaderBytes);
}
public void Write(float[] traceData, long traceIndex)
{
if (traceData == null)
{
throw new ArgumentNullException("Trace data cannot be null when appending");
}
if (traceData.Length != BinaryFileHeader.SamplesPerTraceOfFile)
{
throw new ArgumentException($"Trace (Length:{traceData.Length}) must have {BinaryFileHeader.SamplesPerTraceOfFile}");
}
var traceStartBytePosition = (TextHeaders.Count() * TextHeaderBytesCount) + BinaryHeaderBytesCount + (traceIndex * (TraceHeaderBytesCount + (BinaryFileHeader.SamplesPerTraceOfFile * dataSampleSize)));
binaryWriter.BaseStream.Seek(traceStartBytePosition + TraceHeaderBytesCount, SeekOrigin.Begin);
traceDataWritingFunc(traceData);
}
public IEnumerable <Trace> ReadTraces(long startTraceIndex, long traceCount)
{
if (startTraceIndex > TraceCount)
{
throw new ArgumentException($"Cannot read a trace with trace index: {startTraceIndex}, when file only contains {TraceCount} traces");
}
var initStreamPosition = (3600 + ((TextHeaders.Count() - 1) * TextHeaderBytesCount)) + (240 + BinaryFileHeader.SamplesPerTraceOfFile * dataSampleSize) * startTraceIndex;
binaryReader.BaseStream.Seek(initStreamPosition, SeekOrigin.Begin);
BigList <Trace> traces = new BigList <Trace>(traceCount);
for (long tid = 0; tid < traceCount; tid++)
{
var traceHeaderByteArr = binaryReader.ReadBytes(TraceHeaderBytesCount);
var traceData = traceDataReadingFunc(BinaryFileHeader.SamplesPerTraceOfFile);// _binaryreader.ReadIbmSingles(Header.SamplesPerTraceOfFile);
var trHeader = TraceHeader.From(traceHeaderByteArr, BitConverter);
var seismicTrace = new Trace(trHeader, traceData);
traces.Add(seismicTrace);
}
return(traces);
}
public IEnumerable <TraceHeader> ReadTraceHeaders(long startTraceIndex, long traceCount)
{
if (startTraceIndex > TraceCount)
{
throw new ArgumentException($"Cannot read a trace header with trace index: {startTraceIndex}, when file only contains {TraceCount} traces");
}
var streamLen = binaryReader.BaseStream.Length;
int traceDataBytesSz = BinaryFileHeader.SamplesPerTraceOfFile * dataSampleSize;
var dataStartIndex = TextHeaderBytesCount + BinaryHeaderBytesCount + TextHeaderBytesCount * (TextHeaders.Count() - 1);
var initStreamPosition = dataStartIndex + (240 + BinaryFileHeader.SamplesPerTraceOfFile * dataSampleSize) * startTraceIndex;
binaryReader.BaseStream.Seek(initStreamPosition, SeekOrigin.Begin);
var streamPosition = initStreamPosition;
BigArray <TraceHeader> traceHeaders = new BigArray <TraceHeader>(traceCount);
for (long tid = 0; tid < traceCount && (streamPosition < streamLen); tid++)
{
var traceHeaderByteArr = binaryReader.ReadBytes(TraceHeaderBytesCount);
var trHeader = TraceHeader.From(traceHeaderByteArr, BitConverter);
binaryReader.BaseStream.Seek(traceDataBytesSz, SeekOrigin.Current);
streamPosition += 240 + traceDataBytesSz;
traceHeaders[tid] = trHeader;
}
return(traceHeaders);
}
public TraceHeader ReadTraceHeader(long traceIndex)
{
if (traceIndex > TraceCount)
{
throw new ArgumentException($"Cannot read a trace with trace index: {traceIndex}, when file only contains {TraceCount} traces");
}
var dataStartIndex = TextHeaderBytesCount + BinaryHeaderBytesCount + TextHeaderBytesCount * (TextHeaders.Count() - 1);
var initStreamPosition = dataStartIndex + (240 + BinaryFileHeader.SamplesPerTraceOfFile * this.dataSampleSize) * traceIndex;
this.binaryReader.BaseStream.Seek(initStreamPosition, SeekOrigin.Begin);
var traceHeaderByteArr = this.binaryReader.ReadBytes(TraceHeaderBytesCount);
var trHeader = TraceHeader.From(traceHeaderByteArr, BitConverter);
return(trHeader);
}
