set() [2/2]

void datrw::su::ScalCoo::set

(

const double &

value

)

set from coordinate value in meters

set from coordinate value in meters

this functions takes the coordinate value as a floating point value in meters; it has to find the appropriate scaling to represent this value with appropriate precision in an integer variable

Definition at line 141 of file sucomanager.cc.

References coo, datrw::su::options::SpatialSampling::coodigits, DATRW_assert, DATRW_debug, DATRW_report_assert, effectivezero, Mcontrol, datrw::util::nsignificantdigits(), datrw::util::ntrailingdigits(), datrw::su::options::SpatialSampling::scalco, scale, scaletopower(), smallestpower(), and value().

    {
      const bool debug=false;
      this->scale=1;
      this->coo=static_cast<int>(nearbyint(value));
      double v=(value>=0 ? value : -value);
      if (v<ScalCoo::effectivezero)
      {
        this->scale=1;
        this->coo=0;
      }
      else
      {
        DATRW_debug(debug, "ScalCoo::set(const double& v)",
                    "v: " << helper::MyOutputFormat() << v << "\n"
                    "log10(v): " << std::log10(v) << "\n"
                    "floor(log10(v)): " << std::floor(std::log10(v)));
        int nlead=1+static_cast<int>(std::floor(std::log10(v)));
        int ntrail=::datrw::util::ntrailingdigits(v);
        int nsig=::datrw::util::nsignificantdigits(v, debug);
        int nzero=ntrail-nsig;
        DATRW_debug(debug, "ScalCoo::set(const double& v)",
                    "nlead: " << nlead << 
                    " ntrail: " << ntrail << 
                    " nsig: " << nsig);
        nsig = nsig>static_cast<int>(Mcontrol.coodigits)
          ? Mcontrol.coodigits : nsig;
        ntrail=nsig+nzero;
        DATRW_debug(debug, "ScalCoo::set(const double& v)",
                    "nlead: " << nlead << 
                    " ntrail: " << ntrail << 
                    " nsig: " << nsig);
        if (ntrail>0)
        {
          DATRW_debug(debug, "ScalCoo::set(const double& value)",
                      "ntrail>0");
          int s=std::pow(10,ntrail);
          s = s > 10000 ? 10000 : s;
          DATRW_assert(s<100000,
                       "ERROR (ScalCoo::set): scale too large");
          this->scale=-s;
          this->coo=static_cast<int>(nearbyint(value*s));
          // check truncation error
          double truevalue=value*s;
          double roundedvalue=nearbyint(truevalue);
          double truncationerror=fabs(1.-(truevalue/roundedvalue));
          DATRW_debug(debug, "ScalCoo::set(const double& value)",
                      "truncation error:"
                      << " truevalue: " << truevalue
                      << " roundedvalue: " << roundedvalue
                      << " truncationerror: " << truncationerror);
          DATRW_report_assert(truncationerror<0.001,
                              "WARNING (ScalCoo::set) " 
                              "truncation error > 0.1%\n"
                              "coordinate value " 
                              << helper::MyOutputFormat() << value
                              << " will be truncated!"
                              << "\n*"
                              << " scaled value: " << truevalue
                              << " rounded scaled value: "
                              << roundedvalue);
        }
        else if (nlead>nsig)
        {
          DATRW_debug(debug, "ScalCoo::set(const double& value)",
                      "nlead>nsig");
          int s=std::pow(10,nlead-nsig);
          s = s > 10000 ? 10000 : s;
          DATRW_assert(s<100000,
                       "ERROR (ScalCoo::set): scale too large");
          this->scale=s;
          this->coo=static_cast<int>(nearbyint(value/s));
        }
      } // if (v<ScalCoo::effectivezero), else clause
      // adjust scale
      this->scaletopower(this->smallestpower(Mcontrol.scalco));
      DATRW_debug(debug, "ScalCoo::set(const double& value)",
                  "value on exit:" 
                  << " value: " << value
                  << " this->coo: " << this->coo
                  << " this->scale: " << this->scale);
    } // void ScalCoo::set(const double& v)

Here is the call graph for this function: