From 3fec2805ec3f1e1b7fabc60c32b362386220c54b Mon Sep 17 00:00:00 2001 From: "Reece R. Pollack" Date: Sat, 4 Jul 2020 22:02:12 -0400 Subject: [PATCH] Add the ORIGIN_TRANSFORMS class This commit adds the ORIGIN_TRANSFORMS class to support Display Origin Transforms in all KiCad applications. Functions are provided to perform four basic types of origin coordinate transforms: * Transform a relative coordinate from internal to display form * Transform a relative coordinate from display to internal form * Transform an absolute coordinate from internal to display form * Transform an absolute coordinate from display to internal form These functions are supported for data types "int", "long long int", and "double". The default implementations for all but "int" simply return their input unchanged; the implementation for "int" invokes the implementation for "long long int". The expectation is that the different KiCad applications will create derived classes from this base class and override the functions as needed. Protected template functions are provided for the standard translations to maintain consistency within the derived classes. --- common/CMakeLists.txt | 1 + common/origin_transforms.cpp | 69 +++++++++++++ include/origin_transforms.h | 195 +++++++++++++++++++++++++++++++++++ 3 files changed, 265 insertions(+) create mode 100644 common/origin_transforms.cpp create mode 100644 include/origin_transforms.h diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index dc60c113cb..d579745802 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -343,6 +343,7 @@ set( COMMON_SRCS msgpanel.cpp netclass.cpp observable.cpp + origin_transforms.cpp prependpath.cpp printout.cpp project.cpp diff --git a/common/origin_transforms.cpp b/common/origin_transforms.cpp new file mode 100644 index 0000000000..9faa4eebdf --- /dev/null +++ b/common/origin_transforms.cpp @@ -0,0 +1,69 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2019-2020 Reece R. Pollack + * Copyright (C) 1992-2019 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include + + +ORIGIN_TRANSFORMS::ORIGIN_TRANSFORMS() +{} + +ORIGIN_TRANSFORMS::~ORIGIN_TRANSFORMS() +{} + + +int ORIGIN_TRANSFORMS::ToDisplay( int aValue, + COORD_TYPES_T aCoordType ) +{ + return ToDisplay( static_cast(aValue), aCoordType ); +} + +long long int ORIGIN_TRANSFORMS::ToDisplay( long long int aValue, + COORD_TYPES_T aCoordType ) +{ + return aValue; +} + +double ORIGIN_TRANSFORMS::ToDisplay( double aValue, + COORD_TYPES_T aCoordType ) +{ + return aValue; +} + +int ORIGIN_TRANSFORMS::FromDisplay( int aValue, + COORD_TYPES_T aCoordType ) +{ + return FromDisplay( static_cast(aValue), aCoordType ); +} + +long long int ORIGIN_TRANSFORMS::FromDisplay( long long int aValue, + COORD_TYPES_T aCoordType ) +{ + return aValue; +} + +double ORIGIN_TRANSFORMS::FromDisplay( double aValue, + COORD_TYPES_T aCoordType ) +{ + return aValue; +} diff --git a/include/origin_transforms.h b/include/origin_transforms.h new file mode 100644 index 0000000000..45f771e6b0 --- /dev/null +++ b/include/origin_transforms.h @@ -0,0 +1,195 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2019-2020 Reece R. Pollack + * Copyright (C) 1992-2019 KiCad Developers, see AUTHORS.txt for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef ORIGIN_TRANSFORMS_H_ +#define ORIGIN_TRANSFORMS_H_ 1 + +/** + * A class to perform either relative or absolute display origin + * transforms for a single axis of a point. + * + * The coordinate argument is transformed between an offset from + * the internal origin and an offset from the user-specified origin + * and coordinate direction. + * + * The functions are templated to allow use with any size scalar + * parameter: an int, a long long int, or a double. + */ +class ORIGIN_TRANSFORMS { +public: + /** + * The supported Display Origin Transform types + * + * Absolute coordinates require both translation and direction + * inversion. Relative coordinates require only direction inversion. + */ + enum COORD_TYPES_T { + NOT_A_COORD, //< A non-coordinate value, never transformed + ABS_X_COORD, //< An absolute X coordinate + ABS_Y_COORD, //< An absolute Y coordinate + REL_X_COORD, //< A relative X coordinate + REL_Y_COORD, //< A relative Y coordinate + }; + +public: + ORIGIN_TRANSFORMS(); + + virtual ~ORIGIN_TRANSFORMS(); + + + // =============== Single-axis Transforms =============== + + virtual int ToDisplay( int aValue, + COORD_TYPES_T aCoordType ); + + virtual long long int ToDisplay( long long int aValue, + COORD_TYPES_T aCoordType ); + + virtual double ToDisplay( double aValue, + COORD_TYPES_T aCoordType ); + + virtual int FromDisplay( int aValue, + COORD_TYPES_T aCoordType ); + + virtual long long int FromDisplay( long long int aValue, + COORD_TYPES_T aCoordType ); + + virtual double FromDisplay( double aValue, + COORD_TYPES_T aCoordType ); + + + // =============== Two-axis Transforms =============== + + template + T ToDisplayAbs( const T& aValue ) + { + T displayValue; + + displayValue.x = ToDisplay( aValue.x, ABS_X_COORD ); + displayValue.x = ToDisplay( aValue.y, ABS_Y_COORD ); + return displayValue; + } + + template + T ToDisplayRel( const T& aValue ) + { + T displayValue; + + displayValue.x = ToDisplay( aValue.x, REL_X_COORD ); + displayValue.x = ToDisplay( aValue.y, REL_Y_COORD ); + return displayValue; + } + + + template + T FromDisplayAbs( const T& aValue ) + { + T displayValue; + + displayValue.x = FromDisplay( aValue.x, ABS_X_COORD ); + displayValue.x = FromDisplay( aValue.y, ABS_Y_COORD ); + return displayValue; + } + + template + T FromDisplayRel( const T& aValue ) + { + T displayValue; + + displayValue.x = FromDisplay( aValue.x, REL_X_COORD ); + displayValue.x = FromDisplay( aValue.y, REL_Y_COORD ); + return displayValue; + } + + +protected: + + // =============== Generic Relative Transforms =============== + + template inline static + T ToDisplayRel( T aInternalValue, + bool aInvertAxis ) + { + T displayValue = aInternalValue; + + // Invert the direction if needed + if( aInvertAxis && (displayValue != static_cast(0)) ) + displayValue = -displayValue; + + return displayValue; + } + + + template inline static + T FromDisplayRel( T aDisplayValue, + bool aInvertAxis ) + { + T internalValue = aDisplayValue; + + // Invert the direction if needed + if( aInvertAxis && (internalValue != static_cast(0)) ) + internalValue = -internalValue; + + return internalValue; + } + + + // =============== Generic Absolute Transforms =============== + + template inline static + T ToDisplayAbs( T aInternalValue, + int aUserOrigin, + bool aInvertAxis ) + { + T displayValue = aInternalValue; + + // Make the value relative to the internal origin + displayValue -= aUserOrigin; + + // Invert the direction if needed + if( aInvertAxis && (displayValue != static_cast(0)) ) + displayValue = -displayValue; + + return displayValue; + } + + template inline static + T FromDisplayAbs( T aDisplayValue, + int aUserOrigin, + bool aInvertAxis ) + { + T internalValue = aDisplayValue; + + // Invert the direction if needed + if( aInvertAxis && (internalValue != static_cast(0)) ) + internalValue = -internalValue; + + // Make the value relative to the internal origin + internalValue += aUserOrigin; + + return internalValue; + } +}; + +#endif // ORIGIN_TRANSFORMS_H