/// <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); }