Merge pull request #650 from achaikou/field_mappings_open

Open file with shifted layout

Author: achaikou

lib/include/segyio/segy.h

@@ -550,7 +550,7 @@ int segy_field_forall( segy_datasource*,
                        int start,
                        int stop,
                        int step,
-                       int* buf,
+                       void* buf,
                        long trace0,
                        int trace_bsize );
 
@@ -821,7 +821,7 @@ int segy_inline_indices( segy_datasource*,
                          int inline_count,
                          int crossline_count,
                          int offsets,
-                         int* buf,
+                         void* buf,
                          long trace0,
                          int trace_bsize );
 
@@ -831,7 +831,7 @@ int segy_crossline_indices( segy_datasource*,
                             int inline_count,
                             int crossline_count,
                             int offsets,
-                            int* buf,
+                            void* buf,
                             long trace0,
                             int trace_bsize );
 

lib/src/segy.c

@@ -1377,68 +1377,116 @@ static int slicelength( int start, int stop, int step ) {
     return (stop - start - 1) / step + 1;
 }
 
-static int32_t bswap_header_word(int32_t f, int word_size) {
-    if (word_size == 4)
-        return bswap32(f);
+static int bswap_header_word( segy_field_data* fd ) {
+    uint8_t datatype = entry_type_to_datatype_map[fd->entry_type];
+    switch( datatype ) {
+        case SEGY_SIGNED_INTEGER_8_BYTE:
+            fd->value.i64 = bswap64( fd->value.i64 );
+            return SEGY_OK;
 
-    /*
-     * The casts are here are necessary
-     *
-     * First, it must be converted to a *signed* short (to preserve negative
-     * numbers). The narrowing is safe because the source is 2 bytes anyway.
-     *
-     * The behaviour when this is implicitly wrong was discovered in [1].
-     *
-     * Then, it must be byteswapped with bswap16. When using the shifts is
-     * probably fine as the types are also cast in the macro and are
-     * compatible, but the builtins have this signature [2]:
-     *
-     *  uint16_t __builtin_bswap16 (uint16_t x)
-     *
-     * which means that if the value is *negative* it will be interpreted as
-     * unsigned and very much positive. When it is then implicitly converted
-     * in the return type it is widened, and int32 can fit uint16 maximum just
-     * fine.
-     *
-     * [1] https://github.com/equinor/segyio/issues/368
-     * [2] http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
-     */
-    return (int16_t) bswap16((int16_t) f);
+        case SEGY_SIGNED_INTEGER_4_BYTE:
+            fd->value.i32 = bswap32( fd->value.i32 );
+            return SEGY_OK;
+
+        case SEGY_SIGNED_SHORT_2_BYTE:
+            fd->value.i16 = bswap16( fd->value.i16 );
+            return SEGY_OK;
+
+        case SEGY_UNSIGNED_INTEGER_8_BYTE:
+            fd->value.u64 = bswap64( fd->value.u64 );
+            return SEGY_OK;
+
+        case SEGY_UNSIGNED_INTEGER_4_BYTE:
+            fd->value.u32 = bswap32( fd->value.u32 );
+            return SEGY_OK;
+
+        case SEGY_UNSIGNED_SHORT_2_BYTE:
+            fd->value.u16 = bswap16( fd->value.u16 );
+            return SEGY_OK;
+
+        case SEGY_UNSIGNED_CHAR_1_BYTE:
+        case SEGY_SIGNED_CHAR_1_BYTE:
+            return SEGY_OK;
+        default:
+            return SEGY_INVALID_FIELD_DATATYPE;
+    }
 }
 
 int segy_field_forall( segy_datasource* ds,
                        int field,
                        int start,
                        int stop,
                        int step,
-                       int* buf,
+                       void* buffer,
                        long trace0,
                        int trace_bsize ) {
     int err;
+    char* buf = (char*)buffer;
+
     // do a dummy-read of a zero-init'd buffer to check args
-    int32_t f;
-    char header[ SEGY_TRACE_HEADER_SIZE ] = { 0 };
-    err = segy_get_tracefield_int( header, field, &f );
+    segy_field_data fd;
+    char header[SEGY_TRACE_HEADER_SIZE] = { 0 };
+
+    const segy_entry_definition* offset_map =
+        ds->traceheader_mapping_standard.offset_to_entry_definition;
+    err = segy_get_tracefield( header, offset_map, field, &fd );
     if( err != SEGY_OK ) return SEGY_INVALID_ARGS;
 
     int slicelen = slicelength( start, stop, step );
+    int elemsize = segy_formatsize( entry_type_to_datatype_map[fd.entry_type] );
 
     const int zfield = field - 1;
-    for( int i = start; slicelen > 0; i += step, ++buf, --slicelen ) {
-        err = segy_seek( ds, i, trace0 + zfield, trace_bsize );
+    for( int i = start; slicelen > 0; i += step, buf += elemsize, --slicelen ) {
+        int offset = trace0 + zfield;
+        err = segy_seek( ds, i, offset, trace_bsize );
         if( err != SEGY_OK ) return err;
-        err = ds->read( ds, header + zfield, sizeof( uint32_t ) );
+        err = ds->read( ds, header + zfield, elemsize );
         if( err != 0 ) return SEGY_DS_READ_ERROR;
 
-        // note: for the moment function still works only on ints
-        err = segy_get_tracefield_int( header, field, &f );
+        err = segy_get_tracefield( header, offset_map, field, &fd );
         if( err != 0 ) return err;
-        const uint8_t entry_type = traceheader_default_map[zfield].entry_type;
-        const uint8_t datatype = entry_type_to_datatype_map[entry_type];
-        if( ds->metadata.endianness == SEGY_LSB) {
-            f = bswap_header_word( f, segy_formatsize( datatype ) );
+
+        if( ds->metadata.endianness == SEGY_LSB ) {
+            err = bswap_header_word( &fd );
+            if( err != SEGY_OK ) return err;
+        }
+
+        switch( entry_type_to_datatype_map[fd.entry_type] ) {
+            case SEGY_SIGNED_INTEGER_8_BYTE:
+                memcpy( buf, &fd.value.i64, elemsize );
+                break;
+
+            case SEGY_SIGNED_INTEGER_4_BYTE:
+                memcpy( buf, &fd.value.i32, elemsize );
+                break;
+
+            case SEGY_SIGNED_SHORT_2_BYTE:
+                memcpy( buf, &fd.value.i16, elemsize );
+                break;
+
+            case SEGY_SIGNED_CHAR_1_BYTE:
+                memcpy( buf, &fd.value.i8, elemsize );
+                break;
+
+            case SEGY_UNSIGNED_INTEGER_8_BYTE:
+                memcpy( buf, &fd.value.u64, elemsize );
+                break;
+
+            case SEGY_UNSIGNED_INTEGER_4_BYTE:
+                memcpy( buf, &fd.value.u32, elemsize );
+                break;
+
+            case SEGY_UNSIGNED_SHORT_2_BYTE:
+                memcpy( buf, &fd.value.u16, elemsize );
+                break;
+
+            case SEGY_UNSIGNED_CHAR_1_BYTE:
+                memcpy( buf, &fd.value.u8, elemsize );
+                break;
+
+            default:
+                return SEGY_INVALID_FIELD_DATATYPE;
         }
-        *buf = f;
     }
 
     return SEGY_OK;
@@ -2117,7 +2165,7 @@ static int segy_line_indices( segy_datasource* ds,
                               int traceno,
                               int stride,
                               int num_indices,
-                              int* buf,
+                              void* buf,
                               long trace0,
                               int trace_bsize ) {
     return segy_field_forall( ds,
@@ -2281,7 +2329,7 @@ int segy_inline_indices( segy_datasource* ds,
                          int inline_count,
                          int crossline_count,
                          int offsets,
-                         int* buf,
+                         void* buf,
                          long trace0,
                          int trace_bsize) {
 
@@ -2303,7 +2351,7 @@ int segy_crossline_indices( segy_datasource* ds,
                             int inline_count,
                             int crossline_count,
                             int offsets,
-                            int* buf,
+                            void* buf,
                             long trace0,
                             int trace_bsize ) {
 

python/segyio/__init__.py

@@ -63,6 +63,8 @@ def __hash__(self):
         return hash(self._value)
 
     def __eq__(self, other):
+        if other is None:
+            return False
         try:
             o = int(other)
         except ValueError:

python/segyio/create.py

@@ -247,10 +247,11 @@ def _create(datasource_descriptor, spec):
         ext_headers = int(ext_headers),
     )
 
+    # note: even if iline/xline are overridden, file is already created with
+    # standard iline/xline position, so those can mismatch
+
     f = segyio.SegyFile(fd,
             datasource_descriptor,
-            iline = int(spec.iline),
-            xline = int(spec.xline),
             endian = endian,
     )
 

python/segyio/open.py

@@ -38,8 +38,8 @@ def infer_geometry(f, metrics, strict):
     return f
 
 
-def open(filename, mode="r", iline = 189,
-                             xline = 193,
+def open(filename, mode="r", iline = None,
+                             xline = None,
                              strict = True,
                              ignore_geometry = False,
                              endian = None,
@@ -82,12 +82,16 @@ def open(filename, mode="r", iline = 189,
         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
+        Overrides inline field offset in the trace headers. If no value is set,
+        value defined in xml mapping is used and if this one is absent the
+        standard-defined value 189 is used. By setting this value user takes
+        over responsibility of assuring parsing can be done correctly.
 
     xline : int or segyio.TraceField
-        Crossline number field in the trace headers. Defaults to 193 as per the
-        SEG-Y rev1 specification
+        Overrides crossline field offset in the trace headers. If no value is
+        set, value defined in xml mapping is used and if this one is absent the
+        standard-defined value 193 is used. By setting this value user takes
+        over responsibility of assuring parsing can be done correctly.
 
     strict : bool, optional
         Abort if a geometry cannot be inferred. Defaults to True.
@@ -169,8 +173,8 @@ def open(filename, mode="r", iline = 189,
 
 
 def open_with(stream,
-              iline=189,
-              xline=193,
+              iline=None,
+              xline=None,
               strict=True,
               ignore_geometry=False,
               endian=None,
@@ -210,8 +214,8 @@ def open_with(stream,
 
 
 def open_from_memory(memory_buffer,
-                   iline=189,
-                   xline=193,
+                   iline=None,
+                   xline=None,
                    strict=True,
                    ignore_geometry=False,
                    endian=None,
@@ -242,27 +246,31 @@ def open_from_memory(memory_buffer,
 
 
 def _open(datasource_descriptor,
-          iline=189,
-          xline=193,
+          iline=None,
+          xline=None,
           strict=True,
           ignore_geometry=False,
           endian=None,
           encoding=None,
           ):
 
     fd = datasource_descriptor.make_segyfile_descriptor()
+
+    if iline != None:
+        iline = int(iline)
+    if xline != None:
+        xline = int(xline)
+
     fd.segyopen(
         endianness=to_c_endianness(endian),
         encoding=to_c_encoding(encoding),
-        iline=int(iline),
-        xline=int(xline)
+        iline=iline,
+        xline=xline
     )
     metrics = fd.metrics()
 
     f = segyio.SegyFile(fd,
             datasource_descriptor,
-            iline = int(iline),
-            xline = int(xline),
             endian = endian,
     )
 

python/segyio/segy.py

@@ -27,14 +27,15 @@ def __init__(
         self,
         fd,
         datasource_descriptor,
-        iline=189,
-        xline=193,
         endian='big'
     ):
 
         self._datasource_descriptor = datasource_descriptor
-        self._il = iline
-        self._xl = xline
+
+        self._traceheader_layouts = fd.traceheader_layouts()
+        standard_header_layout = self._traceheader_layouts["SEG00000"]
+        self._il = standard_header_layout.entry_by_name("iline").byte
+        self._xl = standard_header_layout.entry_by_name("xline").byte
 
         # property value holders
         self._ilines = None
@@ -415,7 +416,8 @@ def attributes(self, field):
         .. versionadded:: 1.1
 
         """
-        return Attributes(field, self.segyfd, self.tracecount)
+        traceheader_layout = self._traceheader_layouts["SEG00000"]
+        return Attributes(field, self.segyfd, traceheader_layout, self.tracecount)
 
     @property
     def trace(self):