File indexing completed on 2025-01-26 03:34:10

 /*
     File                 : CartesianScale.cpp
     Project              : LabPlot
     Description          : Cartesian coordinate system for plots.
     --------------------------------------------------------------------
     SPDX-FileCopyrightText: 2012-2016 Alexander Semke <alexander.semke@web.de>
     SPDX-FileCopyrightText: 2020-2021 Stefan Gerlach <stefan.gerlach@uni.kn>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "CartesianScale.h"
 
 #include <gsl/gsl_math.h>
 
 /**
  * \class CartesianScale
  * \brief Base class for cartesian coordinate system scales.
  */
 CartesianScale::CartesianScale(const Range<double>& range, double a, double b, double c)
     : m_range(range)
     , m_a(a)
     , m_b(b)
     , m_c(c) {
 }
 
 CartesianScale::~CartesianScale() = default;
 
 void CartesianScale::getProperties(Range<double>* range, double* a, double* b, double* c) const {
     if (range)
         *range = m_range;
     if (a)
         *a = m_a;
     if (b)
         *b = m_b;
     if (c)
         *c = m_c;
 }
 
 /**
  * \class CartesianCoordinateSystem::LinearScale
  * \brief implementation of a linear scale for cartesian coordinate systems
  * y =  b * x + a. a - offset, b - gradient
  */
 class LinearScale : public CartesianScale {
 public:
     LinearScale(const Range<double>& range, double offset, double gradient)
         : CartesianScale(range, offset, gradient, 0) {
         Q_ASSERT(gradient != 0.0);
     }
 
     ~LinearScale() override = default;
 
     bool map(double* value) const override {
         *value = *value * m_b + m_a;
         return true;
     }
 
     bool inverseMap(double* value) const override {
         *value = (*value - m_a) / m_b;
         return true;
     }
 
     int direction() const override {
         return m_b < 0 ? -1 : 1;
     }
 };
 
 /**
  * \class CartesianCoordinateSystem::LogScale
  * \brief implementation of a logarithmic scale for cartesian coordinate systems
  * y = TODO. a - offset, b - scaleFactor, c - base
  */
 class LogScale : public CartesianScale {
 public:
     LogScale(const Range<double>& range, double offset, double scaleFactor, double base)
         : CartesianScale(range, offset, scaleFactor, base) {
         Q_ASSERT(scaleFactor != 0.0);
         Q_ASSERT(base > 0.0);
     }
 
     ~LogScale() override = default;
 
     bool map(double* value) const override {
         CHECK(*value > 0)
 
         *value = log(*value) / log(m_c) * m_b + m_a;
 
         return true;
     }
 
     bool inverseMap(double* value) const override {
         *value = pow(m_c, (*value - m_a) / m_b);
         return true;
     }
     int direction() const override {
         return m_b < 0 ? -1 : 1;
     }
 };
 
 /**
  * \class CartesianCoordinateSystem::SqrtScale
  * \brief implementation of a square-root scale for cartesian coordinate systems
  * y = TODO. a - offset, b - scaleFactor
  */
 class SqrtScale : public CartesianScale {
 public:
     SqrtScale(const Range<double>& range, double offset, double scaleFactor)
         : CartesianScale(range, offset, scaleFactor, 0) {
         Q_ASSERT(scaleFactor != 0.0);
     }
 
     ~SqrtScale() override = default;
 
     bool map(double* value) const override {
         CHECK(*value >= 0)
         *value = sqrt(*value) * m_b + m_a;
         return true;
     }
 
     bool inverseMap(double* value) const override {
         *value = gsl_pow_2((*value - m_a) / m_b);
         return true;
     }
     int direction() const override {
         return m_b < 0 ? -1 : 1;
     }
 };
 
 /**
  * \class CartesianCoordinateSystem::SquareScale
  * \brief implementation of a square scale for cartesian coordinate systems
  * y = TODO. a - offset, b - scaleFactor
  */
 class SquareScale : public CartesianScale {
 public:
     SquareScale(const Range<double>& range, double offset, double scaleFactor)
         : CartesianScale(range, offset, scaleFactor, 0) {
         Q_ASSERT(scaleFactor != 0.0);
     }
 
     ~SquareScale() override = default;
 
     bool map(double* value) const override {
         *value = gsl_pow_2(*value) * m_b + m_a;
         return true;
     }
 
     bool inverseMap(double* value) const override {
         *value = std::sqrt(std::abs((*value - m_a) / m_b));
         return true;
     }
     int direction() const override {
         return m_b < 0 ? -1 : 1;
     }
 };
 
 /**
  * \class CartesianCoordinateSystem::InverseScale
  * \brief implementation of an inverse scale for cartesian coordinate systems
  * y = TODO. a - offset, b - scaleFactor
  */
 class InverseScale : public CartesianScale {
 public:
     InverseScale(const Range<double>& range, double offset, double scaleFactor)
         : CartesianScale(range, offset, scaleFactor, 0) {
         Q_ASSERT(scaleFactor != 0.0);
     }
 
     ~InverseScale() override = default;
 
     bool map(double* value) const override {
         CHECK(*value != 0)
 
         *value = m_b / (*value) + m_a;
         return true;
     }
 
     bool inverseMap(double* value) const override {
         CHECK(*value != m_a)
 
         *value = m_b / (*value - m_a);
         return true;
     }
     int direction() const override {
         return m_b < 0 ? -1 : 1;
     }
 };
 
 /***************************************************************/
 
 CartesianScale* CartesianScale::createLinearScale(const Range<double>& range, const Range<double>& sceneRange, const Range<double>& logicalRange) {
     if (logicalRange.size() == 0.0)
         return nullptr;
 
     double b = sceneRange.size() / logicalRange.size();
     double a = sceneRange.start() - b * logicalRange.start();
 
     return new LinearScale(range, a, b);
 }
 
 CartesianScale*
 CartesianScale::createLogScale(const Range<double>& range, const Range<double>& sceneRange, const Range<double>& logicalRange, RangeT::Scale scale) {
     if (logicalRange.start() <= 0.0 || logicalRange.end() <= 0.0 || logicalRange.isZero()) {
         DEBUG(Q_FUNC_INFO << ", WARNING: invalid range for log scale : " << logicalRange.toStdString())
         return nullptr;
     }
 
     double base;
     if (scale == RangeT::Scale::Log10)
         base = 10.0;
     else if (scale == RangeT::Scale::Log2)
         base = 2.0;
     else // RangeT::Scale::Ln
         base = M_E;
 
     const double lDiff = (log(logicalRange.end()) - log(logicalRange.start())) / log(base);
     double b = sceneRange.size() / lDiff;
     double a = sceneRange.start() - b * log(logicalRange.start()) / log(base);
 
     return new LogScale(range, a, b, base);
 }
 
 CartesianScale* CartesianScale::createSqrtScale(const Range<double>& range, const Range<double>& sceneRange, const Range<double>& logicalRange) {
     if (logicalRange.start() < 0.0 || logicalRange.end() < 0.0 || logicalRange.isZero()) {
         DEBUG(Q_FUNC_INFO << ", WARNING: invalid range for sqrt scale : " << logicalRange.toStdString())
         return nullptr;
     }
 
     const double lDiff = sqrt(logicalRange.end()) - sqrt(logicalRange.start());
     double b = sceneRange.size() / lDiff;
     double a = sceneRange.start() - b * sqrt(logicalRange.start());
 
     return new SqrtScale(range, a, b);
 }
 
 CartesianScale* CartesianScale::createSquareScale(const Range<double>& range, const Range<double>& sceneRange, const Range<double>& logicalRange) {
     const double lDiff = logicalRange.end() * logicalRange.end() - logicalRange.start() * logicalRange.start();
     double b = sceneRange.size() / lDiff;
     double a = sceneRange.start() - b * logicalRange.start() * logicalRange.start();
 
     return new SquareScale(range, a, b);
 }
 
 CartesianScale* CartesianScale::createInverseScale(const Range<double>& range, const Range<double>& sceneRange, const Range<double>& logicalRange) {
     const double lDiff = 1. / logicalRange.end() - 1. / logicalRange.start();
     double b = sceneRange.size() / lDiff;
     double a = sceneRange.start() - b / logicalRange.start();
 
     return new InverseScale(range, a, b);
 }