delete obsolete code (747c3fc7) · Commits · github_fork / Clip

common/graphics/layer.cc

+0 −16

Original line number	Diff line number	Diff line
		@@ -75,21 +75,5 @@ void Layer::clear(const Colour& c) {
		cairo_paint(rasterizer.cr_ctx);
		}

		double from_rem(const Layer& l, double v) {
		return from_pt(l, l.measures.rem) * v;
		}

		double from_px(const Layer& l, double v) {
		return v;
		}

		double from_pt(const Layer& l, double v) {
		return (v / 72.0) * l.measures.dpi;
		}

		double to_pt(const Layer& l, double v) {
		return (v / l.measures.dpi) * 72;
		}

		} // namespace plotfx

common/graphics/layer.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -62,10 +62,5 @@ struct Layer {
		Rasterizer rasterizer;
		};

		double from_rem(const Layer& l, double v);
		double from_px(const Layer& l, double v);
		double from_pt(const Layer& l, double v);
		double to_pt(const Layer& l, double v);

		} // namespace plotfx

elements/continuousdomain.h

deleted100644 → 0

+0 −233

Original line number	Diff line number	Diff line
		/**
		* This file is part of the "plotfx" project
		* Copyright (c) 2014 Paul Asmuth, Google Inc.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are met:
		*
		* * Redistributions of source code must retain the above copyright notice, this
		* list of conditions and the following disclaimer.
		*
		* * Redistributions in binary form must reproduce the above copyright notice,
		* this list of conditions and the following disclaimer in the documentation
		* and/or other materials provided with the distribution.
		*
		* * Neither the name of the copyright holder nor the names of its
		* contributors may be used to endorse or promote products derived from
		* this software without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
		* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
		* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/
		#ifndef _libstx_CONTINUOUSDOMAIN_H
		#define _libstx_CONTINUOUSDOMAIN_H
		#include "utils/exception.h"
		#include "utils/stringutil.h"
		#include "domain.h"

		namespace plotfx {
		namespace chart {

		class AnyContinuousDomain {
		public:
		virtual void setLogarithmic(bool logarithmic) = 0;
		virtual void setPadding(double min_padding, double top_padding) = 0;
		};

		template <typename T>
		class ContinuousDomain : public Domain<T>, public AnyContinuousDomain {
		public:

		/**
		* Create a new numerical domain with explicit parameters
		*
		* @param min_value the smallest value
		* @param max_value the largest value
		* @param logarithmic is this domain a logarithmic domain?
		*/
		ContinuousDomain(
		T min_value = std::numeric_limits<T>::max(),
		T max_value = std::numeric_limits<T>::min(),
		bool is_logarithmic = false,
		bool is_inverted = false) :
		min_value_(min_value),
		max_value_(max_value),
		is_logarithmic_(is_logarithmic),
		is_inverted_(is_inverted),
		padding_(0, 0) {}

		double scale(T value) const {
		double scaled;

		if (is_logarithmic_) {
		if (min_value_ < 0) {
		RAISE(
		kRuntimeError,
		"negative value is outside of logarithmic domain");
		}

		double max_log = 0.0f;
		if (max_value_ >= 1.0) {
		max_log = log10(max_value_ + max_value_* padding_.second);
		}

		double value_log = 0.0f;
		if (static_cast<double>(value) >= 1.0) {
		value_log = log10(static_cast<double>(value));
		}

		scaled = value_log / max_log;
		} else {
		auto min_max = getRangeWithPadding();
		auto min_value = min_max.first;
		auto max_value = min_max.second;

		scaled =
		(static_cast<double>(value) - min_value) / (max_value - min_value);
		}

		if (is_inverted_) {
		return 1.0 - scaled;
		} else {
		return scaled;
		}
		}

		virtual std::string label(T value) const {
		return StringUtil::formatNumberMetric(static_cast<double>(value));
		}

		double valueAt(double index) const {
		if (is_logarithmic_) {
		if (max_value_ < 0) {
		RAISE(
		kRuntimeError,
		"negative value is outside of logarithmic domain");
		}

		double max_log = 0.0f;
		if (max_value_ >= 1.0) {
		max_log = log10(max_value_ + max_value_* padding_.second);
		}

		if (is_inverted_) {
		return pow(10, (1.0 - index) * max_log);
		} else {
		return pow(10, index * max_log);
		}
		} else {
		auto min_max = getRangeWithPadding();
		double min_value = min_max.first;
		double max_value = min_max.second;
		double val_range = min_value + (max_value - min_value);

		if (is_inverted_) {
		return min_value + (max_value - min_value) * (1.0 - index);
		} else {
		return min_value + (max_value - min_value) * index;
		}
		}
		}

		std::pair<double, double> scaleRange(T value) const {
		return std::make_pair(scale(value), scale(value));
		}

		void addValue(const T& value) {
		if (static_cast<double>(value) > max_value_) {
		max_value_ = static_cast<double>(value);
		}

		if (static_cast<double>(value) < min_value_) {
		min_value_ = static_cast<double>(value);
		}
		}

		bool contains(T value) const {
		return false;
		}

		const std::vector<double> getTicks() const {
		std::vector<double> ticks;

		double num_ticks = AnyDomain::kDefaultNumTicks;
		for (int n = 0; n < num_ticks; ++n) {
		ticks.push_back((double) n / (double) (num_ticks - 1));
		}

		return ticks;
		}

		const std::vector<std::pair<double, std::string>> getLabels() const {
		auto ticks = getTicks();
		std::vector<std::pair<double, std::string>> labels;

		for (auto tick : ticks) {
		labels.emplace_back(tick, label(valueAt(tick)));
		}

		return labels;
		}

		void setMin(T min) {
		min_value_ = static_cast<double>(min);
		padding_.first = 0.0f;
		}

		void setMax(T max) {
		max_value_ = static_cast<double>(max);
		padding_.second = 0.0f;
		}

		void setInverted(bool inverted) {
		is_inverted_ = inverted;
		}

		void setLogarithmic(bool logarithmic) {
		is_logarithmic_ = logarithmic;
		}

		void setPadding(double min_padding, double max_padding) {
		padding_.first = min_padding;
		padding_.second = max_padding;
		}

		void build() {
		if (min_value_ == max_value_) {
		max_value_ += 1.0f;
		min_value_ -= 1.0f;
		}
		}

		protected:

		std::pair<double, double> getRangeWithPadding() const {
		double range = max_value_ - min_value_;

		return std::make_pair(
		min_value_ == 0 ? 0 : min_value_ - range * padding_.first,
		max_value_ + range * padding_.second);
		}

		T getRange() const {
		return max_value_ - min_value_;
		}

		double min_value_;
		double max_value_;
		bool is_logarithmic_;
		bool is_inverted_;
		std::pair<double, double> padding_;
		};

		}
		}
		#endif

