def report_segy(in_filename):
with open(in_filename, 'rb') as in_file:
segy_reader = create_reader(in_file)
print()
print("Filename: ", segy_reader.filename)
print("SEG Y revision: ", segy_reader.revision)
print("Number of traces: ", segy_reader.num_traces())
print("Data format: ",
segy_reader.data_sample_format_description)
print("Dimensionality: ", segy_reader.dimensionality)
try:
print("Number of CDPs: ", segy_reader.num_cdps())
except AttributeError:
pass
try:
print("Number of inlines: ", segy_reader.num_inlines())
print("Number of crosslines: ", segy_reader.num_xlines())
except AttributeError:
pass
print("=== BEGIN TEXTUAL REEL HEADER ===")
for line in segy_reader.textual_reel_header:
print(line[3:])
print("=== END TEXTUAL REEL HEADER ===")
print()
print("=== BEGIN EXTENDED TEXTUAL HEADER ===")
print(segy_reader.extended_textual_header)
print("=== END EXTENDED TEXTUAL_HEADER ===")
def test_cache_used_if_found(self, tempdir):
dset1 = dataset(num_dims=2).example()
dset2 = dataset(num_dims=2).example()
# This is hacky. We want to verify that create_reader will use a
# chached reader if one exists, but we don't really have a way to
# determine that directly (without timing, perhaps). So we're going to
# try to trick the system. First we'll save one dataset and read it to
# generate a cache. Then we'll do the same with another dataset . Then
# we'll copy the first cache over the second, making sure to use the
# right filename (since it's derived from the sha1 of the dataset).
# Finally, we'll load the second dataset and request that the cache is
# used. The returned reader should look like the first dataset, i.e.
# the one who's cache we copied.
# create a reliably different dset. hypothesis likes to make them
# entirely equal.
dset2.binary_reel_header.reel_num = 1 if dset1.binary_reel_header.reel_num == 0 else 0
# generate the cache for the first dataset
segy_dir1 = tempdir / '1'
segy_dir1.mkdir()
segy_file1 = str(segy_dir1 / 'test.segy')
cache_dir = '.segy_cache'
with open(segy_file1, mode='wb') as fh:
write_segy(fh, dset1)
with open(segy_file1, mode='rb') as fh:
create_reader(fh, cache_directory=cache_dir)
# generate the cache for the second dataset
segy_dir2 = tempdir / '2'
segy_dir2.mkdir()
segy_file2 = str(segy_dir2 / 'test.segy')
with open(segy_file2, mode='wb') as fh:
write_segy(fh, dset2)
with open(segy_file2, mode='rb') as fh:
create_reader(fh, cache_directory=cache_dir)
# Replace the second cache with the first, preserving the filename.
cache_path1 = segy_dir1 / cache_dir
cache_file1 = next(cache_path1.iterdir())
cache_path2 = segy_dir2 / cache_dir
cache_file2 = next(cache_path2.iterdir())
cache_file1.replace(cache_file2)
# Now when we load the second dataset, we should get the cache of the
# first. Sneaky!
with open(segy_file2, mode='rb') as fh:
reader = create_reader(
fh,
dimensionality=dset2.dimensionality,
cache_directory=cache_dir)
_compare_datasets(dset1, reader,
compare_dimensionality=False)
def test_filename_reports_unknown_when_filename_unavailable(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh)
assert reader.filename == '<unknown>'
def test_all_cdps_map_to_a_trace_index(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh, dimensionality=2)
for cdp_number in reader.cdp_numbers():
reader.trace_index(cdp_number)
def test_segy_revision_is_correct(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh)
assert reader.revision == dset.binary_reel_header.format_revision_num
def test_SegYReader_bytes_per_sample_is_correct(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh)
assert reader.bytes_per_sample == bytes_per_sample(dset.binary_reel_header)
def transform(scale_factor, in_filename, out_filename):
with open(in_filename, 'rb') as in_file, \
open(out_filename, 'wb') as out_file:
segy_reader = create_reader(in_file, progress=make_progress_indicator("Cataloging"))
transformed_dataset = ScaledCoordinatesDataset(segy_reader, scale_factor)
write_segy(out_file, transformed_dataset, progress=make_progress_indicator("Transforming"))
def report_segy(in_filename):
with open(in_filename, 'rb') as in_file:
# Create a reader using the CustomBinaryReelHeader format.
segy_reader = create_reader(
in_file, binary_reel_header_format=CustomBinaryReelHeader)
print()
print("Filename: ", segy_reader.filename)
print("SEG Y revision: ", segy_reader.revision)
print("Number of traces: ", segy_reader.num_traces())
print("Data format: ",
segy_reader.data_sample_format_description)
print("Dimensionality: ", segy_reader.dimensionality)
try:
print("Number of CDPs: ", segy_reader.num_cdps())
except AttributeError:
pass
try:
print("Number of inlines: ", segy_reader.num_inlines())
print("Number of crosslines: ", segy_reader.num_xlines())
except AttributeError:
pass
print("=== BEGIN TEXTUAL REEL HEADER ===")
for line in segy_reader.textual_reel_header:
print(line[3:])
print("=== END TEXTUAL REEL HEADER ===")
print()
print("=== BEGIN EXTENDED TEXTUAL HEADER ===")
print(segy_reader.extended_textual_header)
print("=== END EXTENDED TEXTUAL_HEADER ===")
def test_all_inline_xlines_have_a_trace_index(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh, dimensionality=3)
for num in reader.inline_xline_numbers():
assert reader.has_trace_index(num)
def transform(scale_factor, in_filename, out_filename):
with open(in_filename, 'rb') as in_file, \
open(out_filename, 'wb') as out_file:
segy_reader = create_reader(in_file)
transformed_dataset = ScaledSamplesDataset(segy_reader, scale_factor)
write_segy(out_file, transformed_dataset)
def transform(scale_factor, in_filename, out_filename):
with open(in_filename, 'rb') as in_file, \
open(out_filename, 'wb') as out_file:
segy_reader = create_reader(in_file)
transformed_dataset = ScaledSamplesDataset(segy_reader, scale_factor)
write_segy(out_file, transformed_dataset)
def test_inline_xlines_map_to_correct_trace_index(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh, dimensionality=3)
for num in reader.inline_xline_numbers():
assert reader.trace_index(num) == num[0]
assert reader.trace_index(num) == num[1]
def test_reading_from_non_file(dset):
handle = io.BytesIO()
write_segy(handle, dset)
handle.seek(0)
reader = create_reader(handle, dimensionality=dset.dimensionality)
_compare_datasets(reader, dset)
def test_type_error_on_non_reader_cache_file(self, dset, tempdir):
segy_file = str(tempdir / 'test.segy')
cache_dir = '.segy_cache'
with open(segy_file, mode='wb') as fh:
write_segy(fh, dset)
with open(segy_file, mode='rb') as fh:
create_reader(fh, cache_directory=cache_dir)
cache_dir = tempdir / cache_dir
cache_file = next(cache_dir.iterdir())
with open(str(cache_file), mode='wb') as fh:
pickle.dump('not a reader', fh)
with pytest.raises(TypeError):
with open(segy_file, mode='rb') as fh:
create_reader(fh, cache_directory=cache_dir)
def test_filename_correctly_reported_for_normal_files(tempdir, dset):
segy_file = str(tempdir / 'segy')
with open(segy_file, mode='wb') as fh:
write_segy(fh, dset)
with open(segy_file, mode='rb') as fh:
reader = create_reader(fh)
assert reader.filename == segy_file
def load_save(in_filename, out_filename):
with open(in_filename, 'rb') as in_file, \
open(out_filename, 'wb') as out_file:
segy_reader = create_reader(
in_file, progress=make_progress_indicator("Cataloging"))
write_segy(out_file,
segy_reader,
progress=make_progress_indicator("Copying"))
def test_SegYReader_throws_TypeError_if_pickled_without_real_file_handle(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh, cache_directory=None)
with pytest.raises(TypeError):
pickle.dumps(reader)
def test_SegYReader_throws_TypeError_when_pickling_from_closed_file_handle(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh)
fh.close()
with pytest.raises(TypeError):
pickle.dumps(reader)
def test_reading_when_cache_dir_is_empty(self, dset, tempdir):
segy_file = str(tempdir / 'test.segy')
cache_dir = '.segy_cache'
with open(segy_file, mode='wb') as fh:
write_segy(fh, dset)
with open(segy_file, mode='rb') as fh:
create_reader(fh, cache_directory=cache_dir)
cache_dir = tempdir / cache_dir
for cache_file in cache_dir.iterdir():
cache_file.unlink()
with open(segy_file, mode='rb') as fh:
reader = create_reader(fh,
dimensionality=dset.dimensionality,
cache_directory=cache_dir)
_compare_datasets(reader, dset)
def test_TypeError_unpickling_cache_with_missing_segy_file(dset, tempdir):
segy_file = tempdir / 'segy'
cache_dir = 'cache_dir'
with open(str(segy_file), mode='wb') as fh:
write_segy(fh, dset)
# Force creation of cache
with open(str(segy_file), mode='rb') as fh:
create_reader(fh, cache_directory=cache_dir)
# Delete the segy file
segy_file.unlink()
# Try to unpickle the cache
cache_path = tempdir / cache_dir
cache_file = next(cache_path.iterdir())
with open(str(cache_file), mode='rb') as fh:
with pytest.raises(TypeError):
pickle.load(fh)
def test_trace_header_format_is_requested_format(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(
fh,
trace_header_format=TraceHeaderRev1)
# TODO: Currently we only generate datasets with rev1 headers. We need to
# fix this.
assert reader.trace_header_format_class is TraceHeaderRev1
def test_trace_header_raises_ValueError_on_out_of_range(dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh)
with pytest.raises(ValueError):
reader.trace_header(-1)
with pytest.raises(ValueError):
reader.trace_header(reader.num_traces() + 1)
def test_ValueError_on_out_of_range_trace_index(self, dset):
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh)
with pytest.raises(ValueError):
reader.trace_samples(-1)
with pytest.raises(ValueError):
reader.trace_samples(reader.num_traces())
def main():
output_path = "data.json"
fh = open("line12_1.8_2.2s", 'rb')
segy_reader = reader.create_reader(fh)
traces = []
for trace_index in segy_reader.trace_indexes():
trace = [float(a) for a in segy_reader.trace_samples(trace_index)]
traces.append(trace)
traces = traces[:int(len(traces) / 2)]
json.dump(traces, open(output_path, 'w'))
def test_cache_version_mismatch_throws_TypeError(dset, tempdir):
segy_file = tempdir / 'segy'
cache_dir = 'cache_dir'
with open(str(segy_file), mode='wb') as fh:
write_segy(fh, dset)
# Create reader to force creation of cache
with open(str(segy_file), mode='rb') as fh:
reader = create_reader(fh, cache_directory=cache_dir)
state_dict = reader.__getstate__()
state_dict['__version__'] = state_dict['__version__'] * 2
with pytest.raises(TypeError):
reader.__setstate__(state_dict)
def extract_timeslice(segy_filename, out_filename, slice_index, dtype=None, null=0):
"""Extract a timeslice from a 3D SEG Y file to a Numpy NPY file.
Args:
segy_filename: Filename of a SEG Y file.
out_filename: Filename of the NPY file.
slice_index: The zero-based index (increasing with depth) of the slice to be extracted.
dtype: Optional Numpy dtype for the result array. If not provided a dtype compatible with
the SEG Y data will be used.
null: Optional sample value to use for missing or short traces. Defaults to zero.
"""
with open(segy_filename, 'rb') as segy_file:
segy_reader = create_reader(segy_file)
if dtype is None:
dtype = make_dtype(segy_reader.data_sample_format)
if segy_reader.dimensionality != 3:
raise DimensionalityError("Cannot slice {n} dimensional seismic.".format(segy_reader.dimensionality))
i_line_range = segy_reader.inline_range()
x_line_range = segy_reader.xline_range()
i_size = len(i_line_range)
x_size = len(x_line_range)
t_size = segy_reader.max_num_trace_samples()
if not (0 <= slice_index < t_size):
raise ValueError("Time slice index {0} out of range {} to {}".format(slice_index, 0, t_size))
timeslice = np.full((x_size, i_size), null, dtype)
for inline_num, xline_num in segy_reader.inline_xline_numbers():
trace_index = segy_reader.trace_index((inline_num, xline_num))
trace = segy_reader.trace_samples(trace_index)
try:
sample = trace[slice_index]
except IndexError:
sample = null
i_index = inline_num - i_line_range.start
x_index = xline_num - x_line_range.start
timeslice[x_index, i_index] = sample
np.save(out_filename, timeslice)
def test_cache_is_created_when_requested(self, dset, tempdir):
segy_file = str(tempdir / 'test.segy')
cache_dir = '.segy_cache'
cache_path = tempdir / cache_dir
with open(segy_file, mode='wb') as fh:
write_segy(fh, dset)
assert not cache_path.exists()
with open(segy_file, mode='rb') as fh:
reader = create_reader(fh, cache_directory=cache_dir)
assert cache_path.exists()
def transform(in_filename, out_filename):
with open(in_filename, 'rb') as in_file, \
open(out_filename, 'wb') as out_file:
print('Loading SEG-Y file')
segy_reader = create_reader(in_file)
print('Calculation starts...')
angle_to_rotate, averaged_tool_face = _measure_rotation_angle(segy_reader)
np.savetxt(in_filename[:-4]+'_RotationAngle.txt', angle_to_rotate, fmt='%.2f')
np.savetxt(in_filename[:-4]+'_ToolFace.txt', averaged_tool_face, fmt='%.2f')
transformed_dataset = RotatedDataset(segy_reader, angle_to_rotate)
print('Rotating and saving SEG-Y file')
write_segy(out_file, transformed_dataset)
def test_ValueError_on_out_of_range_start_sample(self, dset):
assume(dset.num_traces() > 0)
fh = io.BytesIO()
write_segy(fh, dset)
fh.seek(0)
reader = create_reader(fh)
with pytest.raises(ValueError):
reader.trace_samples(0, start=-1)
with pytest.raises(ValueError):
reader.trace_samples(0, start=reader.num_trace_samples(0) + 1)
def extract_trace_positions(segy_filename):
"""Extract a timeslice from a 3D SEG Y file to a Numpy NPY file.
Args:
segy_filename: Filename of a SEG Y file.
"""
with open(segy_filename, 'rb') as segy_file:
segy_reader = create_reader(segy_file)
for trace_index in segy_reader.trace_indexes():
trace_header = segy_reader.trace_header(trace_index)
trace_position = (trace_header.cdp_x,
trace_header.cdp_y)
print(trace_index, trace_position)
def _dataset_round_trip(rootdir, dataset, compare_dimensionality=True):
"""Write `dataset` to a file in `rootdir`, read it back in, and compare the
original with the loaded version.
"""
segy_file = str(rootdir / 'test.segy')
with open(segy_file, mode='bw') as fh:
write_segy(fh, dataset)
with open(segy_file, mode='br') as fh:
reader = create_reader(
fh,
trace_header_format=dataset._trace_header_format,
dimensionality=dataset.dimensionality)
_compare_datasets(dataset, reader, compare_dimensionality)
def extract_inline(segy_filename, out_filename, inline_number, null=None):
"""Extract a timeslice from a 3D SEG Y file to a Numpy NPY file.
Args:
segy_filename: Filename of a SEG Y file.
out_filename: Filename of the NPY file.
inline_index: The zero-based index (increasing with depth) of the slice to be extracted.
null: Optional sample value to use for missing or short traces. Defaults to zero.
"""
with open(segy_filename, 'rb') as segy_file:
segy_reader = create_reader(segy_file)
inline_array = extract_inline_3d(segy_reader, inline_number, null=null)
return inline_array
def handle_metadata(args):
"""Usage: {program} {command} <filename>
Print metadata for a SEGY file.
"""
result = {}
filename = args['<filename>']
with open(filename, 'rb') as fh:
reader = create_reader(fh)
result['num_traces'] = reader.num_traces()
result['dimensionality'] = reader.dimensionality
result['data_sample_format'] = reader.data_sample_format
result['max_num_trace_samples'] = reader.max_num_trace_samples()
print(json.dumps(result))
def test_SegYReader3D_raises_TypeError_on_null_line_catalog():
dataset = diagonal_dataset_3d().example()
fh = io.BytesIO()
write_segy(fh, dataset)
fh.seek(0)
reader = create_reader(fh, dimensionality=2)
fh.seek(0)
with pytest.raises(TypeError):
SegYReader3D(
fh=fh,
textual_reel_header=reader.textual_reel_header,
binary_reel_header=reader.binary_reel_header,
extended_textual_headers=reader._extended_textual_headers,
trace_offset_catalog=reader._trace_offset_catalog,
trace_length_catalog=reader._trace_length_catalog,
line_catalog=None,
trace_header_format=reader.trace_header_format_class,
encoding=reader.encoding)
