Skip to content

Segy field data cleanup #636

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
achaikou merged 10 commits into from
Jul 29, 2025
Merged

Segy field data cleanup #636

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
82ef437
Remove int-[type] specific get-set field functions
achaikou Jul 4, 2025
a19565c
Remove segy_field_data_to_int
achaikou Jul 24, 2025
e49f3a5
Move some functions to better places
achaikou Jul 17, 2025
bbb0c1b
Reuse general field get/set in their int versions
achaikou Jul 24, 2025
e17c97a
Unify segy_get/set_field and get/set_field
achaikou Jul 24, 2025
3f3061f
Directly pass field argument to segy_get/set_field
achaikou Jul 25, 2025
cd62426
Remove unused members from segy_field_data
achaikou Jul 25, 2025
b9e3f3d
Turn segy_init_field_data into segy_field_datatype
achaikou Jul 25, 2025
033b287
Check datatype match inside segy_set_field
achaikou Jul 25, 2025
b7837d5
Disable building wheels on python 3.14
achaikou Jul 25, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 8 additions & 8 deletions applications/segyinfo.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,10 +8,10 @@

static void printSegyTraceInfo( const char* buf ) {
int cdp, tsf, xl, il;
segy_get_field_i32( buf, SEGY_TR_ENSEMBLE, &cdp );

@yngve793 yngve793 Jul 28, 2025

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Type specific functions was added by POs request.

segy_get_field_i32( buf, SEGY_TR_SEQ_FILE, &tsf );
segy_get_field_i32( buf, SEGY_TR_CROSSLINE, &xl );
segy_get_field_i32( buf, SEGY_TR_INLINE, &il );
segy_get_field_int( buf, SEGY_TR_ENSEMBLE, &cdp );
segy_get_field_int( buf, SEGY_TR_SEQ_FILE, &tsf );
segy_get_field_int( buf, SEGY_TR_CROSSLINE, &xl );
segy_get_field_int( buf, SEGY_TR_INLINE, &il );

printf("cdp: %d\n", cdp );
printf("TraceSequenceFile: %d\n", tsf );
Expand Down Expand Up @@ -55,8 +55,8 @@ int main(int argc, char* argv[]) {
const int samples = segy_samples( header );
const long trace0 = segy_trace0( header );
const int trace_bsize = segy_trace_bsize( samples );
int16_t extended_headers;
err = segy_get_field_i16( header, SEGY_BIN_EXT_HEADERS, &extended_headers );
int extended_headers;
err = segy_get_field_int( header, SEGY_BIN_EXT_HEADERS, &extended_headers );

if( err != 0 ) {
perror( "Can't read 'extended headers' field from binary header" );
Expand Down Expand Up @@ -113,8 +113,8 @@ int main(int argc, char* argv[]) {
exit( err );
}

int16_t sample_count;
err = segy_get_field_i16( traceh, SEGY_TR_SAMPLE_COUNT, &sample_count );
int sample_count;
err = segy_get_field_int( traceh, SEGY_TR_SAMPLE_COUNT, &sample_count );

if( err != 0 ) {
fprintf( stderr, "Invalid trace header field: %d\n", SEGY_TR_SAMPLE_COUNT );
Expand Down
4 changes: 2 additions & 2 deletions applications/segyio-cath.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,8 +34,8 @@ static int ext_headers( segy_file* fp ) {

if( err ) return -1;

int16_t ext;
err = segy_get_field_i16( binary, SEGY_BIN_EXT_HEADERS, &ext );
int ext;
err = segy_get_field_int( binary, SEGY_BIN_EXT_HEADERS, &ext );
if( err ) return -2;
return ext;
}
Expand Down
26 changes: 13 additions & 13 deletions applications/segyio-crop.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -51,10 +51,10 @@ static struct delay delay_recording_time( const char* trheader,
int dt,
int samples ) {

int16_t t0;
segy_get_field_i16( trheader, SEGY_TR_DELAY_REC_TIME, &t0 );
int16_t trdt;
segy_get_field_i16( trheader, SEGY_TR_SAMPLE_INTER, &trdt );
int t0;
segy_get_field_int( trheader, SEGY_TR_DELAY_REC_TIME, &t0 );
int trdt;
segy_get_field_int( trheader, SEGY_TR_SAMPLE_INTER, &trdt );
if( trdt ) dt = trdt;

/*
Expand Down Expand Up @@ -408,8 +408,8 @@ int main( int argc, char** argv ) {
if( sz != 1 ) exit( errmsg2( errno, "Unable to write binary header",
strerror( errno ) ) );

int16_t ext_headers;
int err = segy_get_field_i16(binheader, SEGY_BIN_EXT_HEADERS, &ext_headers);
int ext_headers;
int err = segy_get_field_int(binheader, SEGY_BIN_EXT_HEADERS, &ext_headers);
if( err != SEGY_OK ) exit( errmsg( -1, "Malformed binary header" ) );

for( int i = 0; i < ext_headers; ++i ) {
Expand All @@ -424,10 +424,10 @@ int main( int argc, char** argv ) {
}

if( verbosity > 2 ) puts( "Computing samples-per-trace" );
int16_t bindt;
segy_get_field_i16( binheader, SEGY_BIN_INTERVAL, &bindt );
uint16_t src_samples;
err = segy_get_field_u16( binheader, SEGY_BIN_SAMPLES, &src_samples );
int bindt;
segy_get_field_int( binheader, SEGY_BIN_INTERVAL, &bindt );
int src_samples;
err = segy_get_field_int( binheader, SEGY_BIN_SAMPLES, &src_samples );
if( err != SEGY_OK )
exit( errmsg( -2, "Could not determine samples per trace" ) );

Expand Down Expand Up @@ -514,9 +514,9 @@ int main( int argc, char** argv ) {
bindt,
src_samples );

segy_set_field_u16( trheader, SEGY_TR_SAMPLE_COUNT, d.len );
segy_set_field_i16( trheader, SEGY_TR_DELAY_REC_TIME, d.delay );
segy_set_field_u16( binheader, SEGY_BIN_SAMPLES, d.len );
segy_set_field_int( trheader, SEGY_TR_SAMPLE_COUNT, d.len );
segy_set_field_int( trheader, SEGY_TR_DELAY_REC_TIME, d.delay );
segy_set_field_int( binheader, SEGY_BIN_SAMPLES, d.len );

if( verbosity > 2 ) printf( "Copying trace %lld\n", traces );
sz = fwrite( trheader, TRHSIZE, 1, dst );
Expand Down
16 changes: 3 additions & 13 deletions lib/include/segyio/segy.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -204,23 +204,13 @@ int segy_set_endianness( segy_datasource*, int opt );
*/
int segy_init_field_data(int field, segy_field_data* fd);

int segy_get_field_u8( const char* header, int field, uint8_t* val );
int segy_get_field_u16( const char* header, int field, uint16_t* val );
int segy_get_field_u64( const char* header, int field, uint64_t* val );
int segy_get_field_i16( const char* header, int field, int16_t* val );
int segy_get_field_i32( const char* header, int field, int32_t* val );
int segy_get_field_f64( const char* header, int field, double* val );
int segy_get_field_int( const char* header, int field, int* f );
segy_field_data segy_get_field( const char* header, int field);
int segy_set_field( char* header, segy_field_data* fd );

int segy_field_data_to_int( const segy_field_data* fd, int* val );

int segy_set_field_i16( char* header, const int field, const int16_t val );
int segy_set_field_i32( char* header, const int field, const int32_t val );
int segy_set_field_u16( char* header, const int field, const uint16_t val );
int segy_set_field_u64( char* header, const int field, const uint64_t val );
int segy_set_field_f64( char* header, const int field, const double val );
int segy_get_field_int( const char* header, int field, int* f );
int segy_set_field_int( char* header, const int field, const int val );
int segy_set_field( char* header, segy_field_data* fd );

int segy_field_forall( segy_datasource*,
int field,
Expand Down
170 changes: 19 additions & 151 deletions lib/src/segy.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -916,78 +916,6 @@ int segy_init_field_data(int field, segy_field_data* fd) {
return SEGY_OK;
}

int segy_get_field_u8( const char* header, int field, uint8_t* val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;
err = get_field( header, &fd );
if( err != SEGY_OK ) return err;
if ( fd.datatype != SEGY_UNSIGNED_CHAR_1_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;
*val = fd.value.u8;
return SEGY_OK;
}

int segy_get_field_u16( const char* header, int field, uint16_t* val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;
err = get_field( header, &fd );
if( err != SEGY_OK ) return err;
if ( fd.datatype != SEGY_UNSIGNED_SHORT_2_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;
*val = fd.value.u16;
return SEGY_OK;
}

int segy_get_field_u64( const char* header, int field, uint64_t* val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;
err = get_field( header, &fd );
if( err != SEGY_OK ) return err;
if ( fd.datatype != SEGY_UNSIGNED_INTEGER_8_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;
*val = fd.value.u64;
return SEGY_OK;
}

int segy_get_field_i16( const char* header, int field, int16_t* val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;
err = get_field( header, &fd );
if( err != SEGY_OK ) return err;
if ( fd.datatype != SEGY_SIGNED_SHORT_2_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;
*val = fd.value.i16;
return SEGY_OK;
}

int segy_get_field_i32( const char* header, int field, int32_t* val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;
err = get_field( header, &fd );
if( err != SEGY_OK ) return err;
if ( fd.datatype != SEGY_SIGNED_INTEGER_4_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;
*val = fd.value.i32;
return SEGY_OK;
}

int segy_get_field_f64( const char* header, int field, double* val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;
err = get_field( header, &fd );
if( err != SEGY_OK ) return err;
if ( fd.datatype != SEGY_IEEE_FLOAT_8_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;
*val = fd.value.f64;
return SEGY_OK;
}

int segy_get_field_int( const char* header, int field, int* val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
Expand Down Expand Up @@ -1098,66 +1026,6 @@ static int fd_set_int( segy_field_data* fd, int val ) {
}
}

int segy_set_field_i16( char* header, const int field, const int16_t val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;

if ( fd.datatype != SEGY_SIGNED_SHORT_2_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;

fd.value.i16 = val;
return set_field( header, &fd );
}

int segy_set_field_i32( char* header, const int field, const int32_t val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;

if ( fd.datatype != SEGY_SIGNED_INTEGER_4_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;

fd.value.i32 = val;
return set_field( header, &fd );
}

int segy_set_field_u16( char* header, const int field, const uint16_t val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;

if ( fd.datatype != SEGY_UNSIGNED_SHORT_2_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;

fd.value.u16 = val;
return set_field( header, &fd );
}

int segy_set_field_u64( char* header, const int field, const uint64_t val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;

if ( fd.datatype != SEGY_UNSIGNED_INTEGER_8_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;

fd.value.u64 = val;
return set_field( header, &fd );
}

int segy_set_field_f64( char* header, const int field, const double val ) {
segy_field_data fd;
int err = segy_init_field_data( field, &fd );
if ( err != SEGY_OK ) return err;

if ( fd.datatype != SEGY_IEEE_FLOAT_8_BYTE )
return SEGY_INVALID_FIELD_DATATYPE;

fd.value.f64 = val;
return set_field( header, &fd );
}

int segy_set_field_int( char* header, const int field, const int val ) {

segy_field_data fd;
Expand Down Expand Up @@ -1345,8 +1213,8 @@ int segy_write_binheader( segy_datasource* ds, const char* buf ) {
}

int segy_format( const char* binheader ) {
int16_t format = 0;
segy_get_field_i16( binheader, SEGY_BIN_FORMAT, &format );
int format = 0;
segy_get_field_int( binheader, SEGY_BIN_FORMAT, &format );
return format;
}

Expand All @@ -1372,12 +1240,12 @@ int segy_set_endianness( segy_datasource* ds, int endianness) {
}

int segy_samples( const char* binheader ) {
uint16_t samples = 0;
segy_get_field_u16( binheader, SEGY_BIN_SAMPLES, &samples );
int samples = 0;
segy_get_field_int( binheader, SEGY_BIN_SAMPLES, &samples );
samples = (int32_t)((uint16_t)samples);

int32_t ext_samples = 0;
segy_get_field_i32(binheader, SEGY_BIN_EXT_SAMPLES, &ext_samples);
int ext_samples = 0;
segy_get_field_int(binheader, SEGY_BIN_EXT_SAMPLES, &ext_samples);

if (samples == 0 && ext_samples > 0)
return ext_samples;
Expand All @@ -1393,8 +1261,8 @@ int segy_samples( const char* binheader ) {
* used, the revision flag is also appropriately set to >= 2. Negative
* values are ignored, as it's likely just noise.
*/
uint8_t revision = 0;
segy_get_field_u8(binheader, SEGY_BIN_SEGY_REVISION, &revision);
int revision = 0;
segy_get_field_int(binheader, SEGY_BIN_SEGY_REVISION, &revision);
if (revision >= 2 && ext_samples > 0)
return ext_samples;

Expand All @@ -1413,8 +1281,8 @@ int segy_trsize( int format, int samples ) {
}

long segy_trace0( const char* binheader ) {
int16_t extra_headers = 0;
segy_get_field_i16( binheader, SEGY_BIN_EXT_HEADERS, &extra_headers );
int extra_headers = 0;
segy_get_field_int( binheader, SEGY_BIN_EXT_HEADERS, &extra_headers );

return SEGY_TEXT_HEADER_SIZE + SEGY_BINARY_HEADER_SIZE +
SEGY_TEXT_HEADER_SIZE * extra_headers;
Expand Down Expand Up @@ -1621,11 +1489,11 @@ int segy_sample_interval( segy_datasource* ds, float fallback, float* dt ) {
return err;
}

int16_t bindt = 0;
int16_t trdt = 0;
int bindt = 0;
int trdt = 0;

segy_get_field_i16( bin_header, SEGY_BIN_INTERVAL, &bindt );
segy_get_field_i16( trace_header, SEGY_TR_SAMPLE_INTER, &trdt );
segy_get_field_int( bin_header, SEGY_BIN_INTERVAL, &bindt );
segy_get_field_int( trace_header, SEGY_TR_SAMPLE_INTER, &trdt );

float binary_header_dt = (float) bindt;
float trace_header_dt = (float) trdt;
Expand Down Expand Up @@ -2672,18 +2540,18 @@ static int scaled_cdp( segy_datasource* ds,
float* cdpy,
long trace0,
int trace_bsize ) {
int32_t x, y;
int16_t scalar;
int x, y;
int scalar;
char trheader[ SEGY_TRACE_HEADER_SIZE ];

int err = segy_traceheader( ds, traceno, trheader, trace0, trace_bsize );
if( err != 0 ) return err;

err = segy_get_field_i32( trheader, SEGY_TR_CDP_X, &x );
err = segy_get_field_int( trheader, SEGY_TR_CDP_X, &x );
if( err != 0 ) return err;
err = segy_get_field_i32( trheader, SEGY_TR_CDP_Y, &y );
err = segy_get_field_int( trheader, SEGY_TR_CDP_Y, &y );
if( err != 0 ) return err;
err = segy_get_field_i16( trheader, SEGY_TR_SOURCE_GROUP_SCALAR, &scalar );
err = segy_get_field_int( trheader, SEGY_TR_SOURCE_GROUP_SCALAR, &scalar );
if( err != 0 ) return err;

float scale = (float) scalar;
Expand Down
7 changes: 0 additions & 7 deletions lib/src/segy.def
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,14 +12,7 @@ segy_sample_interval
segy_format
segy_set_format
segy_set_endianness
segy_get_field_u8
segy_get_field_u16
segy_get_field_i16
segy_get_field_i32
segy_get_field_int
segy_set_field_u16
segy_set_field_i16
segy_set_field_i32
segy_set_field_int
segy_field_forall
segy_trace_bsize
Expand Down
Loading