data.c

seismic software,very useful

/* return long data name */
char    *DataLabel(data)
Data     data;
{
    static Message message;

    if (!data)
    return (0);
    sprintf(message, "%s: %dx%dx%dx%dx%d=%d samples", data->title,
        AxisSize(data->axis[DATA_AXIS1]),
        AxisSize(data->axis[DATA_AXIS2]),
        AxisSize(data->axis[DATA_AXIS3]),
        AxisSize(data->axis[DATA_AXIS4]),
        AxisSize(data->axis[DATA_AXIS5]),
        data->size, AxisLabel(data->axis[DATA_VALUE]));
    return (message);
}

/* return short data name */
char    *DataTitle(data)
Data     data;
{
    if (!data)
    return (0);
    return (data->title);
}

/* return data file */
char    *DataFile(data)
Data     data;
{
    if (!data)
    return (0);
    return (data->file);
}

/* return short name of dataset from filename */
char    *DataShortName(data)
Data     data;
{
    static string name;
    char    *c, *strrchr(), *strchr();

    /* truncate leading pathname */
    if ((c = strrchr(data->file, '/')) != NULL)
    strcpy(name, c + 1);
    else
    strcpy(name, data->file);
    /* truncate trailing tail */
    if ((c = strchr(name, '.')) != NULL)
    *c = '\0';
    return (name);
}

/* return data buffer */
Buffer DataBuffer(data)
Data     data;
{
    if (!data)
    return (0);
    return (data->buffer);
}

/* return axis reference */
Axis DataAxis(data, iaxis)
Data     data;
int      iaxis;
{
    if (!data || iaxis > DATA_NAXIS)
    return (0);
    return (data->axis[iaxis]);
}

/* return data size */
DataSize(data)
Data     data;
{
    return (data->size);
}

/* return longest dimension */
DataMaxDim(data)
Data     data;
{
    int      n[DATA_NAXIS], max, iaxis;

    if (!data)
    return (0);
    for (iaxis = 0, max = 1; iaxis < DATA_NAXIS - 1; iaxis++) {
    max =
        AxisSize(data->axis[iaxis + 1]) >
        max ? AxisSize(data->axis[iaxis + 1]) : max;
    }
    return (max);
}

/* return data amplitude */
float    DataValue(data, value)
Data     data;
int      value;
{
    return (data->low +
        ((data->high - data->low) * ((value & 0x7F) - data->value_base)) /
        DATA_VALUE_SIZE);
}

/* return data value size */
DataValueSize(data)
Data     data;
{
    if (!data)
    return (0);
    else
    return (data->value_size);
}

/* return base data value */
DataValueBase(data)
Data     data;
{
    if (!data)
    return (0);
    else
    return (data->value_base);
}


/* return data high clip */
float    DataHigh()
{
    extern Data data;

    if (!data)
    return (0.0);
    return (data->high);
}

/* return data low clip */
float    DataLow()
{
    extern Data data;

    if (!data)
    return (0.0);
    return (data->low);
}

/* return integer percentage of histogram */
DataHistogram(i)
int      i;
{
    extern Data data;

    if (!data || i < 0 || i > 255)
    return (0);
    return ((int) (100 * data->histogram[i]));
}

#ifdef OLD_HISTOGRAM

DataComputeHistogram(data)
Data     data;
{
    register Buffer bp, be;
    register float *hp;
    int      i;
    float    max;

    for (i = 0; i < 256; i++) {
    data->histogram[i] = 0;
    }
    for (bp = data->buffer, be = bp + data->size, hp = data->histogram; bp < be;
     bp++) {
    hp[*bp] += 1.;
    }
    for (i = 0, max = 0, data->hist_low = 255, data->hist_high = 0; i < 256;
     i++) {
    data->histogram[i] = data->histogram[i] / data->size;
    max = data->histogram[i] > max ? data->histogram[i] : max;
    if (data->hist_low == 255 && data->histogram[i] != 0)
        data->hist_low = i;
    if (data->histogram[i] != 0)
        data->hist_high = i;
    }
    max = max > 0. ? 1. / max : 0.;
    for (i = 0; i < 256; i++) {
    data->histogram[i] = data->histogram[i] * max;
    }
}

