Ignore:
Timestamp:
Mar 20, 2012, 2:25:37 AM (8 years ago)
Author:
ldelgass
Message:

formatting/style changes only

File:
1 edited

Legend:

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

    r2844 r2871  
    77
    88#include "Axis.h"
    9 
    10 NaN _NaN;
    119
    1210inline bool DEFINED(double x) {
     
    8381
    8482void
    85 Ticks::SetTicks(void)
    86 {
    87     numTicks_ = 0;
    88     ticks_ = new float[nSteps_];
    89     if (step_ == 0.0) {
     83Ticks::SetTicks()
     84{
     85    _numTicks = 0;
     86    _ticks = new float[_nSteps];
     87    if (_step == 0.0) {
    9088        /* Hack: A zero step indicates to use log values. */
    9189        unsigned int i;
     
    103101            1.0
    104102        };
    105         for (i = 0; i < nSteps_; i++) {
    106             ticks_[i] = logTable[i];
     103        for (i = 0; i < _nSteps; i++) {
     104            _ticks[i] = logTable[i];
    107105        }
    108106    } else {
     
    110108        unsigned int i;
    111109   
    112         value = initial_;       /* Start from smallest axis tick */
    113         for (i = 0; i < nSteps_; i++) {
    114             value = initial_ + (step_ * i);
    115             ticks_[i] = UROUND(value, step_);
    116         }
    117     }
    118     numTicks_ = nSteps_;
     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;
    119117}
    120118
    121119Axis::Axis(const char *axisName) :
    122     major_(5), minor_(2)
    123 {
    124     name_ = NULL;
    125     name(axisName);
    126     units_ = NULL;
    127     title_ = NULL;
    128     valueMin_ = DBL_MAX, valueMax_ = -DBL_MAX;
    129     min_ = DBL_MAX, max_ = -DBL_MAX;
    130     reqMin_ = reqMax_ = _NaN;
    131     range_ = 0.0, scale_ = 0.0;
    132     reqStep_ = 0.0;
    133     flags_ = AUTOSCALE;
     120    _name(axisName),
     121    _flags(AUTOSCALE),
     122    _title(NULL),
     123    _units(NULL),
     124    _valueMin(DBL_MAX),
     125    _valueMax(-DBL_MAX),
     126    _reqMin(NAN),
     127    _reqMax(NAN),
     128    _min(DBL_MAX),
     129    _max(-DBL_MAX),
     130    _range(0.0),
     131    _scale(0.0),
     132    _reqStep(0.0),
     133    _major(5),
     134    _minor(2)
     135{
    134136}
    135137
     
    158160Axis::InRange(double x)
    159161{
    160     if (range_ < DBL_EPSILON) {
    161         return (fabs(max_ - x) >= DBL_EPSILON);
     162    if (_range < DBL_EPSILON) {
     163        return (fabs(_max - x) >= DBL_EPSILON);
    162164    } else {
    163         x = (x - min_) * scale_;
     165        x = (x - _min) * _scale;
    164166        return ((x >= -DBL_EPSILON) && ((x - 1.0) < DBL_EPSILON));
    165167    }
     
    170172{
    171173    if (min == DBL_MAX) {
    172         if (DEFINED(reqMin_)) {
    173             min = reqMin_;
    174         } else {
    175             min = (flags_ & LOGSCALE) ? 0.001 : 0.0;
     174        if (DEFINED(_reqMin)) {
     175            min = _reqMin;
     176        } else {
     177            min = (_flags & LOGSCALE) ? 0.001 : 0.0;
    176178        }
    177179    }
    178180    if (max == -DBL_MAX) {
    179         if (DEFINED(reqMax_)) {
    180             max = reqMax_;
     181        if (DEFINED(_reqMax)) {
     182            max = _reqMax;
    181183        } else {
    182184            max = 1.0;
     
    199201     * values selected by the user with the -min or -max options.
    200202     */
    201     valueMin_ = (DEFINED(reqMin_)) ? reqMin_ : min;
    202     valueMax_ = (DEFINED(reqMax_)) ? reqMax_ : max;
    203     if (valueMax_ < valueMin_) {
     203    _valueMin = (DEFINED(_reqMin)) ? _reqMin : min;
     204    _valueMax = (DEFINED(_reqMax)) ? _reqMax : max;
     205    if (_valueMax < _valueMin) {
    204206        /*   
    205207         * If the limits still don't make sense, it's because one limit
     
    208210         * up a new min or max from the user-defined limit.
    209211         */
    210         if (!DEFINED(reqMin_)) {
    211             valueMin_ = valueMax_ - (fabs(valueMax_) * 0.1);
    212         }
    213         if (!DEFINED(reqMax_)) {
    214             valueMax_ = valueMin_ + (fabs(valueMax_) * 0.1);
     212        if (!DEFINED(_reqMin)) {
     213            _valueMin = _valueMax - (fabs(_valueMax) * 0.1);
     214        }
     215        if (!DEFINED(_reqMax)) {
     216            _valueMax = _valueMin + (fabs(_valueMax) * 0.1);
    215217        }
    216218    }
     
    302304    /* Suppress compiler warnings. */
    303305    majorStep = minorStep = 0.0;
    304     tickMin = tickMax = _NaN;
    305     min = valueMin_, max = valueMax_;
     306    tickMin = tickMax = NAN;
     307    min = _valueMin, max = _valueMax;
    306308    if (min < max) {
    307309        min = (min != 0.0) ? log10(fabs(min)) : 0.0;
     
    316318             * decade.  Instead, treat the axis as a linear scale.  */
    317319            range = NiceNum(range, 0);
    318             majorStep = NiceNum(range / major_.reqNumTicks, 1);
     320            majorStep = NiceNum(range / _major.reqNumTicks, 1);
    319321            tickMin = UFLOOR(tickMin, majorStep);
    320322            tickMax = UCEIL(tickMax, majorStep);
     
    341343            nMinor = 10;
    342344        }
    343         if ((flags_ & TIGHT_MIN) || (DEFINED(reqMin_))) {
     345        if ((_flags & TIGHT_MIN) || (DEFINED(_reqMin))) {
    344346            tickMin = min;
    345347            nMajor++;
    346348        }
    347         if ((flags_ & TIGHT_MAX) || (DEFINED(reqMax_))) {
     349        if ((_flags & TIGHT_MAX) || (DEFINED(_reqMax))) {
    348350            tickMax = max;
    349351        }
    350352    }
    351     major_.SetValues(floor(tickMin), majorStep, nMajor);
    352     minor_.SetValues(minorStep, minorStep, nMinor);
    353     min_ = tickMin;
    354     max_ = tickMax;
    355     range_ = max_ - min_;
    356     scale_ = 1.0 / range_;
     353    _major.SetValues(floor(tickMin), majorStep, nMajor);
     354    _minor.SetValues(minorStep, minorStep, nMinor);
     355    _min = tickMin;
     356    _max = tickMax;
     357    _range = _max - _min;
     358    _scale = 1.0 / _range;
    357359}
    358360
     
    429431    /* Suppress compiler warning. */
    430432    tickMin = tickMax = 0.0;
    431     if (valueMin_ < valueMax_) {
     433    if (_valueMin < _valueMax) {
    432434        double range;
    433435
    434         range = valueMax_ - valueMin_;
     436        range = _valueMax - _valueMin;
    435437        /* Calculate the major tick stepping. */
    436         if (reqStep_ > 0.0) {
     438        if (_reqStep > 0.0) {
    437439            /* An interval was designated by the user.  Keep scaling it until
    438440             * it fits comfortably within the current range of the axis.  */
    439             step = reqStep_;
     441            step = _reqStep;
    440442            while ((2 * step) >= range) {
    441443                step *= 0.5;
     
    443445        } else {
    444446            range = NiceNum(range, 0);
    445             step = NiceNum(range / major_.reqNumTicks, 1);
     447            step = NiceNum(range / _major.reqNumTicks, 1);
    446448        }
    447449       
    448450        /* Find the outer tick values. Add 0.0 to prevent getting -0.0. */
    449         tickMin = floor(valueMin_ / step) * step + 0.0;
    450         tickMax = ceil(valueMax_ / step) * step + 0.0;
     451        tickMin = floor(_valueMin / step) * step + 0.0;
     452        tickMax = ceil(_valueMax / step) * step + 0.0;
    451453       
    452454        nTicks = ROUND((tickMax - tickMin) / step) + 1;
    453455    }
    454     major_.SetValues(tickMin, step, nTicks);
     456    _major.SetValues(tickMin, step, nTicks);
    455457
    456458    /*
     
    462464     * assume that user would have picked a different number).
    463465     */
    464     min_ = ((flags_ & TIGHT_MIN)||(DEFINED(reqMin_))) ? valueMin_ : tickMin;
    465     max_ = ((flags_ & TIGHT_MAX)||(DEFINED(reqMax_))) ? valueMax_ : tickMax;
    466     range_ = max_ - min_;
    467     scale_ = 1.0 / range_;
     466    _min = ((_flags & TIGHT_MIN)||(DEFINED(_reqMin))) ? _valueMin : tickMin;
     467    _max = ((_flags & TIGHT_MAX)||(DEFINED(_reqMax))) ? _valueMax : tickMax;
     468    _range = _max - _min;
     469    _scale = 1.0 / _range;
    468470
    469471    /* Now calculate the minor tick step and number. */
    470472
    471     if ((minor_.reqNumTicks > 0) && (minor_.autoscale())) {
    472         nTicks = minor_.reqNumTicks - 1;
     473    if ((_minor.reqNumTicks > 0) && (_minor.autoscale())) {
     474        nTicks = _minor.reqNumTicks - 1;
    473475        step = 1.0 / (nTicks + 1);
    474476    } else {
     
    478480                                 * create minor log-scale tick marks.  */
    479481    }
    480     minor_.SetValues(step, step, nTicks);
     482    _minor.SetValues(step, step, nTicks);
    481483}
    482484
     
    486488{
    487489    FixRange(min, max);
    488     if (flags_ & LOGSCALE) {
     490    if (_flags & LOGSCALE) {
    489491        LogScale();
    490492    } else {
    491493        LinearScale();
    492494    }
    493     major_.SweepTicks();
    494     minor_.SweepTicks();
     495    _major.SweepTicks();
     496    _minor.SweepTicks();
    495497    MakeTicks();
    496498}
    497499
    498500void
    499 Axis::MakeTicks(void)
    500 {
    501     major_.Reset();
    502     minor_.Reset();
     501Axis::MakeTicks()
     502{
     503    _major.Reset();
     504    _minor.Reset();
    503505    int i;
    504     for (i = 0; i < major_.numTicks(); i++) {
     506    for (i = 0; i < _major.numTicks(); i++) {
    505507        double t1, t2;
    506508        int j;
    507509       
    508         t1 = major_.tick(i);
     510        t1 = _major.tick(i);
    509511        /* Minor ticks */
    510         for (j = 0; j < minor_.numTicks(); j++) {
    511             t2 = t1 + (major_.step() * minor_.tick(j));
     512        for (j = 0; j < _minor.numTicks(); j++) {
     513            t2 = t1 + (_major.step() * _minor.tick(j));
    512514            if (!InRange(t2)) {
    513515                continue;
     
    516518                continue;       // Don't add duplicate minor ticks.
    517519            }
    518             minor_.Append(t2);
     520            _minor.Append(t2);
    519521        }
    520522        if (!InRange(t1)) {
    521523            continue;
    522524        }
    523         major_.Append(t1);
     525        _major.Append(t1);
    524526    }
    525527}
     
    528530Axis::Map(double x)
    529531{
    530     if ((flags_ & LOGSCALE) && (x != 0.0)) {
     532    if ((_flags & LOGSCALE) && (x != 0.0)) {
    531533        x = log10(fabs(x));
    532534    }
    533535    /* Map graph coordinate to normalized coordinates [0..1] */
    534     x = (x - min_) * scale_;
    535     if (flags_ & DESCENDING) {
     536    x = (x - _min) * _scale;
     537    if (_flags & DESCENDING) {
    536538        x = 1.0 - x;
    537539    }
     
    542544Axis::InvMap(double x)
    543545{
    544     if (flags_ & DESCENDING) {
     546    if (_flags & DESCENDING) {
    545547        x = 1.0 - x;
    546548    }
    547     x = (x * range_) + min_;
    548     if (flags_ & LOGSCALE) {
     549    x = (x * _range) + _min;
     550    if (_flags & LOGSCALE) {
    549551        x = EXP10(x);
    550552    }
Note: See TracChangeset for help on using the changeset viewer.