elements/discretedomain.h

deleted100644 → 0

+0 −149

Original line number	Diff line number	Diff line
		/**
		* This file is part of the "plotfx" project
		* Copyright (c) 2014 Paul Asmuth, Google Inc.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are met:
		*
		* * Redistributions of source code must retain the above copyright notice, this
		* list of conditions and the following disclaimer.
		*
		* * Redistributions in binary form must reproduce the above copyright notice,
		* this list of conditions and the following disclaimer in the documentation
		* and/or other materials provided with the distribution.
		*
		* * Neither the name of the copyright holder nor the names of its
		* contributors may be used to endorse or promote products derived from
		* this software without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
		* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
		* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/
		#ifndef _libstx_DISCRETEDOMAIN_H
		#define _libstx_DISCRETEDOMAIN_H
		#include "utils/stringutil.h"
		#include "domain.h"

		namespace plotfx {
		namespace chart {

		template <typename T>
		class DiscreteDomain : public Domain<T> {
		public:

		/**
		* Create a new categorical domain
		*/
		DiscreteDomain(bool is_inverted = false) : is_inverted_(is_inverted) {}

		std::string label(T value) const {
		return StringUtil::toString(value);
		}

		double scale(T value) const {
		size_t index = categories_.end() - std::find(
		categories_.begin(),
		categories_.end(),
		value);

		if (index < 1) {
		RAISE(kRuntimeError, "can't scale value");
		}

		double cardinality = (double) categories_.size();
		auto scaled = ((double) index - 0.5f) / cardinality;

		if (is_inverted_) {
		return 1.0 - scaled;
		} else {
		return scaled;
		}
		}

		std::pair<double, double> scaleRange(T value) const {
		size_t index = categories_.end() - std::find(
		categories_.begin(),
		categories_.end(),
		value);

		if (index < 1) {
		RAISE(kRuntimeError, "can't scale value");
		}

		auto cardinality = (double) categories_.size();
		auto begin = (double) (index - 1) / cardinality;;
		auto end = (double) index / cardinality;

		if (is_inverted_) {
		return std::make_pair(1.0 - begin, 1.0 - end);
		} else {
		return std::make_pair(begin, end);
		}
		}

		void addValue(const T& value) {
		addCategory(value);
		}

		void addCategory(const T& category) {
		bool insert = std::find(
		categories_.begin(),
		categories_.end(),
		category) == categories_.end();

		if (insert) {
		categories_.emplace_back(category);
		}
		}

		const std::vector<double> getTicks() const {
		std::vector<double> ticks{0.0};

		for (const auto category : categories_) {
		auto range = scaleRange(category);
		ticks.push_back(range.second);
		}

		return ticks;
		}

		const std::vector<std::pair<double, std::string>> getLabels() const {
		std::vector<std::pair<double, std::string>> labels;

		for (const auto category : categories_) {
		auto point = scale(category);
		labels.emplace_back(point, label(category));
		}

		return labels;
		}

		bool contains(T value) const {
		return std::find(
		categories_.begin(),
		categories_.end(),
		value) != categories_.end();
		}

		void setInverted(bool inverted) {
		is_inverted_ = inverted;
		}

		void build() {}

		protected:
		bool is_inverted_;
		std::vector<T> categories_;
		};

		}
		}
		#endif

