Ignore:
Timestamp:
Aug 13, 2008, 4:33:28 PM (11 years ago)
Author:
gah
Message:

nanovis/heightmap update

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/nanovis/Axis.cpp

    r1028 r1111  
    8383Ticks::SetTicks(void)
    8484{
    85     _nTicks = 0;
    86     _ticks = new float[_nSteps];
    87     if (_step == 0.0) {
     85    numTicks_ = 0;
     86    ticks_ = new float[nSteps_];
     87    if (step_ == 0.0) {
    8888        /* Hack: A zero step indicates to use log values. */
    8989        unsigned int i;
     
    101101            1.0
    102102        };
    103         for (i = 0; i < _nSteps; i++) {
    104             _ticks[i] = logTable[i];
     103        for (i = 0; i < nSteps_; i++) {
     104            ticks_[i] = logTable[i];
    105105        }
    106106    } else {
     
    108108        unsigned int i;
    109109   
    110         value = _initial;       /* Start from smallest axis tick */
    111         for (i = 0; i < _nSteps; i++) {
    112             value = _initial + (_step * i);
    113             _ticks[i] = UROUND(value, _step);
    114         }
    115     }
    116     _nTicks = _nSteps;
    117 }
    118 
    119 Axis::Axis(const char *name) :
    120     _major(5), _minor(2)
    121 {
    122     _name = NULL;
    123     SetName(name);
    124     _units = NULL;
    125     _title = NULL;
    126     _valueMin = DBL_MAX, _valueMax = -DBL_MAX;
    127     _min = DBL_MAX, _max = -DBL_MAX;
    128     _reqMin = _reqMax = _NaN;
    129     _range = 0.0, _scale = 0.0;
    130     _reqStep = 0.0;
    131     _flags = AUTOSCALE;
     110        value = initial_;       /* Start from smallest axis tick */
     111        for (i = 0; i < nSteps_; i++) {
     112            value = initial_ + (step_ * i);
     113            ticks_[i] = UROUND(value, step_);
     114        }
     115    }
     116    numTicks_ = nSteps_;
     117}
     118
     119Axis::Axis(const char *axisName) :
     120    major_(5), minor_(2)
     121{
     122    name_ = NULL;
     123    name(axisName);
     124    units_ = NULL;
     125    title_ = NULL;
     126    valueMin_ = DBL_MAX, valueMax_ = -DBL_MAX;
     127    min_ = DBL_MAX, max_ = -DBL_MAX;
     128    reqMin_ = reqMax_ = _NaN;
     129    range_ = 0.0, scale_ = 0.0;
     130    reqStep_ = 0.0;
     131    flags_ = AUTOSCALE;
    132132}
    133133
     
    156156Axis::InRange(double x)
    157157{
    158     if (_range < DBL_EPSILON) {
    159         return (fabs(_max - x) >= DBL_EPSILON);
     158    if (range_ < DBL_EPSILON) {
     159        return (fabs(max_ - x) >= DBL_EPSILON);
    160160    } else {
    161         x = (x - _min) * _scale;
     161        x = (x - min_) * scale_;
    162162        return ((x >= -DBL_EPSILON) && ((x - 1.0) < DBL_EPSILON));
    163163    }
     
    168168{
    169169    if (min == DBL_MAX) {
    170         if (DEFINED(_reqMin)) {
    171             min = _reqMin;
    172         } else {
    173             min = (_flags & LOGSCALE) ? 0.001 : 0.0;
     170        if (DEFINED(reqMin_)) {
     171            min = reqMin_;
     172        } else {
     173            min = (flags_ & LOGSCALE) ? 0.001 : 0.0;
    174174        }
    175175    }
    176176    if (max == -DBL_MAX) {
    177         if (DEFINED(_reqMax)) {
    178             max = _reqMax;
     177        if (DEFINED(reqMax_)) {
     178            max = reqMax_;
    179179        } else {
    180180            max = 1.0;
     
    197197     * values selected by the user with the -min or -max options.
    198198     */
    199     _valueMin = (DEFINED(_reqMin)) ? _reqMin : min;
    200     _valueMax = (DEFINED(_reqMax)) ? _reqMax : max;
    201     if (_valueMax < _valueMin) {
     199    valueMin_ = (DEFINED(reqMin_)) ? reqMin_ : min;
     200    valueMax_ = (DEFINED(reqMax_)) ? reqMax_ : max;
     201    if (valueMax_ < valueMin_) {
    202202        /*   
    203203         * If the limits still don't make sense, it's because one limit
     
    206206         * up a new min or max from the user-defined limit.
    207207         */
    208         if (!DEFINED(_reqMin)) {
    209             _valueMin = _valueMax - (fabs(_valueMax) * 0.1);
    210         }
    211         if (!DEFINED(_reqMax)) {
    212             _valueMax = _valueMin + (fabs(_valueMax) * 0.1);
     208        if (!DEFINED(reqMin_)) {
     209            valueMin_ = valueMax_ - (fabs(valueMax_) * 0.1);
     210        }
     211        if (!DEFINED(reqMax_)) {
     212            valueMax_ = valueMin_ + (fabs(valueMax_) * 0.1);
    213213        }
    214214    }
     
    301301    majorStep = minorStep = 0.0;
    302302    tickMin = tickMax = _NaN;
    303     min = _valueMin, max = _valueMax;
     303    min = valueMin_, max = valueMax_;
    304304    if (min < max) {
    305305        min = (min != 0.0) ? log10(fabs(min)) : 0.0;
     
    314314             * decade.  Instead, treat the axis as a linear scale.  */
    315315            range = NiceNum(range, 0);
    316             majorStep = NiceNum(range / _major.reqNumTicks, 1);
     316            majorStep = NiceNum(range / major_.reqNumTicks, 1);
    317317            tickMin = UFLOOR(tickMin, majorStep);
    318318            tickMax = UCEIL(tickMax, majorStep);
     
    339339            nMinor = 10;
    340340        }
    341         if ((_flags & TIGHT_MIN) || (DEFINED(_reqMin))) {
     341        if ((flags_ & TIGHT_MIN) || (DEFINED(reqMin_))) {
    342342            tickMin = min;
    343343            nMajor++;
    344344        }
    345         if ((_flags & TIGHT_MAX) || (DEFINED(_reqMax))) {
     345        if ((flags_ & TIGHT_MAX) || (DEFINED(reqMax_))) {
    346346            tickMax = max;
    347347        }
    348348    }
    349     _major.SetValues(majorStep, nMajor, floor(tickMin));
    350     _minor.SetValues(minorStep, nMinor, minorStep);
    351     _min = tickMin;
    352     _max = tickMax;
    353     _range = _max - _min;
    354     _scale = 1.0 / _range;
     349    major_.SetValues(majorStep, nMajor, floor(tickMin));
     350    minor_.SetValues(minorStep, nMinor, minorStep);
     351    min_ = tickMin;
     352    max_ = tickMax;
     353    range_ = max_ - min_;
     354    scale_ = 1.0 / range_;
    355355}
    356356
     
    427427    /* Suppress compiler warning. */
    428428    tickMin = tickMax = 0.0;
    429     if (_valueMin < _valueMax) {
     429    if (valueMin_ < valueMax_) {
    430430        double range;
    431431
    432         range = _valueMax - _valueMin;
     432        range = valueMax_ - valueMin_;
    433433        /* Calculate the major tick stepping. */
    434         if (_reqStep > 0.0) {
     434        if (reqStep_ > 0.0) {
    435435            /* An interval was designated by the user.  Keep scaling it until
    436436             * it fits comfortably within the current range of the axis.  */
    437             step = _reqStep;
     437            step = reqStep_;
    438438            while ((2 * step) >= range) {
    439439                step *= 0.5;
     
    441441        } else {
    442442            range = NiceNum(range, 0);
    443             step = NiceNum(range / _major.reqNumTicks, 1);
     443            step = NiceNum(range / major_.reqNumTicks, 1);
    444444        }
    445445       
    446446        /* Find the outer tick values. Add 0.0 to prevent getting -0.0. */
    447         tickMin = floor(_valueMin / step) * step + 0.0;
    448         tickMax = ceil(_valueMax / step) * step + 0.0;
     447        tickMin = floor(valueMin_ / step) * step + 0.0;
     448        tickMax = ceil(valueMax_ / step) * step + 0.0;
    449449       
    450450        nTicks = ROUND((tickMax - tickMin) / step) + 1;
    451451    }
    452     _major.SetValues(tickMin, step, nTicks);
     452    major_.SetValues(tickMin, step, nTicks);
    453453
    454454    /*
     
    460460     * assume that user would have picked a different number).
    461461     */
    462     _min = ((_flags & TIGHT_MIN)||(DEFINED(_reqMin))) ? _valueMin : tickMin;
    463     _max = ((_flags & TIGHT_MAX)||(DEFINED(_reqMax))) ? _valueMax : tickMax;
    464     _range = _max - _min;
    465     _scale = 1.0 / _range;
     462    min_ = ((flags_ & TIGHT_MIN)||(DEFINED(reqMin_))) ? valueMin_ : tickMin;
     463    max_ = ((flags_ & TIGHT_MAX)||(DEFINED(reqMax_))) ? valueMax_ : tickMax;
     464    range_ = max_ - min_;
     465    scale_ = 1.0 / range_;
    466466
    467467    /* Now calculate the minor tick step and number. */
    468468
    469     if ((_minor.reqNumTicks > 0) && (_minor.IsAutoScale())) {
    470         nTicks = _minor.reqNumTicks - 1;
     469    if ((minor_.reqNumTicks > 0) && (minor_.autoscale())) {
     470        nTicks = minor_.reqNumTicks - 1;
    471471        step = 1.0 / (nTicks + 1);
    472472    } else {
     
    476476                                 * create minor log-scale tick marks.  */
    477477    }
    478     _minor.SetValues(step, step, nTicks);
     478    minor_.SetValues(step, step, nTicks);
    479479}
    480480
     
    484484{
    485485    FixRange(min, max);
    486     if (_flags & LOGSCALE) {
     486    if (flags_ & LOGSCALE) {
    487487        LogScale();
    488488    } else {
    489489        LinearScale();
    490490    }
    491     _major.SweepTicks();
    492     _minor.SweepTicks();
     491    major_.SweepTicks();
     492    minor_.SweepTicks();
    493493    MakeTicks();
    494494}
     
    497497Axis::MakeTicks(void)
    498498{
    499     _major.Reset();
    500     _minor.Reset();
     499    major_.Reset();
     500    minor_.Reset();
    501501    int i;
    502     for (i = 0; i < _major.NumTicks(); i++) {
     502    for (i = 0; i < major_.numTicks(); i++) {
    503503        double t1, t2;
    504504        int j;
    505505       
    506         t1 = _major.GetTick(i);
     506        t1 = major_.tick(i);
    507507        /* Minor ticks */
    508         for (j = 0; j < _minor.NumTicks(); j++) {
    509             t2 = t1 + (_major.Step() * _minor.GetTick(j));
     508        for (j = 0; j < minor_.numTicks(); j++) {
     509            t2 = t1 + (major_.step() * minor_.tick(j));
    510510            if (!InRange(t2)) {
    511511                continue;
     
    514514                continue;       // Don't add duplicate minor ticks.
    515515            }
    516             _minor.Append(t2);
     516            minor_.Append(t2);
    517517        }
    518518        if (!InRange(t1)) {
    519519            continue;
    520520        }
    521         _major.Append(t1);
     521        major_.Append(t1);
    522522    }
    523523}
     
    526526Axis::Map(double x)
    527527{
    528     if ((_flags & LOGSCALE) && (x != 0.0)) {
     528    if ((flags_ & LOGSCALE) && (x != 0.0)) {
    529529        x = log10(fabs(x));
    530530    }
    531531    /* Map graph coordinate to normalized coordinates [0..1] */
    532     x = (x - _min) * _scale;
    533     if (_flags & DESCENDING) {
     532    x = (x - min_) * scale_;
     533    if (flags_ & DESCENDING) {
    534534        x = 1.0 - x;
    535535    }
     
    540540Axis::InvMap(double x)
    541541{
    542     if (_flags & DESCENDING) {
     542    if (flags_ & DESCENDING) {
    543543        x = 1.0 - x;
    544544    }
    545     x = (x * _range) + _min;
    546     if (_flags & LOGSCALE) {
     545    x = (x * range_) + min_;
     546    if (flags_ & LOGSCALE) {
    547547        x = EXP10(x);
    548548    }
Note: See TracChangeset for help on using the changeset viewer.