#else


DataComputeHistogram(data)
Data     data;
{
    register Buffer bp, be;
    int      i;
    float    max;
    int count;
    int bin;

    /*----------------------------*/
    /* clear the histogram buffer */
    /*----------------------------*/

    for (i = 0; i < 256; i++) {
        data->histogram[i] = 0;
    }

    /*------------------------------*/
    /* calculate total for each bin */
    /*------------------------------*/

    for (bp = data->buffer, be = bp + data->size; bp < be; bp++) {

        data->histogram[*bp] += 1.0;
    }

    /*------------------------------*/
    /* rescale totals to percentage */
    /*------------------------------*/

    max = 0;

    for (i = 0; i < ColorSize(); i++) {
        max = data->histogram[i] > max ? data->histogram[i] : max;
    }

    for (i = 0; i < ColorSize(); i++) {
        data->histogram[i] /= max;
    }
}

#endif

/* print data information */
DataInfo(data)
Data     data;
{
    Message  message;

    sprintf(message,
        "Data: %s: in=%s %dx%dx%dx%dx%d=%d esize=%d segy=%d hbytes=%d script=%s",
        data->title, data->file, AxisSize(data->axis[DATA_AXIS1]),
        AxisSize(data->axis[DATA_AXIS2]), AxisSize(data->axis[DATA_AXIS3]),
        AxisSize(data->axis[DATA_AXIS4]), AxisSize(data->axis[DATA_AXIS5]),
        data->size, data->esize, data->segy, data->hbytes, data->script);
    UIMessage(message);
}

/* data value parameters */
DataValueInfo(data)
Data     data;
{
    Message  message;

    sprintf(message,
        "Value: min=%g low=%g high=%g max=%g tpow=%g gpow=%g base=%d size=%d",
        data->min, data->low, data->high, data->max, data->tpow, data->gpow,
        data->value_base, data->value_size);
    UIMessage(message);
}

/* save data parameters */
DataSavePar(data)
Data     data;
{
    int      iaxis;
    Message  message;

    if (!data)
    return;
    sprintf(message,
        "Data: %s: in=%s %dx%dx%dx%dx%d=%d esize=%d segy=%d hbytes=%d script=%s",
        data->title, data->file, AxisSize(data->axis[DATA_AXIS1]),
        AxisSize(data->axis[DATA_AXIS2]), AxisSize(data->axis[DATA_AXIS3]),
        AxisSize(data->axis[DATA_AXIS4]), AxisSize(data->axis[DATA_AXIS5]),
        data->size, data->esize, data->segy, data->hbytes, data->script);
    UISaveMessage(message);
    sprintf(message,
        "Value: min=%g low=%g high=%g max=%g tpow=%d gpow=%g base=%d size=%d",
        data->min, data->low, data->high, data->max, data->tpow, data->gpow,
        data->value_base, data->value_size);
    UISaveMessage(message);
    for (iaxis = DATA_AXIS1; iaxis <= DATA_AXIS5; iaxis++) {
    AxisSavePar(data->axis[iaxis]);
    }
}

/* dump data bytes */
DataDumpBytes(data, file, fd)
Data     data;
char    *file;
int      fd;
{
    string   parfile, datafile;
    register byte bp, be;
    Message  message;

    DrawWatch(1);
    for (bp = data->buffer, be = bp + data->size; bp < be;)
    *bp++ <<= 1;
    write(fd, data->buffer, data->size);
    for (bp = data->buffer, be = bp + data->size; bp < be;)
    *bp++ >>= 1;
    DataDumpHeader(data, file, fd, 1);
    DrawWatch(0);
}

/* dump data vgrid header */
DataDumpHeader(data, file, datafd, esize)
Data     data;
string   file;
int      datafd, esize;
{
    Message  message;
    char     parfile[80];
    extern FILE *savefd;

    if (data->gh.dtype == 0.) { /* build a header */
    data->gh.scale = 1.;
    data->gh.n1 = AxisSize(data->axis[DATA_AXIS1]) * data->gh.scale;
    data->gh.n2 = AxisSize(data->axis[DATA_AXIS2]) * data->gh.scale;
    data->gh.n3 = AxisSize(data->axis[DATA_AXIS3]) * data->gh.scale;
    data->gh.n4 = AxisSize(data->axis[DATA_AXIS4]) * data->gh.scale;
    data->gh.n5 = AxisSize(data->axis[DATA_AXIS5]) * data->gh.scale;
    data->gh.d1 = AxisDelta(data->axis[DATA_AXIS1]) * data->gh.scale;
    data->gh.d2 = AxisDelta(data->axis[DATA_AXIS2]) * data->gh.scale;
    data->gh.d3 = AxisDelta(data->axis[DATA_AXIS3]) * data->gh.scale;
    data->gh.d4 = AxisDelta(data->axis[DATA_AXIS4]) * data->gh.scale;
    data->gh.d5 = AxisDelta(data->axis[DATA_AXIS5]) * data->gh.scale;
    data->gh.o1 = AxisFirst(data->axis[DATA_AXIS1]) * data->gh.scale;
    data->gh.o2 = AxisFirst(data->axis[DATA_AXIS2]) * data->gh.scale;
    data->gh.o3 = AxisFirst(data->axis[DATA_AXIS3]) * data->gh.scale;
    data->gh.o4 = AxisFirst(data->axis[DATA_AXIS4]) * data->gh.scale;
    data->gh.o5 = AxisFirst(data->axis[DATA_AXIS5]) * data->gh.scale;
    data->gh.dcdp2 = 1.;
    data->gh.dline3 = 1.;
    data->gh.ocdp2 = 1.;
    data->gh.oline3 = 1.;
    data->gh.gmin = data->low * data->gh.scale;
    data->gh.gmax = data->high * data->gh.scale;
    }
    data->gh.dtype = esize * data->gh.scale;
    write(datafd, &data->gh, sizeof(data->gh));
    close(datafd);
    sprintf(parfile, "%s.H", file);
    if ((savefd = fopen(parfile, "w")) == NULL);
    UIMessage("cant create vgrid parfile");
    DataSavePar(data);
    sprintf(message, "Byte data dump into %s", parfile);
    UIMessage(message);
    fclose(savefd);
}

/* dump data floats */
DataDumpFloats(data, file, fd)
Data     data;
char    *file;
int      fd;
{
    string   parfile, datafile;
    int      nn, n3, i;
    Buffer   dbuf;
    float   *fbuf, min, max;
    Message  message;

    DrawWatch(1);
    nn = AxisSize(data->axis[DATA_AXIS1]) * AxisSize(data->axis[DATA_AXIS2]);
    n3 = data->size / nn;
    NEW(float *, fbuf, nn);

    /* convert and dump a plane at a time */
    min = data->high;
    max = data->low;
    for (i = 0, dbuf = data->buffer; i < n3; i++, dbuf += nn) {
    Data2Float(dbuf, fbuf, nn, &min, &max);
    write(fd, fbuf, nn * sizeof(fbuf[0]));
    }
    data->gh.gmin = min * data->gh.scale;
    data->gh.gmax = max * data->gh.scale;
    DataDumpHeader(data, file, fd, 4);
    FREE(fbuf);
    DrawWatch(0);
}

Data2Float(dbuf, fbuf, n, min, max)
Buffer   dbuf;
float   *fbuf, *min, *max;
int      n;
{
    register Buffer bp, be;
    register float *fp, *mp, *fe, Min, Max;
    extern Data data;

    Min = *min;
    Max = *max;
    /* convert */
    for (mp = AxisValues(data->axis[DATA_VALUE]) - DATA_VALUE_BASE, bp =
     dbuf, fp = fbuf, be = dbuf + n; bp < be; bp++, fp++) {
    *fp = mp[*bp];
    Max = Max > *fp ? Max : *fp;
    Min = Min < *fp ? Min : *fp;
    }
    *min = Min;
    *max = Max;
}

rint(x)
float    x;
{
    int      i;

    i = x;
    return ((x - i) < (1 - (x - i)) ? i : i + 1);
}