def create(filename, spec): """Create a new segy file. Since v1.1 Unstructured file creation since v1.4 Create a new segy file with the geometry and properties given by `spec`. This enables creating SEGY files from your data. The created file supports all segyio modes, but has an emphasis on writing. The spec must be complete, otherwise an exception will be raised. A default, empty spec can be created with `segyio.spec()`. Very little data is written to the file, so just calling create is not sufficient to re-read the file with segyio. Rather, every trace header and trace must be written to for the file to be considered complete. Create should be used together with python's `with` statement. This ensure the data is written. Please refer to the examples. The `spec` is any object that has the following attributes: Mandatory: iline (int/segyio.BinField) xline (int/segyio.BinField) samples (array-like of int) format (int), 1 = IBM float, 5 = IEEE float Exclusive: ilines (array-like of int) xlines (array-like of int) offsets (array-like of int) sorting (int/segyio.TraceSortingFormat) OR tracecount (int) Optional: ext_headers (int) The `segyio.spec()` function will default offsets and everything in the mandatory group, except format and samples, and requires the caller to fill in *all* the fields in either of the exclusive groups. If any field is missing from the first exclusive group, and the tracecount is set, the resulting file will be considered unstructured. If the tracecount is set, and all fields of the first exclusive group are specified, the file is considered structured and the tracecount is inferred from the xlines/ilines/offsets. The offsets are defaulted to [1] by `segyio.spec()`. Args: filename (str): Path to file to open. spec (:obj: `spec`): Structure of the segy file. Examples: Create a file:: >>> spec = segyio.spec() >>> spec.ilines = [1, 2, 3, 4] >>> spec.xlines = [11, 12, 13] >>> spec.samples = list(range(50)) >>> spec.sorting = 2 >>> spec.format = 1 >>> with segyio.create(path, spec) as f: ... ## fill the file with data ... Copy a file, but shorten all traces by 50 samples:: >>> with segyio.open(srcpath) as src: ... spec = segyio.spec() ... spec.sorting = src.sorting ... spec.format = src.format ... spec.samples = src.samples[:len(src.samples) - 50] ... spec.ilines = src.ilines ... spec.xline = src.xlines ... with segyio.create(dstpath, spec) as dst: ... dst.text[0] = src.text[0] ... dst.bin = src.bin ... dst.header = src.header ... dst.trace = src.trace Copy a file, but shorten all traces by 50 samples (since v1.4):: >>> with segyio.open(srcpath) as src: ... spec = segyio.tools.metadata(src) ... spec.samples = spec.samples[:len(spec.samples) - 50] ... with segyio.create(dstpath, spec) as dst: ... dst.text[0] = src.text[0] ... dst.bin = src.bin ... dst.header = src.header ... dst.trace = src.trace :rtype: segyio.SegyFile """ f = segyio.SegyFile(filename, "w+") f._samples = numpy.asarray(spec.samples, dtype=numpy.single) f._ext_headers = spec.ext_headers if hasattr(spec, 'ext_headers') else 0 f._bsz = _segyio.trace_bsize(len(f.samples)) txt_hdr_sz = _segyio.textheader_size() bin_hdr_sz = _segyio.binheader_size() f._tr0 = txt_hdr_sz + bin_hdr_sz + (f.ext_headers * txt_hdr_sz) f._fmt = int(spec.format) f._il = int(spec.iline) f._xl = int(spec.xline) if not structured(spec): f._tracecount = spec.tracecount else: f._sorting = spec.sorting f._offsets = numpy.copy(numpy.asarray(spec.offsets, dtype=numpy.intc)) f._tracecount = len(spec.ilines) * len(spec.xlines) * len(spec.offsets) f._ilines = numpy.copy(numpy.asarray(spec.ilines, dtype=numpy.intc)) f._xlines = numpy.copy(numpy.asarray(spec.xlines, dtype=numpy.intc)) line_metrics = _segyio.init_line_metrics(f.sorting, f.tracecount, len(f.ilines), len(f.xlines), len(f.offsets)) f._iline_length = line_metrics['iline_length'] f._iline_stride = line_metrics['iline_stride'] f._xline_length = line_metrics['xline_length'] f._xline_stride = line_metrics['xline_stride'] f.text[0] = default_text_header(f._il, f._xl, segyio.TraceField.offset) f.bin = { 3213: f.tracecount, 3217: 4000, 3221: len(f.samples), 3225: f.format, 3505: f.ext_headers, } return f
def create(filename, spec): """Create a new segy file. Since v1.1 Create a new segy file with the geometry and properties given by `spec`. This enables creating SEGY files from your data. The created file supports all segyio modes, but has an emphasis on writing. The spec must be complete, otherwise an exception will be raised. A default, empty spec can be created with `segyio.spec()`. Very little data is written to the file, so just calling create is not sufficient to re-read the file with segyio. Rather, every trace header and trace must be written to for the file to be considered complete. Create should be used together with python's `with` statement. This ensure the data is written. Please refer to the examples. Args: filename (str): Path to file to open. spec (:obj: `spec`): Structure of the segy file. Examples: Create a file:: >>> spec = segyio.spec() >>> spec.ilines = [1, 2, 3, 4] >>> spec.xlines = [11, 12, 13] >>> spec.samples = list(range(50)) >>> spec.sorting = 2 >>> spec.format = 1 >>> with segyio.create(path, spec) as f: ... ## fill the file with data ... Copy a file, but shorten all traces by 50 samples:: >>> with segyio.open(srcpath) as src: ... spec = segyio.spec() ... spec.sorting = src.sorting ... spec.format = src.format ... spec.samples = src.samples[:len(src.samples) - 50] ... spec.ilines = src.ilines ... spec.xline = src.xlines ... with segyio.create(dstpath, spec) as dst: ... dst.text[0] = src.text[0] ... dst.bin = src.bin ... dst.header = src.header ... dst.trace = src.trace :rtype: segyio.SegyFile """ f = segyio.SegyFile(filename, "w+") f._samples = numpy.asarray(spec.samples, dtype=numpy.single) f._ext_headers = spec.ext_headers f._bsz = _segyio.trace_bsize(len(f.samples)) txt_hdr_sz = _segyio.textheader_size() bin_hdr_sz = _segyio.binheader_size() f._tr0 = txt_hdr_sz + bin_hdr_sz + (spec.ext_headers * txt_hdr_sz) f._sorting = spec.sorting f._fmt = int(spec.format) f._offsets = numpy.copy(numpy.asarray(spec.offsets, dtype=numpy.intc)) f._tracecount = len(spec.ilines) * len(spec.xlines) * len(spec.offsets) f._il = int(spec.iline) f._ilines = numpy.copy(numpy.asarray(spec.ilines, dtype=numpy.intc)) f._xl = int(spec.xline) f._xlines = numpy.copy(numpy.asarray(spec.xlines, dtype=numpy.intc)) line_metrics = _segyio.init_line_metrics(f.sorting, f.tracecount, len(f.ilines), len(f.xlines), len(f.offsets)) f._iline_length = line_metrics['iline_length'] f._iline_stride = line_metrics['iline_stride'] f._xline_length = line_metrics['xline_length'] f._xline_stride = line_metrics['xline_stride'] f.text[0] = default_text_header(f._il, f._xl, segyio.TraceField.offset) f.bin = { 3213: f.tracecount, 3217: 4000, 3221: len(f.samples), 3225: f.format, 3505: f.ext_headers, } return f
def open(filename, mode="r", iline=189, xline=193, strict=True, ignore_geometry=False): """Open a segy file. Opens a segy file and tries to figure out its sorting, inline numbers, crossline numbers, and offsets, and enables reading and writing to this file in a simple manner. For reading, the access mode "r" is preferred. All write operations will raise an exception. For writing, the mode "r+" is preferred (as "rw" would truncate the file). The modes used are standard C file modes; please refer to that documentation for a complete reference. Open should be used together with python's `with` statement. Please refer to the examples. When the `with` statement is used the file will automatically be closed when the routine completes or an exception is raised. By default, segyio tries to open in 'strict' mode. This means the file will be assumed to represent a geometry with consistent inline, crosslines and offsets. If strict is False, segyio will still try to establish a geometry, but it won't abort if it fails. When in non-strict mode is opened, geometry-dependent modes such as iline will raise an error. If 'ignore_geometry' is set to True, segyio will *not* try to build iline/xline or other geometry related structures, which leads to faster opens. This is essentially the same as using strict = False on a file that has no geometry. Args: filename (str): Path to file to open. mode (str, optional): File access mode, defaults to "r". iline (TraceField): Inline number field in the trace headers. Defaults to 189 as per the SEGY specification. xline (TraceField): Crossline number field in the trace headers. Defaults to 193 as per the SEGY specification. strict (bool, optional): Abort if a geometry cannot be inferred. Defaults to True. ignore_geometry (bool, optional): Opt out on building geometry information, useful for e.g. shot organised files. Defaults to False. Examples: Open a file in read-only mode:: >>> with segyio.open(path, "r") as f: ... print(f.ilines) ... Open a file in read-write mode:: >>> with segyio.open(path, "r+") as f: ... f.trace = np.arange(100) ... Open two files at once:: >>> with segyio.open(path) as src, segyio.open(path, "r+") as dst: ... dst.trace = src.trace # copy all traces from src to dst ... :rtype: segyio.SegyFile """ f = segyio.SegyFile(filename, mode, iline, xline) try: metrics = segyio._segyio.init_metrics(f.xfd, f.bin.buf) f._tr0 = metrics['trace0'] f._fmt = metrics['format'] f._bsz = metrics['trace_bsize'] f._tracecount = metrics['trace_count'] f._ext_headers = (f._tr0 - 3600) // 3200 # should probably be from C dt = segyio.tools.dt(f, fallback_dt=4000.0) t0 = f.header[0][segyio.TraceField.DelayRecordingTime] sample_count = metrics['sample_count'] f._samples = numpy.array([t0 + i * dt for i in range(sample_count)], dtype=numpy.single) / 1000.0 except: f.close() raise if ignore_geometry: return f try: cube_metrics = segyio._segyio.init_cube_metrics( f.xfd, iline, xline, f.tracecount, f._tr0, f._bsz) f._sorting = cube_metrics['sorting'] iline_count = cube_metrics['iline_count'] xline_count = cube_metrics['xline_count'] offset_count = cube_metrics['offset_count'] metrics.update(cube_metrics) line_metrics = segyio._segyio.init_line_metrics( f.sorting, f.tracecount, iline_count, xline_count, offset_count) f._iline_length = line_metrics['iline_length'] f._iline_stride = line_metrics['iline_stride'] f._xline_length = line_metrics['xline_length'] f._xline_stride = line_metrics['xline_stride'] f._ilines = numpy.zeros(iline_count, dtype=numpy.intc) f._xlines = numpy.zeros(xline_count, dtype=numpy.intc) f._offsets = numpy.zeros(offset_count, dtype=numpy.intc) segyio._segyio.init_indices(f.xfd, metrics, f.ilines, f.xlines, f.offsets) if numpy.unique(f.ilines).size != f.ilines.size: raise ValueError( "Inlines inconsistent - expect all inlines to be unique") if numpy.unique(f.xlines).size != f.xlines.size: raise ValueError( "Crosslines inconsistent - expect all crosslines to be unique") except: if not strict: f._ilines = None f._xlines = None f._offsets = None else: f.close() raise return f
def create(filename, spec): """Create a new segy file. Create a new segy file with the geometry and properties given by `spec`. This enables creating SEGY files from your data. The created file supports all segyio modes, but has an emphasis on writing. The spec must be complete, otherwise an exception will be raised. A default, empty spec can be created with ``segyio.spec()``. Very little data is written to the file, so just calling create is not sufficient to re-read the file with segyio. Rather, every trace header and trace must be written to the file to be considered complete. Create should be used together with python's ``with`` statement. This ensure the data is written. Please refer to the examples. The ``segyio.spec()`` function will default offsets and everything in the mandatory group, except format and samples, and requires the caller to fill in *all* the fields in either of the exclusive groups. If any field is missing from the first exclusive group, and the tracecount is set, the resulting file will be considered unstructured. If the tracecount is set, and all fields of the first exclusive group are specified, the file is considered structured and the tracecount is inferred from the xlines/ilines/offsets. The offsets are defaulted to ``[1]`` by ``segyio.spec()``. Parameters ---------- filename : str Path to file to create spec : segyio.spec Structure of the segy file Returns ------- file : segyio.SegyFile An open segyio file handle, similar to that returned by `segyio.open` See also -------- segyio.spec : template for the `spec` argument Notes ----- .. versionadded:: 1.1 .. versionchanged:: 1.4 Support for creating unstructured files The ``spec`` is any object that has the following attributes Mandatory:: iline : int or segyio.BinField xline : int or segyio.BinField samples : array of int format : { 1, 5 } 1 = IBM float, 5 = IEEE float Exclusive:: ilines : array_like of int xlines : array_like of int offsets : array_like of int sorting : int or segyio.TraceSortingFormat OR tracecount : int Optional:: ext_headers : int Examples -------- Create a file: >>> spec = segyio.spec() >>> spec.ilines = [1, 2, 3, 4] >>> spec.xlines = [11, 12, 13] >>> spec.samples = list(range(50)) >>> spec.sorting = 2 >>> spec.format = 1 >>> with segyio.create(path, spec) as f: ... ## fill the file with data ... pass ... Copy a file, but shorten all traces by 50 samples: >>> with segyio.open(srcpath) as src: ... spec = segyio.spec() ... spec.sorting = src.sorting ... spec.format = src.format ... spec.samples = src.samples[:len(src.samples) - 50] ... spec.ilines = src.ilines ... spec.xline = src.xlines ... with segyio.create(dstpath, spec) as dst: ... dst.text[0] = src.text[0] ... dst.bin = src.bin ... dst.header = src.header ... dst.trace = src.trace Copy a file, but shorten all traces by 50 samples (since v1.4): >>> with segyio.open(srcpath) as src: ... spec = segyio.tools.metadata(src) ... spec.samples = spec.samples[:len(spec.samples) - 50] ... with segyio.create(dstpath, spec) as dst: ... dst.text[0] = src.text[0] ... dst.bin = src.bin ... dst.header = src.header ... dst.trace = src.trace """ if not structured(spec): tracecount = spec.tracecount else: tracecount = len(spec.ilines) * len(spec.xlines) * len(spec.offsets) ext_headers = spec.ext_headers if hasattr(spec, 'ext_headers') else 0 samples = numpy.asarray(spec.samples, dtype = numpy.single) binary = bytearray(_segyio.binsize()) _segyio.putfield(binary, 3217, 4000) _segyio.putfield(binary, 3221, len(samples)) _segyio.putfield(binary, 3225, int(spec.format)) _segyio.putfield(binary, 3505, int(ext_headers)) f = segyio.SegyFile(str(filename), "w+", tracecount = tracecount, binary = binary) f._il = int(spec.iline) f._xl = int(spec.xline) f._samples = samples if structured(spec): f._sorting = spec.sorting f._offsets = numpy.copy(numpy.asarray(spec.offsets, dtype = numpy.intc)) f._ilines = numpy.copy(numpy.asarray(spec.ilines, dtype=numpy.intc)) f._xlines = numpy.copy(numpy.asarray(spec.xlines, dtype=numpy.intc)) line_metrics = _segyio.line_metrics(f.sorting, tracecount, len(f.ilines), len(f.xlines), len(f.offsets)) f._iline_length = line_metrics['iline_length'] f._iline_stride = line_metrics['iline_stride'] f._xline_length = line_metrics['xline_length'] f._xline_stride = line_metrics['xline_stride'] f.text[0] = default_text_header(f._il, f._xl, segyio.TraceField.offset) f.xfd.putbin(binary) return f
def open(filename, mode="r", iline=189, xline=193, strict=True, ignore_geometry=False): """Open a segy file. Opens a segy file and tries to figure out its sorting, inline numbers, crossline numbers, and offsets, and enables reading and writing to this file in a simple manner. For reading, the access mode `r` is preferred. All write operations will raise an exception. For writing, the mode `r+` is preferred (as `rw` would truncate the file). Any mode with `w` will raise an error. The modes used are standard C file modes; please refer to that documentation for a complete reference. Open should be used together with python's ``with`` statement. Please refer to the examples. When the ``with`` statement is used the file will automatically be closed when the routine completes or an exception is raised. By default, segyio tries to open in ``strict`` mode. This means the file will be assumed to represent a geometry with consistent inline, crosslines and offsets. If strict is False, segyio will still try to establish a geometry, but it won't abort if it fails. When in non-strict mode is opened, geometry-dependent modes such as iline will raise an error. If ``ignore_geometry=True``, segyio will *not* try to build iline/xline or other geometry related structures, which leads to faster opens. This is essentially the same as using ``strict=False`` on a file that has no geometry. Parameters ---------- filename : str Path to file to open mode : {'r', 'r+'} File access mode, read-only ('r', default) or read-write ('r+') iline : int or segyio.TraceField Inline number field in the trace headers. Defaults to 189 as per the SEG-Y rev1 specification xline : int or segyio.TraceField Crossline number field in the trace headers. Defaults to 193 as per the SEG-Y rev1 specification strict : bool, optional Abort if a geometry cannot be inferred. Defaults to True. ignore_geometry : bool, optional Opt out on building geometry information, useful for e.g. shot organised files. Defaults to False. Returns ------- file : segyio.SegyFile An open segyio file handle Raises ------ ValueError If the mode string contains 'w', as it would truncate the file Notes ----- .. versionadded:: 1.1 When a file is opened non-strict, only raw traces access is allowed, and using modes such as ``iline`` raise an error. Examples -------- Open a file in read-only mode: >>> with segyio.open(path, "r") as f: ... print(f.ilines) ... [1, 2, 3, 4, 5] Open a file in read-write mode: >>> with segyio.open(path, "r+") as f: ... f.trace = np.arange(100) Open two files at once: >>> with segyio.open(path) as src, segyio.open(path, "r+") as dst: ... dst.trace = src.trace # copy all traces from src to dst """ if 'w' in mode: problem = 'w in mode would truncate the file' solution = 'use r+ to open in read-write' raise ValueError(', '.join((problem, solution))) f = segyio.SegyFile(str(filename), mode, iline, xline) metrics = f.xfd.metrics() try: dt = segyio.tools.dt(f, fallback_dt=4000.0) / 1000.0 t0 = f.header[0][segyio.TraceField.DelayRecordingTime] samples = metrics['samplecount'] f._samples = (numpy.arange(samples) * dt) + t0 except: f.close() raise if ignore_geometry: return f try: cube_metrics = f.xfd.cube_metrics(iline, xline) f._sorting = cube_metrics['sorting'] iline_count = cube_metrics['iline_count'] xline_count = cube_metrics['xline_count'] offset_count = cube_metrics['offset_count'] metrics.update(cube_metrics) line_metrics = segyio._segyio.line_metrics(f.sorting, f.tracecount, iline_count, xline_count, offset_count) f._iline_length = line_metrics['iline_length'] f._iline_stride = line_metrics['iline_stride'] f._xline_length = line_metrics['xline_length'] f._xline_stride = line_metrics['xline_stride'] f._ilines = numpy.zeros(iline_count, dtype=numpy.intc) f._xlines = numpy.zeros(xline_count, dtype=numpy.intc) f._offsets = numpy.zeros(offset_count, dtype=numpy.intc) f.xfd.indices(metrics, f.ilines, f.xlines, f.offsets) if numpy.unique(f.ilines).size != f.ilines.size: raise ValueError( "Inlines inconsistent - expect all inlines to be unique") if numpy.unique(f.xlines).size != f.xlines.size: raise ValueError( "Crosslines inconsistent - expect all crosslines to be unique") except: if not strict: f._ilines = None f._xlines = None f._offsets = None else: f.close() raise return f
def create(filename, spec): """Create a new segy file. Create a new segy file with the geometry and properties given by `spec`. This enables creating SEGY files from your data. The created file supports all segyio modes, but has an emphasis on writing. The spec must be complete, otherwise an exception will be raised. A default, empty spec can be created with ``segyio.spec()``. Very little data is written to the file, so just calling create is not sufficient to re-read the file with segyio. Rather, every trace header and trace must be written to the file to be considered complete. Create should be used together with python's ``with`` statement. This ensure the data is written. Please refer to the examples. The ``segyio.spec()`` function will default sorting, offsets and everything in the mandatory group, except format and samples, and requires the caller to fill in *all* the fields in either of the exclusive groups. If any field is missing from the first exclusive group, and the tracecount is set, the resulting file will be considered unstructured. If the tracecount is set, and all fields of the first exclusive group are specified, the file is considered structured and the tracecount is inferred from the xlines/ilines/offsets. The offsets are defaulted to ``[1]`` by ``segyio.spec()``. Parameters ---------- filename : str Path to file to create spec : segyio.spec Structure of the segy file Returns ------- file : segyio.SegyFile An open segyio file handle, similar to that returned by `segyio.open` See also -------- segyio.spec : template for the `spec` argument Notes ----- .. versionadded:: 1.1 .. versionchanged:: 1.4 Support for creating unstructured files .. versionchanged:: 1.8 Support for creating lsb files The ``spec`` is any object that has the following attributes Mandatory:: iline : int or segyio.BinField xline : int or segyio.BinField samples : array of int format : { 1, 5 } 1 = IBM float, 5 = IEEE float Exclusive:: ilines : array_like of int xlines : array_like of int offsets : array_like of int sorting : int or segyio.TraceSortingFormat OR tracecount : int Optional:: ext_headers : int endian : str { 'big', 'msb', 'little', 'lsb' } defaults to 'big' Examples -------- Create a file: >>> spec = segyio.spec() >>> spec.ilines = [1, 2, 3, 4] >>> spec.xlines = [11, 12, 13] >>> spec.samples = list(range(50)) >>> spec.sorting = 2 >>> spec.format = 1 >>> with segyio.create(path, spec) as f: ... ## fill the file with data ... pass ... Copy a file, but shorten all traces by 50 samples: >>> with segyio.open(srcpath) as src: ... spec = segyio.spec() ... spec.sorting = src.sorting ... spec.format = src.format ... spec.samples = src.samples[:len(src.samples) - 50] ... spec.ilines = src.ilines ... spec.xline = src.xlines ... with segyio.create(dstpath, spec) as dst: ... dst.text[0] = src.text[0] ... dst.bin = src.bin ... dst.header = src.header ... dst.trace = src.trace Copy a file, but shorten all traces by 50 samples (since v1.4): >>> with segyio.open(srcpath) as src: ... spec = segyio.tools.metadata(src) ... spec.samples = spec.samples[:len(spec.samples) - 50] ... with segyio.create(dstpath, spec) as dst: ... dst.text[0] = src.text[0] ... dst.bin = src.bin ... dst.header = src.header ... dst.trace = src.trace """ from . import _segyio if not structured(spec): tracecount = spec.tracecount else: tracecount = len(spec.ilines) * len(spec.xlines) * len(spec.offsets) ext_headers = spec.ext_headers if hasattr(spec, 'ext_headers') else 0 samples = numpy.asarray(spec.samples) endians = { 'lsb': 256, # (1 << 8) 'little': 256, 'msb': 0, 'big': 0, } endian = spec.endian if hasattr(spec, 'endian') else 'big' if endian is None: endian = 'big' if endian not in endians: problem = 'unknown endianness {}, expected one of: ' opts = ' '.join(endians.keys()) raise ValueError(problem.format(endian) + opts) fd = _segyio.segyiofd(str(filename), 'w+', endians[endian]) fd.segymake( samples=len(samples), tracecount=tracecount, format=int(spec.format), ext_headers=int(ext_headers), ) f = segyio.SegyFile( fd, filename=str(filename), mode='w+', iline=int(spec.iline), xline=int(spec.xline), endian=endian, ) f._samples = samples if structured(spec): sorting = spec.sorting if hasattr(spec, 'sorting') else None if sorting is None: sorting = TraceSortingFormat.INLINE_SORTING f.interpret(spec.ilines, spec.xlines, spec.offsets, sorting) f.text[0] = default_text_header(f._il, f._xl, segyio.TraceField.offset) if len(samples) == 1: interval = int(samples[0] * 1000) else: interval = int((samples[1] - samples[0]) * 1000) f.bin.update( ntrpr=tracecount, nart=tracecount, hdt=interval, dto=interval, hns=len(samples), nso=len(samples), format=int(spec.format), exth=ext_headers, ) return f
def open(filename, mode="r", iline=189, xline=193): """Open a segy file. Opens a segy file and tries to figure out its sorting, inline numbers, crossline numbers, and offsets, and enables reading and writing to this file in a simple manner. For reading, the access mode "r" is preferred. All write operations will raise an exception. For writing, the mode "r+" is preferred (as "rw" would truncate the file). The modes used are standard C file modes; please refer to that documentation for a complete reference. Open should be used together with python's `with` statement. Please refer to the examples. When the `with` statement is used the file will automatically be closed when the routine completes or an exception is raised. Args: filename (str): Path to file to open. mode (str, optional): File access mode, defaults to "r". iline (TraceField): Inline number field in the trace headers. Defaults to 189 as per the SEGY specification. xline (TraceField): Crossline number field in the trace headers. Defaults to 193 as per the SEGY specification. Examples: Open a file in read-only mode:: >>> with segyio.open(path, "r") as f: ... print(f.ilines) ... Open a file in read-write mode:: >>> with segyio.open(path, "r+") as f: ... f.trace = np.arange(100) ... Open two files at once:: >>> with segyio.open(path) as src, segyio.open(path, "r+") as dst: ... dst.trace = src.trace # copy all traces from src to dst ... :rtype: segyio.SegyFile """ f = segyio.SegyFile(filename, mode, iline, xline) try: header = f.bin.buf metrics = segyio._segyio.init_metrics(f.xfd, header, iline, xline) f._samples = metrics['sample_count'] f._tr0 = metrics['trace0'] f._fmt = metrics['format'] f._bsz = metrics['trace_bsize'] f._ext_headers = (f._tr0 - 3600) / 3200 # should probably be from C f._tracecount = metrics['trace_count'] f._sorting = metrics['sorting'] f._offsets = metrics['offset_count'] iline_count, xline_count = metrics['iline_count'], metrics[ 'xline_count'] line_metrics = segyio._segyio.init_line_metrics( f.sorting, f.tracecount, iline_count, xline_count, f.offsets) f._ilines = numpy.zeros(iline_count, dtype=numpy.uintc) f._xlines = numpy.zeros(xline_count, dtype=numpy.uintc) segyio._segyio.init_line_indices(f.xfd, metrics, f.ilines, f.xlines) f._iline_length = line_metrics['iline_length'] f._iline_stride = line_metrics['iline_stride'] f._xline_length = line_metrics['xline_length'] f._xline_stride = line_metrics['xline_stride'] except: f.close() raise return f
def open(filename, mode="r", iline=189, xline=193, strict=True, ignore_geometry=False, endian='big'): """Open a segy file. Opens a segy file and tries to figure out its sorting, inline numbers, crossline numbers, and offsets, and enables reading and writing to this file in a simple manner. For reading, the access mode `r` is preferred. All write operations will raise an exception. For writing, the mode `r+` is preferred (as `rw` would truncate the file). Any mode with `w` will raise an error. The modes used are standard C file modes; please refer to that documentation for a complete reference. Open should be used together with python's ``with`` statement. Please refer to the examples. When the ``with`` statement is used the file will automatically be closed when the routine completes or an exception is raised. By default, segyio tries to open in ``strict`` mode. This means the file will be assumed to represent a geometry with consistent inline, crosslines and offsets. If strict is False, segyio will still try to establish a geometry, but it won't abort if it fails. When in non-strict mode is opened, geometry-dependent modes such as iline will raise an error. If ``ignore_geometry=True``, segyio will *not* try to build iline/xline or other geometry related structures, which leads to faster opens. This is essentially the same as using ``strict=False`` on a file that has no geometry. Parameters ---------- filename : str Path to file to open mode : {'r', 'r+'} File access mode, read-only ('r', default) or read-write ('r+') iline : int or segyio.TraceField Inline number field in the trace headers. Defaults to 189 as per the SEG-Y rev1 specification xline : int or segyio.TraceField Crossline number field in the trace headers. Defaults to 193 as per the SEG-Y rev1 specification strict : bool, optional Abort if a geometry cannot be inferred. Defaults to True. ignore_geometry : bool, optional Opt out on building geometry information, useful for e.g. shot organised files. Defaults to False. endian : {'big', 'msb', 'little', 'lsb'} File endianness, big/msb (default) or little/lsb Returns ------- file : segyio.SegyFile An open segyio file handle Raises ------ ValueError If the mode string contains 'w', as it would truncate the file Notes ----- .. versionadded:: 1.1 .. versionchanged:: 1.8 endian argument When a file is opened non-strict, only raw traces access is allowed, and using modes such as ``iline`` raise an error. Examples -------- Open a file in read-only mode: >>> with segyio.open(path, "r") as f: ... print(f.ilines) ... [1, 2, 3, 4, 5] Open a file in read-write mode: >>> with segyio.open(path, "r+") as f: ... f.trace = np.arange(100) Open two files at once: >>> with segyio.open(path) as src, segyio.open(path, "r+") as dst: ... dst.trace = src.trace # copy all traces from src to dst Open a file little-endian file: >>> with segyio.open(path, endian = 'little') as f: ... f.trace[0] """ if 'w' in mode: problem = 'w in mode would truncate the file' solution = 'use r+ to open in read-write' raise ValueError(', '.join((problem, solution))) endians = { 'little': 256, # (1 << 8) 'lsb': 256, 'big': 0, 'msb': 0, } if endian not in endians: problem = 'unknown endianness {}, expected one of: ' opts = ' '.join(endians.keys()) raise ValueError(problem.format(endian) + opts) from . import _segyio fd = _segyio.segyiofd(str(filename), mode, endians[endian]) fd.segyopen() metrics = fd.metrics() f = segyio.SegyFile( fd, filename=str(filename), mode=mode, iline=iline, xline=xline, endian=endian, ) try: dt = segyio.tools.dt(f, fallback_dt=4000.0) / 1000.0 t0 = f.header[0][segyio.TraceField.DelayRecordingTime] samples = metrics['samplecount'] f._samples = (numpy.arange(samples) * dt) + t0 except: f.close() raise if ignore_geometry: return f return infer_geometry(f, metrics, iline, xline, strict)