1 : /******************************************************************************
2 : * $Id: ogrsegylayer.cpp 23292 2011-10-30 09:16:40Z rouault $
3 : *
4 : * Project: SEG-Y Translator
5 : * Purpose: Implements OGRSEGYLayer class.
6 : * Author: Even Rouault, <even dot rouault at mines dash paris dot org>
7 : *
8 : ******************************************************************************
9 : * Copyright (c) 2011, Even Rouault <even dot rouault at mines dash paris dot org>
10 : *
11 : * Permission is hereby granted, free of charge, to any person obtaining a
12 : * copy of this software and associated documentation files (the "Software"),
13 : * to deal in the Software without restriction, including without limitation
14 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 : * and/or sell copies of the Software, and to permit persons to whom the
16 : * Software is furnished to do so, subject to the following conditions:
17 : *
18 : * The above copyright notice and this permission notice shall be included
19 : * in all copies or substantial portions of the Software.
20 : *
21 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMSEGYS OR OTHER
25 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27 : * DEALINGS IN THE SOFTWARE.
28 : ****************************************************************************/
29 :
30 : #include "ogr_segy.h"
31 : #include "cpl_conv.h"
32 : #include "cpl_string.h"
33 : #include "ogr_p.h"
34 : #include "ogr_srs_api.h"
35 :
36 : CPL_CVSID("$Id: ogrsegylayer.cpp 23292 2011-10-30 09:16:40Z rouault $");
37 :
38 : #define DT_IBM_4BYTES_FP 1
39 : #define DT_4BYTES_INT 2
40 : #define DT_2BYTES_INT 3
41 : #define DT_4BYTES_FP_WITH_GAIN 4
42 : #define DT_IEEE_4BYTES_FP 5
43 : #define DT_1BYTE_INT 8
44 :
45 : typedef struct
46 : {
47 : const char* pszName;
48 : OGRFieldType eType;
49 : } FieldDesc;
50 :
51 : static const FieldDesc SEGYFields[] =
52 : {
53 : { "TRACE_NUMBER_WITHIN_LINE", OFTInteger },
54 : { "TRACE_NUMBER_WITHIN_FILE", OFTInteger },
55 : { "ORIGINAL_FIELD_RECORD_NUMBER", OFTInteger },
56 : { "TRACE_NUMBER_WITHIN_ORIGINAL_FIELD_RECORD", OFTInteger },
57 : { "TRACE_IDENTIFICATION_CODE", OFTInteger },
58 : { "ENSEMBLE_NUMBER", OFTInteger },
59 : { "TRACE_NUMBER_WITHIN_ENSEMBLE", OFTInteger },
60 : { "NUMBER_VERTICAL_SUMMED_TRACES", OFTInteger },
61 : { "NUMBER_HORIZONTAL_STACKED_TRACES", OFTInteger },
62 : { "DATA_USE", OFTInteger },
63 : { "DISTANCE_SOURCE_GROUP", OFTInteger },
64 : { "RECEIVER_GROUP_ELEVATION", OFTInteger },
65 : { "SURFACE_ELEVATION_AT_SOURCE", OFTInteger },
66 : { "SOURCE_DEPTH_BELOW_SURFACE", OFTInteger },
67 : { "DATUM_ELEVATION_AT_RECEIVER_GROUP", OFTInteger },
68 : { "DATUM_ELEVATION_AT_SOURCE", OFTInteger },
69 : { "WATER_DEPTH_AT_SOURCE", OFTInteger },
70 : { "WATER_DEPTH_AT_GROUP", OFTInteger },
71 : { "VERTICAL_SCALAR", OFTInteger },
72 : { "HORIZONTAL_SCALAR", OFTInteger },
73 : { "SOURCE_X", OFTInteger },
74 : { "SOURCE_Y", OFTInteger },
75 : { "GROUP_X", OFTInteger },
76 : { "GROUP_Y", OFTInteger },
77 : { "COORDINATE_UNITS", OFTInteger },
78 : { "WEATHERING_VELOCITY", OFTInteger },
79 : { "SUB_WEATHERING_VELOCITY", OFTInteger },
80 : { "UPHOLE_TIME_AT_SOURCE", OFTInteger },
81 : { "UPHOLE_TIME_AT_GROUP", OFTInteger },
82 : { "SOURCE_STATIC_CORRECTION", OFTInteger },
83 : { "GROUP_STATIC_CORRECTION", OFTInteger },
84 : { "TOTAL_STATIC_CORRECTION", OFTInteger },
85 : { "LAG_TIME_A", OFTInteger },
86 : { "LAG_TIME_B", OFTInteger },
87 : { "DELAY_RECORDING_TIME", OFTInteger },
88 : { "MUTE_TIME_START", OFTInteger },
89 : { "MUTE_TIME_END", OFTInteger },
90 : { "SAMPLES", OFTInteger },
91 : { "SAMPLE_INTERVAL", OFTInteger },
92 : { "GAIN_TYPE", OFTInteger },
93 : { "INSTRUMENT_GAIN_CONSTANT", OFTInteger },
94 : { "INSTRUMENT_INITIAL_GAIN", OFTInteger },
95 : { "CORRELATED", OFTInteger },
96 : { "SWEEP_FREQUENCY_AT_START", OFTInteger },
97 : { "SWEEP_FREQUENCY_AT_END", OFTInteger },
98 : { "SWEEP_LENGTH", OFTInteger },
99 : { "SWEEP_TYPE", OFTInteger },
100 : { "SWEEP_TRACE_TAPER_LENGTH_AT_START", OFTInteger },
101 : { "SWEEP_TRACE_TAPER_LENGTH_AT_END", OFTInteger },
102 : { "TAPER_TYPE", OFTInteger },
103 : { "ALIAS_FILTER_FREQUENCY", OFTInteger },
104 : { "ALIAS_FILTER_SLOPE", OFTInteger },
105 : { "NOTCH_FILTER_FREQUENCY", OFTInteger },
106 : { "NOTCH_FILTER_SLOPE", OFTInteger },
107 : { "LOW_CUT_FREQUENCY", OFTInteger },
108 : { "HIGH_CUT_FREQUENCY", OFTInteger },
109 : { "LOW_CUT_SLOPE", OFTInteger },
110 : { "HIGH_CUT_SLOPE", OFTInteger },
111 : { "YEAR", OFTInteger },
112 : { "DAY_OF_YEAR", OFTInteger },
113 : { "HOUR", OFTInteger },
114 : { "MINUTE", OFTInteger },
115 : { "SECOND", OFTInteger },
116 : { "TIME_BASIC_CODE", OFTInteger },
117 : { "TRACE_WEIGHTING_FACTOR", OFTInteger },
118 : { "GEOPHONE_GROUP_NUMBER_OF_ROLL_SWITH", OFTInteger },
119 : { "GEOPHONE_GROUP_NUMBER_OF_TRACE_NUMBER_ONE", OFTInteger },
120 : { "GEOPHONE_GROUP_NUMBER_OF_LAST_TRACE", OFTInteger },
121 : { "GAP_SIZE", OFTInteger },
122 : { "OVER_TRAVEL", OFTInteger },
123 : };
124 :
125 : /* SEGY >= 1.0 */
126 : static const FieldDesc SEGYFields10[] =
127 : {
128 : { "INLINE_NUMBER", OFTInteger },
129 : { "CROSSLINE_NUMBER", OFTInteger },
130 : { "SHOTPOINT_NUMBER", OFTInteger },
131 : { "SHOTPOINT_SCALAR", OFTInteger },
132 : };
133 :
134 : #define TRACE_NUMBER_WITHIN_LINE 0
135 : #define TRACE_NUMBER_WITHIN_FILE 1
136 : #define ORIGINAL_FIELD_RECORD_NUMBER 2
137 : #define TRACE_NUMBER_WITHIN_ORIGINAL_FIELD_RECORD 3
138 : #define TRACE_IDENTIFICATION_CODE 4
139 : #define ENSEMBLE_NUMBER 5
140 : #define TRACE_NUMBER_WITHIN_ENSEMBLE 6
141 : #define NUMBER_VERTICAL_SUMMED_TRACES 7
142 : #define NUMBER_HORIZONTAL_STACKED_TRACES 8
143 : #define DATA_USE 9
144 : #define DISTANCE_SOURCE_GROUP 10
145 : #define RECEIVER_GROUP_ELEVATION 11
146 : #define SURFACE_ELEVATION_AT_SOURCE 12
147 : #define SOURCE_DEPTH_BELOW_SURFACE 13
148 : #define DATUM_ELEVATION_AT_RECEIVER_GROUP 14
149 : #define DATUM_ELEVATION_AT_SOURCE 15
150 : #define WATER_DEPTH_AT_SOURCE 16
151 : #define WATER_DEPTH_AT_GROUP 17
152 : #define VERTICAL_SCALAR 18
153 : #define HORIZONTAL_SCALAR 19
154 : #define SOURCE_X 20
155 : #define SOURCE_Y 21
156 : #define GROUP_X 22
157 : #define GROUP_Y 23
158 : #define COORDINATE_UNITS 24
159 : #define WEATHERING_VELOCITY 25
160 : #define SUB_WEATHERING_VELOCITY 26
161 : #define UPHOLE_TIME_AT_SOURCE 27
162 : #define UPHOLE_TIME_AT_GROUP 28
163 : #define SOURCE_STATIC_CORRECTION 29
164 : #define GROUP_STATIC_CORRECTION 30
165 : #define TOTAL_STATIC_CORRECTION 31
166 : #define LAG_TIME_A 32
167 : #define LAG_TIME_B 33
168 : #define DELAY_RECORDING_TIME 34
169 : #define MUTE_TIME_START 35
170 : #define MUTE_TIME_END 36
171 : #define SAMPLES 37
172 : #define SAMPLE_INTERVAL 38
173 : #define GAIN_TYPE 39
174 : #define INSTRUMENT_GAIN_CONSTANT 40
175 : #define INSTRUMENT_INITIAL_GAIN 41
176 : #define CORRELATED 42
177 : #define SWEEP_FREQUENCY_AT_START 43
178 : #define SWEEP_FREQUENCY_AT_END 44
179 : #define SWEEP_LENGTH 45
180 : #define SWEEP_TYPE 46
181 : #define SWEEP_TRACE_TAPER_LENGTH_AT_START 47
182 : #define SWEEP_TRACE_TAPER_LENGTH_AT_END 48
183 : #define TAPER_TYPE 49
184 : #define ALIAS_FILTER_FREQUENCY 50
185 : #define ALIAS_FILTER_SLOPE 51
186 : #define NOTCH_FILTER_FREQUENCY 52
187 : #define NOTCH_FILTER_SLOPE 53
188 : #define LOW_CUT_FREQUENCY 54
189 : #define HIGH_CUT_FREQUENCY 55
190 : #define LOW_CUT_SLOPE 56
191 : #define HIGH_CUT_SLOPE 57
192 : #define YEAR 58
193 : #define DAY_OF_YEAR 59
194 : #define HOUR 60
195 : #define MINUTE 61
196 : #define SECOND 62
197 : #define TIME_BASIC_CODE 63
198 : #define TRACE_WEIGHTING_FACTOR 64
199 : #define GEOPHONE_GROUP_NUMBER_OF_ROLL_SWITH 65
200 : #define GEOPHONE_GROUP_NUMBER_OF_TRACE_NUMBER_ONE 66
201 : #define GEOPHONE_GROUP_NUMBER_OF_LAST_TRACE 67
202 : #define GAP_SIZE 68
203 : #define OVER_TRAVEL 69
204 : #define INLINE_NUMBER 70
205 : #define CROSSLINE_NUMBER 71
206 : #define SHOTPOINT_NUMBER 72
207 : #define SHOTPOINT_SCALAR 73
208 :
209 : #if 0
210 : /************************************************************************/
211 : /* SEGYReadMSBFloat32() */
212 : /************************************************************************/
213 :
214 : static float SEGYReadMSBFloat32(const GByte* pabyVal)
215 : {
216 : float fVal;
217 : memcpy(&fVal, pabyVal, 4);
218 : CPL_MSBPTR32(&fVal);
219 : return fVal;
220 : }
221 : #endif
222 :
223 : /************************************************************************/
224 : /* OGRSEGYLayer() */
225 : /************************************************************************/
226 :
227 :
228 2 : OGRSEGYLayer::OGRSEGYLayer( const char* pszFilename,
229 : VSILFILE* fp,
230 2 : SEGYBinaryFileHeader* psBFH )
231 :
232 : {
233 2 : this->fp = fp;
234 2 : nNextFID = 0;
235 2 : bEOF = FALSE;
236 2 : poSRS = NULL;
237 2 : memcpy(&sBFH, psBFH, sizeof(sBFH));
238 :
239 2 : nDataSize = 0;
240 2 : switch (sBFH.nDataSampleType)
241 : {
242 0 : case DT_IBM_4BYTES_FP: nDataSize = 4; break;
243 0 : case DT_4BYTES_INT: nDataSize = 4; break;
244 0 : case DT_2BYTES_INT: nDataSize = 2; break;
245 0 : case DT_4BYTES_FP_WITH_GAIN: nDataSize = 4; break;
246 0 : case DT_IEEE_4BYTES_FP: nDataSize = 4; break;
247 0 : case DT_1BYTE_INT: nDataSize = 1; break;
248 : default: break;
249 : }
250 :
251 2 : poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
252 2 : poFeatureDefn->Reference();
253 2 : poFeatureDefn->SetGeomType( wkbPoint );
254 :
255 : int i;
256 142 : for(i=0;i<(int)(sizeof(SEGYFields)/sizeof(SEGYFields[0]));i++)
257 : {
258 : OGRFieldDefn oField( SEGYFields[i].pszName,
259 140 : SEGYFields[i].eType );
260 140 : poFeatureDefn->AddFieldDefn( &oField );
261 : }
262 :
263 2 : if (sBFH.dfSEGYRevisionNumber >= 1.0)
264 : {
265 0 : for(i=0;i<(int)(sizeof(SEGYFields10)/sizeof(SEGYFields10[0]));i++)
266 : {
267 : OGRFieldDefn oField( SEGYFields10[i].pszName,
268 0 : SEGYFields10[i].eType );
269 0 : poFeatureDefn->AddFieldDefn( &oField );
270 : }
271 : }
272 :
273 2 : OGRFieldDefn oField( "SAMPLE_ARRAY", OFTRealList );
274 2 : poFeatureDefn->AddFieldDefn(&oField);
275 :
276 2 : ResetReading();
277 2 : }
278 :
279 : /************************************************************************/
280 : /* ~OGRSEGYLayer() */
281 : /************************************************************************/
282 :
283 2 : OGRSEGYLayer::~OGRSEGYLayer()
284 :
285 : {
286 2 : poFeatureDefn->Release();
287 :
288 2 : VSIFCloseL( fp );
289 :
290 2 : if (poSRS)
291 0 : poSRS->Release();
292 2 : }
293 :
294 : /************************************************************************/
295 : /* ResetReading() */
296 : /************************************************************************/
297 :
298 2 : void OGRSEGYLayer::ResetReading()
299 :
300 : {
301 2 : nNextFID = 0;
302 2 : bEOF = FALSE;
303 :
304 : VSIFSeekL( fp, 3200 + 400 + 3200 * sBFH.nNumberOfExtendedTextualFileHeader,
305 2 : SEEK_SET );
306 2 : }
307 :
308 : /************************************************************************/
309 : /* GetNextFeature() */
310 : /************************************************************************/
311 :
312 4 : OGRFeature *OGRSEGYLayer::GetNextFeature()
313 : {
314 : OGRFeature *poFeature;
315 :
316 0 : while(TRUE)
317 : {
318 4 : poFeature = GetNextRawFeature();
319 4 : if (poFeature == NULL)
320 2 : return NULL;
321 :
322 2 : if((m_poFilterGeom == NULL
323 : || FilterGeometry( poFeature->GetGeometryRef() ) )
324 : && (m_poAttrQuery == NULL
325 : || m_poAttrQuery->Evaluate( poFeature )) )
326 : {
327 2 : return poFeature;
328 : }
329 : else
330 0 : delete poFeature;
331 : }
332 : }
333 :
334 : /************************************************************************/
335 : /* GetIBMFloat() */
336 : /************************************************************************/
337 :
338 0 : static float GetIBMFloat(const GByte* pabyData)
339 : {
340 : int nVal;
341 0 : memcpy(&nVal, pabyData, 4);
342 0 : CPL_MSBPTR32(&nVal);
343 0 : int nSign = 1 - 2 * ((nVal >> 31) & 0x01);
344 0 : int nExp = (nVal >> 24) & 0x7f;
345 0 : int nMant = nVal & 0xffffff;
346 :
347 0 : if (nExp == 0x7f)
348 : {
349 0 : nVal = (nVal & 0x80000000) | (0xff << 23) | (nMant >> 1);
350 : float fVal;
351 0 : memcpy(&fVal, &nVal, 4);
352 0 : return fVal;
353 : }
354 :
355 0 : return (float)((double)nSign * nMant * pow(2.0, 4 * (nExp - 64) - 24));
356 : }
357 : /************************************************************************/
358 : /* GetNextRawFeature() */
359 : /************************************************************************/
360 :
361 4 : OGRFeature *OGRSEGYLayer::GetNextRawFeature()
362 : {
363 4 : if (bEOF)
364 0 : return NULL;
365 :
366 : GByte abyTraceHeader[240];
367 :
368 4 : if ((int)VSIFReadL(abyTraceHeader, 1, 240, fp) != 240)
369 : {
370 2 : bEOF = TRUE;
371 2 : return NULL;
372 : }
373 :
374 2 : int nTraceNumberWithinLine = SEGYReadMSBInt32(abyTraceHeader + 0);
375 2 : int nTraceNumberWithinFile = SEGYReadMSBInt32(abyTraceHeader + 4);
376 2 : int nOriginalFieldRecordNumber = SEGYReadMSBInt32(abyTraceHeader + 8);
377 2 : int nTraceNumberWithinOriginalFieldRecord = SEGYReadMSBInt32(abyTraceHeader + 12);
378 2 : int nEnsembleNumber = SEGYReadMSBInt32(abyTraceHeader + 20);
379 2 : int nTraceNumberWithinEnsemble = SEGYReadMSBInt32(abyTraceHeader + 24);
380 2 : int nTraceIdentificationCode = SEGYReadMSBInt16(abyTraceHeader + 28);
381 2 : int nNumberVerticalSummedTraces = SEGYReadMSBInt16(abyTraceHeader + 30);
382 2 : int nNumberHorizontalStackedTraces = SEGYReadMSBInt16(abyTraceHeader + 32);
383 2 : int nDataUse = SEGYReadMSBInt16(abyTraceHeader + 34);
384 2 : int nDistanceSourceGroup = SEGYReadMSBInt32(abyTraceHeader + 36);
385 2 : int nReceiverGroupElevation = SEGYReadMSBInt32(abyTraceHeader + 40);
386 2 : int nSurfaceElevationAtSource = SEGYReadMSBInt32(abyTraceHeader + 44);
387 2 : int nSourceDepthBelowSurface = SEGYReadMSBInt32(abyTraceHeader + 48);
388 2 : int nDatumElevationAtReceiverGroup = SEGYReadMSBInt32(abyTraceHeader + 52);
389 2 : int nDatumElevationAtSource = SEGYReadMSBInt32(abyTraceHeader + 56);
390 2 : int nWaterDepthAtSource = SEGYReadMSBInt32(abyTraceHeader + 60);
391 2 : int nWaterDepthAtGroup = SEGYReadMSBInt32(abyTraceHeader + 64);
392 2 : int nVerticalScalar = SEGYReadMSBInt16(abyTraceHeader + 68);
393 2 : int nHorizontalScalar = SEGYReadMSBInt16(abyTraceHeader + 70);
394 2 : int nSourceX = SEGYReadMSBInt32(abyTraceHeader + 72);
395 2 : int nSourceY = SEGYReadMSBInt32(abyTraceHeader + 76);
396 2 : int nGroupX = SEGYReadMSBInt32(abyTraceHeader + 80);
397 2 : int nGroupY = SEGYReadMSBInt32(abyTraceHeader + 84);
398 2 : int nCoordinateUnits = SEGYReadMSBInt16(abyTraceHeader + 88);
399 2 : int nWeatheringVelocity = SEGYReadMSBInt16(abyTraceHeader + 90);
400 2 : int nSubWeatheringVelocity = SEGYReadMSBInt16(abyTraceHeader + 92);
401 :
402 2 : int nUpholeTimeAtSource = SEGYReadMSBInt16(abyTraceHeader + 94);
403 2 : int nUpholeTimeAtGroup = SEGYReadMSBInt16(abyTraceHeader + 96);
404 2 : int nSourceStaticCorrection = SEGYReadMSBInt16(abyTraceHeader + 98);
405 2 : int nGroupStaticCorrection = SEGYReadMSBInt16(abyTraceHeader + 100);
406 2 : int nTotalStaticCorrection = SEGYReadMSBInt16(abyTraceHeader + 102);
407 2 : int nLagTimeA = SEGYReadMSBInt16(abyTraceHeader + 104);
408 2 : int nLagTimeB = SEGYReadMSBInt16(abyTraceHeader + 106);
409 2 : int nDelayRecordingTime = SEGYReadMSBInt16(abyTraceHeader + 108);
410 2 : int nMuteTimeStart = SEGYReadMSBInt16(abyTraceHeader + 110);
411 2 : int nMuteTimeEnd = SEGYReadMSBInt16(abyTraceHeader + 112);
412 :
413 2 : int nSamples = SEGYReadMSBInt16(abyTraceHeader + 114);
414 2 : if (nSamples == 0) /* Happens with ftp://software.seg.org/pub/datasets/2D/Hess_VTI/timodel_c11.segy.gz */
415 2 : nSamples = sBFH.nSamplesPerDataTrace;
416 :
417 2 : if (nSamples < 0)
418 : {
419 0 : bEOF = TRUE;
420 0 : return NULL;
421 : }
422 2 : int nSampleInterval = SEGYReadMSBInt16(abyTraceHeader + 116);
423 :
424 2 : int nGainType = SEGYReadMSBInt16(abyTraceHeader + 118);
425 2 : int nInstrumentGainConstant = SEGYReadMSBInt16(abyTraceHeader + 120);
426 2 : int nInstrumentInitialGain = SEGYReadMSBInt16(abyTraceHeader + 122);
427 2 : int nCorrelated = SEGYReadMSBInt16(abyTraceHeader + 124);
428 2 : int nSweepFrequencyAtStart = SEGYReadMSBInt16(abyTraceHeader + 126);
429 2 : int nSweepFrequencyAtEnd = SEGYReadMSBInt16(abyTraceHeader + 128);
430 2 : int nSweepLength = SEGYReadMSBInt16(abyTraceHeader + 130);
431 2 : int nSweepType = SEGYReadMSBInt16(abyTraceHeader + 132);
432 2 : int nSweepTraceTaperLengthAtStart = SEGYReadMSBInt16(abyTraceHeader + 134);
433 2 : int nSweepTraceTaperLengthAtEnd = SEGYReadMSBInt16(abyTraceHeader + 136);
434 2 : int nTaperType = SEGYReadMSBInt16(abyTraceHeader + 138);
435 2 : int nAliasFilterFrequency = SEGYReadMSBInt16(abyTraceHeader + 140);
436 2 : int nAliasFilterSlope = SEGYReadMSBInt16(abyTraceHeader + 142);
437 2 : int nNotchFilterFrequency = SEGYReadMSBInt16(abyTraceHeader + 144);
438 2 : int nNotchFilterSlope = SEGYReadMSBInt16(abyTraceHeader + 146);
439 2 : int nLowCutFrequency = SEGYReadMSBInt16(abyTraceHeader + 148);
440 2 : int nHighCutFrequency = SEGYReadMSBInt16(abyTraceHeader + 150);
441 2 : int nLowCutSlope = SEGYReadMSBInt16(abyTraceHeader + 152);
442 2 : int nHighCutSlope = SEGYReadMSBInt16(abyTraceHeader + 154);
443 :
444 2 : int nYear = SEGYReadMSBInt16(abyTraceHeader + 156);
445 2 : int nDayOfYear = SEGYReadMSBInt16(abyTraceHeader + 158);
446 2 : int nHour = SEGYReadMSBInt16(abyTraceHeader + 160);
447 2 : int nMinute = SEGYReadMSBInt16(abyTraceHeader + 162);
448 2 : int nSecond = SEGYReadMSBInt16(abyTraceHeader + 164);
449 2 : int nTimeBasicCode = SEGYReadMSBInt16(abyTraceHeader + 166);
450 :
451 2 : int nTraceWeightingFactor = SEGYReadMSBInt16(abyTraceHeader + 168);
452 2 : int nGeophoneGroupNumberOfRollSwith = SEGYReadMSBInt16(abyTraceHeader + 170);
453 2 : int nGeophoneGroupNumberOfTraceNumberOne = SEGYReadMSBInt16(abyTraceHeader + 172);
454 2 : int nGeophoneGroupNumberOfLastTrace = SEGYReadMSBInt16(abyTraceHeader + 174);
455 2 : int nGapSize = SEGYReadMSBInt16(abyTraceHeader + 176);
456 2 : int nOverTravel = SEGYReadMSBInt16(abyTraceHeader + 178);
457 :
458 2 : int nInlineNumber = SEGYReadMSBInt32(abyTraceHeader + 188);
459 2 : int nCrosslineNumber = SEGYReadMSBInt32(abyTraceHeader + 192);
460 2 : int nShotpointNumber = SEGYReadMSBInt32(abyTraceHeader + 196);
461 2 : int nShotpointScalar = SEGYReadMSBInt16(abyTraceHeader + 200);
462 :
463 : #if 0
464 : /* Extensions of http://sioseis.ucsd.edu/segy.header.html */
465 : float fDeepWaterDelay = SEGYReadMSBFloat32(abyTraceHeader + 180);
466 : float fStartMuteTime = SEGYReadMSBFloat32(abyTraceHeader + 184);
467 : float fEndMuteTime = SEGYReadMSBFloat32(abyTraceHeader + 188);
468 : float fSampleInterval = SEGYReadMSBFloat32(abyTraceHeader + 192);
469 : float fWaterBottomTime = SEGYReadMSBFloat32(abyTraceHeader + 196);
470 : int nEndOfRp = SEGYReadMSBInt16(abyTraceHeader + 200);
471 : CPLDebug("SIGY", "fDeepWaterDelay = %f", fDeepWaterDelay);
472 : CPLDebug("SIGY", "fStartMuteTime = %f", fStartMuteTime);
473 : CPLDebug("SIGY", "fEndMuteTime = %f", fEndMuteTime);
474 : CPLDebug("SIGY", "fSampleInterval = %f", fSampleInterval);
475 : CPLDebug("SIGY", "fWaterBottomTime = %f", fWaterBottomTime);
476 : CPLDebug("SIGY", "nEndOfRp = %d", nEndOfRp);
477 : #endif
478 :
479 : double dfHorizontalScale = (nHorizontalScalar > 0) ? nHorizontalScalar :
480 2 : (nHorizontalScalar < 0) ? 1.0 / -nHorizontalScalar : 1.0;
481 2 : if (nCoordinateUnits == 2)
482 0 : dfHorizontalScale /= 3600;
483 :
484 2 : double dfGroupX = nGroupX * dfHorizontalScale;
485 2 : double dfGroupY = nGroupY * dfHorizontalScale;
486 :
487 : #if 0
488 : double dfSourceX = nSourceX * dfHorizontalScale;
489 : double dfSourceY = nSourceY * dfHorizontalScale;
490 : #endif
491 :
492 : #if 0
493 : CPLDebug("SIGY", "nTraceNumberWithinLine = %d", nTraceNumberWithinLine);
494 : CPLDebug("SIGY", "nTraceNumberWithinFile = %d", nTraceNumberWithinFile);
495 : CPLDebug("SIGY", "nOriginalFieldRecordNumber = %d", nOriginalFieldRecordNumber);
496 : CPLDebug("SIGY", "nTraceNumberWithinOriginalFieldRecord = %d", nTraceNumberWithinOriginalFieldRecord);
497 : CPLDebug("SIGY", "nTraceIdentificationCode = %d", nTraceIdentificationCode);
498 : CPLDebug("SIGY", "nEnsembleNumber = %d", nEnsembleNumber);
499 : CPLDebug("SIGY", "nTraceNumberWithinEnsemble = %d", nTraceNumberWithinEnsemble);
500 : CPLDebug("SIGY", "nNumberVerticalSummedTraces = %d", nNumberVerticalSummedTraces);
501 : CPLDebug("SIGY", "nNumberHorizontalStackedTraces = %d", nNumberHorizontalStackedTraces);
502 : CPLDebug("SIGY", "nDataUse = %d", nDataUse);
503 : CPLDebug("SIGY", "nDistanceSourceGroup = %d", nDistanceSourceGroup);
504 : CPLDebug("SIGY", "nReceiverGroupElevation = %d", nReceiverGroupElevation);
505 : CPLDebug("SIGY", "nSurfaceElevationAtSource = %d", nSurfaceElevationAtSource);
506 : CPLDebug("SIGY", "nSourceDepthBelowSurface = %d", nSourceDepthBelowSurface);
507 : CPLDebug("SIGY", "nDatumElevationAtReceiverGroup = %d", nDatumElevationAtReceiverGroup);
508 : CPLDebug("SIGY", "nDatumElevationAtSource = %d", nDatumElevationAtSource);
509 : CPLDebug("SIGY", "nWaterDepthAtSource = %d", nWaterDepthAtSource);
510 : CPLDebug("SIGY", "nWaterDepthAtGroup = %d", nWaterDepthAtGroup);
511 : CPLDebug("SIGY", "nVerticalScalar = %d", nVerticalScalar);
512 : CPLDebug("SIGY", "nHorizontalScalar = %d", nHorizontalScalar);
513 : CPLDebug("SIGY", "nSourceX = %d", nSourceX);
514 : CPLDebug("SIGY", "nSourceY = %d", nSourceY);
515 : CPLDebug("SIGY", "dfSourceX = %f", dfSourceX);
516 : CPLDebug("SIGY", "dfSourceY = %f", dfSourceY);
517 : CPLDebug("SIGY", "nGroupX = %d", nGroupX);
518 : CPLDebug("SIGY", "nGroupY = %d", nGroupY);
519 : CPLDebug("SIGY", "dfGroupX = %f", dfGroupX);
520 : CPLDebug("SIGY", "dfGroupY = %f", dfGroupY);
521 : CPLDebug("SIGY", "nCoordinateUnits = %d", nCoordinateUnits);
522 :
523 : CPLDebug("SIGY", "nWeatheringVelocity = %d", nWeatheringVelocity);
524 : CPLDebug("SIGY", "nSubWeatheringVelocity = %d", nSubWeatheringVelocity);
525 : CPLDebug("SIGY", "nUpholeTimeAtSource = %d", nUpholeTimeAtSource);
526 : CPLDebug("SIGY", "nUpholeTimeAtGroup = %d", nUpholeTimeAtGroup);
527 : CPLDebug("SIGY", "nSourceStaticCorrection = %d", nSourceStaticCorrection);
528 : CPLDebug("SIGY", "nGroupStaticCorrection = %d", nGroupStaticCorrection);
529 : CPLDebug("SIGY", "nTotalStaticCorrection = %d", nTotalStaticCorrection);
530 : CPLDebug("SIGY", "nLagTimeA = %d", nLagTimeA);
531 : CPLDebug("SIGY", "nLagTimeB = %d", nLagTimeB);
532 : CPLDebug("SIGY", "nDelayRecordingTime = %d", nDelayRecordingTime);
533 : CPLDebug("SIGY", "nMuteTimeStart = %d", nMuteTimeStart);
534 : CPLDebug("SIGY", "nMuteTimeEnd = %d", nMuteTimeEnd);
535 :
536 : CPLDebug("SIGY", "nSamples = %d", nSamples);
537 : CPLDebug("SIGY", "nSampleInterval = %d", nSampleInterval);
538 :
539 : CPLDebug("SIGY", "nGainType = %d", nGainType);
540 : CPLDebug("SIGY", "nInstrumentGainConstant = %d", nInstrumentGainConstant);
541 : CPLDebug("SIGY", "nInstrumentInitialGain = %d", nInstrumentInitialGain);
542 : CPLDebug("SIGY", "nCorrelated = %d", nCorrelated);
543 : CPLDebug("SIGY", "nSweepFrequencyAtStart = %d", nSweepFrequencyAtStart);
544 : CPLDebug("SIGY", "nSweepFrequencyAtEnd = %d", nSweepFrequencyAtEnd);
545 : CPLDebug("SIGY", "nSweepLength = %d", nSweepLength);
546 : CPLDebug("SIGY", "nSweepType = %d", nSweepType);
547 : CPLDebug("SIGY", "nSweepTraceTaperLengthAtStart = %d", nSweepTraceTaperLengthAtStart);
548 : CPLDebug("SIGY", "nSweepTraceTaperLengthAtEnd = %d", nSweepTraceTaperLengthAtEnd);
549 : CPLDebug("SIGY", "nTaperType = %d", nTaperType);
550 : CPLDebug("SIGY", "nAliasFilterFrequency = %d", nAliasFilterFrequency);
551 : CPLDebug("SIGY", "nAliasFilterSlope = %d", nAliasFilterSlope);
552 : CPLDebug("SIGY", "nNotchFilterFrequency = %d", nNotchFilterFrequency);
553 : CPLDebug("SIGY", "nNotchFilterSlope = %d", nNotchFilterSlope);
554 : CPLDebug("SIGY", "nLowCutFrequency = %d", nLowCutFrequency);
555 : CPLDebug("SIGY", "nHighCutFrequency = %d", nHighCutFrequency);
556 : CPLDebug("SIGY", "nLowCutSlope = %d", nLowCutSlope);
557 : CPLDebug("SIGY", "nHighCutSlope = %d", nHighCutSlope);
558 : CPLDebug("SIGY", "nYear = %d", nYear);
559 : CPLDebug("SIGY", "nDayOfYear = %d", nDayOfYear);
560 : CPLDebug("SIGY", "nHour = %d", nHour);
561 : CPLDebug("SIGY", "nMinute = %d", nMinute);
562 : CPLDebug("SIGY", "nSecond = %d", nSecond);
563 : CPLDebug("SIGY", "nTimeBasicCode = %d", nTimeBasicCode);
564 : CPLDebug("SIGY", "nTraceWeightingFactor = %d", nTraceWeightingFactor);
565 : CPLDebug("SIGY", "nGeophoneGroupNumberOfRollSwith = %d", nGeophoneGroupNumberOfRollSwith);
566 : CPLDebug("SIGY", "nGeophoneGroupNumberOfTraceNumberOne = %d", nGeophoneGroupNumberOfTraceNumberOne);
567 : CPLDebug("SIGY", "nGeophoneGroupNumberOfLastTrace = %d", nGeophoneGroupNumberOfLastTrace);
568 : CPLDebug("SIGY", "nGapSize = %d", nGapSize);
569 : CPLDebug("SIGY", "nOverTravel = %d", nOverTravel);
570 :
571 : if (sBFH.dfSEGYRevisionNumber >= 1.0)
572 : {
573 : CPLDebug("SIGY", "nInlineNumber = %d", nInlineNumber);
574 : CPLDebug("SIGY", "nCrosslineNumber = %d", nCrosslineNumber);
575 : CPLDebug("SIGY", "nShotpointNumber = %d", nShotpointNumber);
576 : CPLDebug("SIGY", "nShotpointScalar = %d", nShotpointScalar);
577 : }
578 : #endif
579 :
580 2 : GByte* pabyData = (GByte*) VSIMalloc( nDataSize * nSamples );
581 2 : double* padfValues = (double*) VSICalloc( nSamples, sizeof(double) );
582 2 : if (pabyData == NULL || padfValues == NULL)
583 : {
584 0 : VSIFSeekL( fp, nDataSize * nSamples, SEEK_CUR );
585 : }
586 : else
587 : {
588 2 : if ((int)VSIFReadL(pabyData, nDataSize, nSamples, fp) != nSamples)
589 : {
590 0 : bEOF = TRUE;
591 : }
592 2 : for(int i=0;i<nSamples;i++)
593 : {
594 0 : switch (sBFH.nDataSampleType)
595 : {
596 : case DT_IBM_4BYTES_FP:
597 : {
598 0 : padfValues[i] = GetIBMFloat(pabyData + i * 4);
599 0 : break;
600 : }
601 :
602 : case DT_4BYTES_INT:
603 : {
604 : int nVal;
605 0 : memcpy(&nVal, pabyData + i * 4, 4);
606 0 : CPL_MSBPTR32(&nVal);
607 0 : padfValues[i] = nVal;
608 0 : break;
609 : }
610 :
611 : case DT_2BYTES_INT:
612 : {
613 : GInt16 nVal;
614 0 : memcpy(&nVal, pabyData + i * 2, 2);
615 0 : CPL_MSBPTR16(&nVal);
616 0 : padfValues[i] = nVal;
617 0 : break;
618 : }
619 :
620 : case DT_IEEE_4BYTES_FP:
621 : {
622 : float fVal;
623 0 : memcpy(&fVal, pabyData + i * 4, 4);
624 0 : CPL_MSBPTR32(&fVal);
625 0 : padfValues[i] = fVal;
626 0 : break;
627 : }
628 :
629 : case DT_1BYTE_INT:
630 : {
631 0 : padfValues[i] = ((char*)pabyData)[i];
632 : break;
633 : }
634 :
635 : default:
636 : break;
637 : }
638 : }
639 : }
640 2 : CPLFree(pabyData);
641 :
642 2 : OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
643 2 : poFeature->SetFID(nNextFID ++);
644 2 : if (dfGroupX != 0.0 || dfGroupY != 0.0)
645 2 : poFeature->SetGeometryDirectly(new OGRPoint(dfGroupX, dfGroupY));
646 :
647 2 : poFeature->SetField(TRACE_NUMBER_WITHIN_LINE, nTraceNumberWithinLine);
648 2 : poFeature->SetField(TRACE_NUMBER_WITHIN_FILE, nTraceNumberWithinFile);
649 2 : poFeature->SetField(ORIGINAL_FIELD_RECORD_NUMBER, nOriginalFieldRecordNumber);
650 2 : poFeature->SetField(TRACE_NUMBER_WITHIN_ORIGINAL_FIELD_RECORD, nTraceNumberWithinOriginalFieldRecord);
651 2 : poFeature->SetField(TRACE_IDENTIFICATION_CODE, nTraceIdentificationCode);
652 2 : poFeature->SetField(ENSEMBLE_NUMBER, nEnsembleNumber);
653 2 : poFeature->SetField(TRACE_NUMBER_WITHIN_ENSEMBLE, nTraceNumberWithinEnsemble);
654 2 : poFeature->SetField(NUMBER_VERTICAL_SUMMED_TRACES, nNumberVerticalSummedTraces);
655 2 : poFeature->SetField(NUMBER_HORIZONTAL_STACKED_TRACES, nNumberHorizontalStackedTraces);
656 2 : poFeature->SetField(DATA_USE, nDataUse);
657 2 : poFeature->SetField(DISTANCE_SOURCE_GROUP, nDistanceSourceGroup);
658 2 : poFeature->SetField(RECEIVER_GROUP_ELEVATION, nReceiverGroupElevation);
659 2 : poFeature->SetField(SURFACE_ELEVATION_AT_SOURCE, nSurfaceElevationAtSource);
660 2 : poFeature->SetField(SOURCE_DEPTH_BELOW_SURFACE, nSourceDepthBelowSurface);
661 2 : poFeature->SetField(DATUM_ELEVATION_AT_RECEIVER_GROUP, nDatumElevationAtReceiverGroup);
662 2 : poFeature->SetField(DATUM_ELEVATION_AT_SOURCE, nDatumElevationAtSource);
663 2 : poFeature->SetField(WATER_DEPTH_AT_SOURCE, nWaterDepthAtSource);
664 2 : poFeature->SetField(WATER_DEPTH_AT_GROUP, nWaterDepthAtGroup);
665 2 : poFeature->SetField(VERTICAL_SCALAR, nVerticalScalar);
666 2 : poFeature->SetField(HORIZONTAL_SCALAR, nHorizontalScalar);
667 2 : poFeature->SetField(SOURCE_X, nSourceX);
668 2 : poFeature->SetField(SOURCE_Y, nSourceY);
669 2 : poFeature->SetField(GROUP_X, nGroupX);
670 2 : poFeature->SetField(GROUP_Y, nGroupY);
671 2 : poFeature->SetField(COORDINATE_UNITS, nCoordinateUnits);
672 2 : poFeature->SetField(WEATHERING_VELOCITY, nWeatheringVelocity);
673 2 : poFeature->SetField(SUB_WEATHERING_VELOCITY, nSubWeatheringVelocity);
674 2 : poFeature->SetField(UPHOLE_TIME_AT_SOURCE, nUpholeTimeAtSource);
675 2 : poFeature->SetField(UPHOLE_TIME_AT_GROUP, nUpholeTimeAtGroup);
676 2 : poFeature->SetField(SOURCE_STATIC_CORRECTION, nSourceStaticCorrection);
677 2 : poFeature->SetField(GROUP_STATIC_CORRECTION, nGroupStaticCorrection);
678 2 : poFeature->SetField(TOTAL_STATIC_CORRECTION, nTotalStaticCorrection);
679 2 : poFeature->SetField(LAG_TIME_A, nLagTimeA);
680 2 : poFeature->SetField(LAG_TIME_B, nLagTimeB);
681 2 : poFeature->SetField(DELAY_RECORDING_TIME, nDelayRecordingTime);
682 2 : poFeature->SetField(MUTE_TIME_START, nMuteTimeStart);
683 2 : poFeature->SetField(MUTE_TIME_END, nMuteTimeEnd);
684 2 : poFeature->SetField(SAMPLES, nSamples);
685 2 : poFeature->SetField(SAMPLE_INTERVAL, nSampleInterval);
686 2 : poFeature->SetField(GAIN_TYPE, nGainType);
687 2 : poFeature->SetField(INSTRUMENT_GAIN_CONSTANT, nInstrumentGainConstant);
688 2 : poFeature->SetField(INSTRUMENT_INITIAL_GAIN, nInstrumentInitialGain);
689 2 : poFeature->SetField(CORRELATED, nCorrelated);
690 2 : poFeature->SetField(SWEEP_FREQUENCY_AT_START, nSweepFrequencyAtStart);
691 2 : poFeature->SetField(SWEEP_FREQUENCY_AT_END, nSweepFrequencyAtEnd);
692 2 : poFeature->SetField(SWEEP_LENGTH, nSweepLength);
693 2 : poFeature->SetField(SWEEP_TYPE, nSweepType);
694 2 : poFeature->SetField(SWEEP_TRACE_TAPER_LENGTH_AT_START, nSweepTraceTaperLengthAtStart);
695 2 : poFeature->SetField(SWEEP_TRACE_TAPER_LENGTH_AT_END, nSweepTraceTaperLengthAtEnd);
696 2 : poFeature->SetField(TAPER_TYPE, nTaperType);
697 2 : poFeature->SetField(ALIAS_FILTER_FREQUENCY, nAliasFilterFrequency);
698 2 : poFeature->SetField(ALIAS_FILTER_SLOPE, nAliasFilterSlope);
699 2 : poFeature->SetField(NOTCH_FILTER_FREQUENCY, nNotchFilterFrequency);
700 2 : poFeature->SetField(NOTCH_FILTER_SLOPE, nNotchFilterSlope);
701 2 : poFeature->SetField(LOW_CUT_FREQUENCY, nLowCutFrequency);
702 2 : poFeature->SetField(HIGH_CUT_FREQUENCY, nHighCutFrequency);
703 2 : poFeature->SetField(LOW_CUT_SLOPE, nLowCutSlope);
704 2 : poFeature->SetField(HIGH_CUT_SLOPE, nHighCutSlope);
705 2 : poFeature->SetField(YEAR, nYear);
706 2 : poFeature->SetField(DAY_OF_YEAR, nDayOfYear);
707 2 : poFeature->SetField(HOUR, nHour);
708 2 : poFeature->SetField(MINUTE, nMinute);
709 2 : poFeature->SetField(SECOND, nSecond);
710 2 : poFeature->SetField(TIME_BASIC_CODE, nTimeBasicCode);
711 2 : poFeature->SetField(TRACE_WEIGHTING_FACTOR, nTraceWeightingFactor);
712 2 : poFeature->SetField(GEOPHONE_GROUP_NUMBER_OF_ROLL_SWITH, nGeophoneGroupNumberOfRollSwith);
713 2 : poFeature->SetField(GEOPHONE_GROUP_NUMBER_OF_TRACE_NUMBER_ONE, nGeophoneGroupNumberOfTraceNumberOne);
714 2 : poFeature->SetField(GEOPHONE_GROUP_NUMBER_OF_LAST_TRACE, nGeophoneGroupNumberOfLastTrace);
715 2 : poFeature->SetField(GAP_SIZE, nGapSize);
716 2 : poFeature->SetField(OVER_TRAVEL, nOverTravel);
717 :
718 2 : if (sBFH.dfSEGYRevisionNumber >= 1.0)
719 : {
720 0 : poFeature->SetField(INLINE_NUMBER, nInlineNumber);
721 0 : poFeature->SetField(CROSSLINE_NUMBER, nCrosslineNumber);
722 0 : poFeature->SetField(SHOTPOINT_NUMBER, nShotpointNumber);
723 0 : poFeature->SetField(SHOTPOINT_SCALAR, nShotpointScalar);
724 : }
725 :
726 2 : if (nSamples > 0 && padfValues != NULL)
727 0 : poFeature->SetField(poFeature->GetFieldCount() - 1, nSamples, padfValues);
728 :
729 2 : CPLFree(padfValues);
730 2 : return poFeature;
731 : }
732 :
733 :
734 :
735 : static const FieldDesc SEGYHeaderFields[] =
736 : {
737 : { "TEXT_HEADER", OFTString },
738 : { "JOB_ID_NUMBER", OFTInteger },
739 : { "LINE_NUMBER", OFTInteger },
740 : { "REEL_NUMBER", OFTInteger },
741 : { "DATA_TRACES_PER_ENSEMBLE", OFTInteger },
742 : { "AUX_TRACES_PER_ENSEMBLE", OFTInteger },
743 : { "SAMPLE_INTERVAL", OFTInteger },
744 : { "SAMPLE_INTERVAL_ORIGINAL", OFTInteger },
745 : { "SAMPLES_PER_DATA_TRACE", OFTInteger },
746 : { "SAMPLES_PER_DATA_TRACE_ORIGINAL", OFTInteger },
747 : { "DATA_SAMPLE_TYPE", OFTInteger },
748 : { "ENSEMBLE_FOLD", OFTInteger },
749 : { "TRACE_SORTING_CODE", OFTInteger },
750 : { "VERTICAL_SUM_CODE", OFTInteger },
751 : { "SWEEP_FREQUENCY_AT_START", OFTInteger },
752 : { "SWEEP_FREQUENCY_AT_END", OFTInteger },
753 : { "SWEEP_LENGTH", OFTInteger },
754 : { "SWEEP_TYPE", OFTInteger },
755 : { "TRACE_NUMBER_OF_SWEEP_CHANNEL", OFTInteger },
756 : { "SWEEP_TRACE_TAPER_LENGTH_AT_START", OFTInteger },
757 : { "SWEEP_TRACE_TAPER_LENGTH_AT_END", OFTInteger },
758 : { "TAPER_TYPE", OFTInteger },
759 : { "CORRELATED", OFTInteger },
760 : { "BINARY_GAIN_RECOVERED", OFTInteger },
761 : { "AMPLITUDE_RECOVERY_METHOD", OFTInteger },
762 : { "MEASUREMENT_SYSTEM", OFTInteger },
763 : { "IMPULSE_SIGNAL_POLARITY", OFTInteger },
764 : { "VIBRATORY_POLARY_CODE", OFTInteger },
765 : { "SEGY_REVISION_NUMBER", OFTInteger },
766 : { "SEGY_FLOAT_REVISION_NUMBER", OFTReal },
767 : { "FIXED_LENGTH_TRACE_FLAG", OFTInteger },
768 : { "NUMBER_OF_EXTENDED_TEXTUAL_FILE_HEADER", OFTInteger },
769 : };
770 :
771 : #define HEADER_TEXT_HEADER 0
772 : #define HEADER_JOB_ID_NUMBER 1
773 : #define HEADER_LINE_NUMBER 2
774 : #define HEADER_REEL_NUMBER 3
775 : #define HEADER_DATA_TRACES_PER_ENSEMBLE 4
776 : #define HEADER_AUX_TRACES_PER_ENSEMBLE 5
777 : #define HEADER_SAMPLE_INTERVAL 6
778 : #define HEADER_SAMPLE_INTERVAL_ORIGINAL 7
779 : #define HEADER_SAMPLES_PER_DATA_TRACE 8
780 : #define HEADER_SAMPLES_PER_DATA_TRACE_ORIGINAL 9
781 : #define HEADER_DATA_SAMPLE_TYPE 10
782 : #define HEADER_ENSEMBLE_FOLD 11
783 : #define HEADER_TRACE_SORTING_CODE 12
784 : #define HEADER_VERTICAL_SUM_CODE 13
785 : #define HEADER_SWEEP_FREQUENCY_AT_START 14
786 : #define HEADER_SWEEP_FREQUENCY_AT_END 15
787 : #define HEADER_SWEEP_LENGTH 16
788 : #define HEADER_SWEEP_TYPE 17
789 : #define HEADER_TRACE_NUMBER_OF_SWEEP_CHANNEL 18
790 : #define HEADER_SWEEP_TRACE_TAPER_LENGTH_AT_START 19
791 : #define HEADER_SWEEP_TRACE_TAPER_LENGTH_AT_END 20
792 : #define HEADER_TAPER_TYPE 21
793 : #define HEADER_CORRELATED 22
794 : #define HEADER_BINARY_GAIN_RECOVERED 23
795 : #define HEADER_AMPLITUDE_RECOVERY_METHOD 24
796 : #define HEADER_MEASUREMENT_SYSTEM 25
797 : #define HEADER_IMPULSE_SIGNAL_POLARITY 26
798 : #define HEADER_VIBRATORY_POLARY_CODE 27
799 : #define HEADER_SEGY_REVISION_NUMBER 28
800 : #define HEADER_FLOAT_SEGY_REVISION_NUMBER 29
801 : #define HEADER_FIXED_LENGTH_TRACE_FLAG 30
802 : #define HEADER_NUMBER_OF_EXTENDED_TEXTUAL_FILE_HEADER 31
803 :
804 :
805 : /************************************************************************/
806 : /* OGRSEGYHeaderLayer() */
807 : /************************************************************************/
808 :
809 :
810 2 : OGRSEGYHeaderLayer::OGRSEGYHeaderLayer( const char* pszLayerName,
811 : SEGYBinaryFileHeader* psBFH,
812 2 : char* pszHeaderTextIn )
813 :
814 : {
815 2 : bEOF = FALSE;
816 2 : memcpy(&sBFH, psBFH, sizeof(sBFH));
817 2 : pszHeaderText = pszHeaderTextIn;
818 :
819 2 : poFeatureDefn = new OGRFeatureDefn( pszLayerName );
820 2 : poFeatureDefn->Reference();
821 2 : poFeatureDefn->SetGeomType( wkbNone );
822 :
823 : int i;
824 66 : for(i=0;i<(int)(sizeof(SEGYHeaderFields)/sizeof(SEGYHeaderFields[0]));i++)
825 : {
826 : OGRFieldDefn oField( SEGYHeaderFields[i].pszName,
827 64 : SEGYHeaderFields[i].eType );
828 64 : poFeatureDefn->AddFieldDefn( &oField );
829 : }
830 :
831 2 : ResetReading();
832 2 : }
833 :
834 : /************************************************************************/
835 : /* ~OGRSEGYLayer() */
836 : /************************************************************************/
837 :
838 2 : OGRSEGYHeaderLayer::~OGRSEGYHeaderLayer()
839 :
840 : {
841 2 : poFeatureDefn->Release();
842 2 : CPLFree(pszHeaderText);
843 2 : }
844 :
845 : /************************************************************************/
846 : /* ResetReading() */
847 : /************************************************************************/
848 :
849 2 : void OGRSEGYHeaderLayer::ResetReading()
850 :
851 : {
852 2 : bEOF = FALSE;
853 2 : }
854 :
855 : /************************************************************************/
856 : /* GetNextFeature() */
857 : /************************************************************************/
858 :
859 4 : OGRFeature *OGRSEGYHeaderLayer::GetNextFeature()
860 : {
861 : OGRFeature *poFeature;
862 :
863 0 : while(TRUE)
864 : {
865 4 : poFeature = GetNextRawFeature();
866 4 : if (poFeature == NULL)
867 2 : return NULL;
868 :
869 2 : if((m_poFilterGeom == NULL
870 : || FilterGeometry( poFeature->GetGeometryRef() ) )
871 : && (m_poAttrQuery == NULL
872 : || m_poAttrQuery->Evaluate( poFeature )) )
873 : {
874 2 : return poFeature;
875 : }
876 : else
877 0 : delete poFeature;
878 : }
879 : }
880 :
881 : /************************************************************************/
882 : /* GetNextRawFeature() */
883 : /************************************************************************/
884 :
885 4 : OGRFeature *OGRSEGYHeaderLayer::GetNextRawFeature()
886 : {
887 4 : if (bEOF)
888 2 : return NULL;
889 :
890 2 : bEOF = TRUE;
891 :
892 2 : OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
893 2 : poFeature->SetFID(0);
894 :
895 2 : poFeature->SetField(HEADER_TEXT_HEADER, pszHeaderText);
896 2 : poFeature->SetField(HEADER_JOB_ID_NUMBER, sBFH.nJobIdNumber);
897 2 : poFeature->SetField(HEADER_LINE_NUMBER, sBFH.nLineNumber);
898 2 : poFeature->SetField(HEADER_REEL_NUMBER, sBFH.nReelNumber);
899 2 : poFeature->SetField(HEADER_DATA_TRACES_PER_ENSEMBLE, sBFH.nDataTracesPerEnsemble);
900 2 : poFeature->SetField(HEADER_AUX_TRACES_PER_ENSEMBLE, sBFH.nAuxTracesPerEnsemble);
901 2 : poFeature->SetField(HEADER_SAMPLE_INTERVAL, sBFH.nSampleInterval);
902 2 : poFeature->SetField(HEADER_SAMPLE_INTERVAL_ORIGINAL, sBFH.nSampleIntervalOriginal);
903 2 : poFeature->SetField(HEADER_SAMPLES_PER_DATA_TRACE, sBFH.nSamplesPerDataTrace);
904 2 : poFeature->SetField(HEADER_SAMPLES_PER_DATA_TRACE_ORIGINAL, sBFH.nSamplesPerDataTraceOriginal);
905 2 : poFeature->SetField(HEADER_DATA_SAMPLE_TYPE, sBFH.nDataSampleType);
906 2 : poFeature->SetField(HEADER_ENSEMBLE_FOLD, sBFH.nEnsembleFold);
907 2 : poFeature->SetField(HEADER_TRACE_SORTING_CODE, sBFH.nTraceSortingCode);
908 2 : poFeature->SetField(HEADER_VERTICAL_SUM_CODE, sBFH.nVerticalSumCode);
909 2 : poFeature->SetField(HEADER_SWEEP_FREQUENCY_AT_START, sBFH.nSweepFrequencyAtStart);
910 2 : poFeature->SetField(HEADER_SWEEP_FREQUENCY_AT_END, sBFH.nSweepFrequencyAtEnd);
911 2 : poFeature->SetField(HEADER_SWEEP_LENGTH, sBFH.nSweepLength);
912 2 : poFeature->SetField(HEADER_SWEEP_TYPE, sBFH.nSweepType);
913 2 : poFeature->SetField(HEADER_TRACE_NUMBER_OF_SWEEP_CHANNEL, sBFH.nTraceNumberOfSweepChannel);
914 2 : poFeature->SetField(HEADER_SWEEP_TRACE_TAPER_LENGTH_AT_START, sBFH.nSweepTraceTaperLengthAtStart);
915 2 : poFeature->SetField(HEADER_SWEEP_TRACE_TAPER_LENGTH_AT_END, sBFH.nSweepTraceTaperLengthAtEnd);
916 2 : poFeature->SetField(HEADER_TAPER_TYPE, sBFH.nTaperType);
917 2 : poFeature->SetField(HEADER_CORRELATED, sBFH.nCorrelated);
918 2 : poFeature->SetField(HEADER_BINARY_GAIN_RECOVERED, sBFH.nBinaryGainRecovered);
919 2 : poFeature->SetField(HEADER_AMPLITUDE_RECOVERY_METHOD, sBFH.nAmplitudeRecoveryMethod);
920 2 : poFeature->SetField(HEADER_MEASUREMENT_SYSTEM, sBFH.nMeasurementSystem);
921 2 : poFeature->SetField(HEADER_IMPULSE_SIGNAL_POLARITY, sBFH.nImpulseSignalPolarity);
922 2 : poFeature->SetField(HEADER_VIBRATORY_POLARY_CODE, sBFH.nVibratoryPolaryCode);
923 2 : poFeature->SetField(HEADER_SEGY_REVISION_NUMBER, sBFH.nSEGYRevisionNumber);
924 2 : poFeature->SetField(HEADER_FLOAT_SEGY_REVISION_NUMBER, sBFH.dfSEGYRevisionNumber);
925 2 : poFeature->SetField(HEADER_FIXED_LENGTH_TRACE_FLAG, sBFH.nFixedLengthTraceFlag);
926 2 : poFeature->SetField(HEADER_NUMBER_OF_EXTENDED_TEXTUAL_FILE_HEADER, sBFH.nNumberOfExtendedTextualFileHeader);
927 :
928 2 : return poFeature;
929 : }
|