elements/domainprovider.cc

deleted100644 → 0

+0 −84

Original line number	Diff line number	Diff line
		/**
		* This file is part of the "plotfx" project
		* Copyright (c) 2014 Paul Asmuth, Google Inc.
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are met:
		*
		* * Redistributions of source code must retain the above copyright notice, this
		* list of conditions and the following disclaimer.
		*
		* * Redistributions in binary form must reproduce the above copyright notice,
		* this list of conditions and the following disclaimer in the documentation
		* and/or other materials provided with the distribution.
		*
		* * Neither the name of the copyright holder nor the names of its
		* contributors may be used to endorse or promote products derived from
		* this software without specific prior written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
		* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
		* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*/
		#include "domainprovider.h"

		namespace plotfx {
		namespace chart {

		DomainProvider::DomainProvider(
		AnyDomain* domain /* = nullptr */) :
		domain_(domain),
		free_on_destroy_(false) {};

		DomainProvider::~DomainProvider() {
		if (free_on_destroy_) {
		delete domain_;
		}
		}

		AnyDomain* DomainProvider::get() const {
		return domain_;
		}

		bool DomainProvider::empty() const {
		return domain_ == nullptr;
		}

		void DomainProvider::reset(
		AnyDomain* domain,
		bool free_on_destroy /* = false */) {
		if (free_on_destroy_) {
		delete domain_;
		}

		domain_ = domain;
		free_on_destroy_ = free_on_destroy;
		}

		const std::vector<double> DomainProvider::getTicks() const {
		if (empty()) {
		return std::vector<double>{};
		} else {
		return domain_->getTicks();
		}
		}

		const std::vector<std::pair<double, std::string>>
		DomainProvider::getLabels() const {
		if (empty()) {
		return std::vector<std::pair<double, std::string>>{};
		} else {
		return domain_->getLabels();
		}
		}


		}
		}

Admin message