EVOLUTION-MANAGER

Edit File: PrecisionModel.h

/********************************************************************** * * GEOS - Geometry Engine Open Source * http://geos.osgeo.org * * Copyright (C) 2011 Sandro Santilli <strk@keybit.net> * Copyright (C) 2006 Refractions Research Inc. * * This is free software; you can redistribute and/or modify it under * the terms of the GNU Lesser General Public Licence as published * by the Free Software Foundation. * See the COPYING file for more information. * ********************************************************************** * * Last port: geom/PrecisionModel.java r378 (JTS-1.12) * **********************************************************************/ #ifndef GEOS_GEOM_PRECISIONMODEL_H #define GEOS_GEOM_PRECISIONMODEL_H #include <geos/export.h> #include <geos/inline.h> #include <string> // Forward declarations namespace geos { namespace io { class Unload; } namespace geom { class Coordinate; } } namespace geos { namespace geom { // geos::geom /** * \class PrecisionModel geom.h geos.h * * \brief Specifies the precision model of the Coordinate in a Geometry. * * In other words, specifies the grid of allowable * points for all <code>Geometry</code>s. * * The makePrecise method allows rounding a coordinate to * a "precise" value; that is, one whose * precision is known exactly. * * Coordinates are assumed to be precise in geometries. * That is, the coordinates are assumed to be rounded to the * precision model given for the geometry. * JTS input routines automatically round coordinates to the precision model * before creating Geometries. * All internal operations * assume that coordinates are rounded to the precision model. * Constructive methods (such as boolean operations) always round computed * coordinates to the appropriate precision model. * * Currently three types of precision model are supported: * - FLOATING - represents full double precision floating point. * This is the default precision model used in JTS * - FLOATING_SINGLE - represents single precision floating point. * - FIXED - represents a model with a fixed number of decimal places. * A Fixed Precision Model is specified by a scale factor. * The scale factor specifies the grid which numbers are rounded to. * Input coordinates are mapped to fixed coordinates according to the * following equations: * - jtsPt.x = round( inputPt.x * scale ) / scale * - jtsPt.y = round( inputPt.y * scale ) / scale * * For example, to specify 3 decimal places of precision, use a scale factor * of 1000. To specify -3 decimal places of precision (i.e. rounding to * the nearest 1000), use a scale factor of 0.001. * * Coordinates are represented internally as Java double-precision values. * Since Java uses the IEEE-394 floating point standard, this * provides 53 bits of precision. (Thus the maximum precisely representable * integer is 9,007,199,254,740,992). * * JTS methods currently do not handle inputs with different precision models. */ class GEOS_DLL PrecisionModel { friend class io::Unload; public: /// The types of Precision Model which GEOS supports. typedef enum { /** * Fixed Precision indicates that coordinates have a fixed * number of decimal places. * The number of decimal places is determined by the log10 * of the scale factor. */ FIXED, /** * Floating precision corresponds to the standard Java * double-precision floating-point representation, which is * based on the IEEE-754 standard */ FLOATING, /** * Floating single precision corresponds to the standard Java * single-precision floating-point representation, which is * based on the IEEE-754 standard */ FLOATING_SINGLE } Type; /// Creates a PrecisionModel with a default precision of FLOATING. PrecisionModel(void); /// Creates a PrecisionModel specifying an explicit precision model type. // /// If the model type is FIXED the scale factor will default to 1. /// /// @param nModelType the type of the precision model /// PrecisionModel(Type nModelType); /** \brief * Creates a <code>PrecisionModel</code> with Fixed precision. * * Fixed-precision coordinates are represented as precise internal * coordinates, which are rounded to the grid defined by the * scale factor. * * @param scale * amount by which to multiply a coordinate after subtracting * the offset, to obtain a precise coordinate * @param offsetX not used. * @param offsetY not used. * * @deprecated offsets are no longer supported, since internal * representation is rounded floating point */ PrecisionModel(double newScale, double newOffsetX, double newOffsetY); /** * \brief * Creates a PrecisionModel with Fixed precision. * * Fixed-precision coordinates are represented as precise * internal coordinates which are rounded to the grid defined * by the scale factor. * * @param newScale amount by which to multiply a coordinate * after subtracting the offset, to obtain a precise coordinate */ PrecisionModel(double newScale); // copy constructor PrecisionModel(const PrecisionModel &pm); /// destructor ~PrecisionModel(void); /// The maximum precise value representable in a double. // /// Since IEE754 double-precision numbers allow 53 bits of mantissa, /// the value is equal to 2^53 - 1. /// This provides <i>almost</i> 16 decimal digits of precision. //// static const double maximumPreciseValue; /** \brief * Rounds a numeric value to the PrecisionModel grid. * * Asymmetric Arithmetic Rounding is used, to provide * uniform rounding behaviour no matter where the number is * on the number line. * * <b>Note:</b> Java's <code>Math#rint</code> uses the "Banker's Rounding" algorithm, * which is not suitable for precision operations elsewhere in JTS. */ double makePrecise(double val) const; /// Rounds the given Coordinate to the PrecisionModel grid. void makePrecise(Coordinate& coord) const; void makePrecise(Coordinate* coord) const; /// Tests whether the precision model supports floating point // /// @return <code>true</code> if the precision model supports /// floating point /// bool isFloating() const; /// \brief /// Returns the maximum number of significant digits provided by /// this precision model. // /// Intended for use by routines which need to print out precise /// values. /// /// @return the maximum number of decimal places provided by this /// precision model /// int getMaximumSignificantDigits() const; /// Gets the type of this PrecisionModel // /// @return the type of this PrecisionModel /// Type getType() const; /// Returns the multiplying factor used to obtain a precise coordinate. double getScale() const; /// Returns the x-offset used to obtain a precise coordinate. // /// @return the amount by which to subtract the x-coordinate before /// multiplying by the scale /// @deprecated Offsets are no longer used /// double getOffsetX() const; /// Returns the y-offset used to obtain a precise coordinate. // /// @return the amount by which to subtract the y-coordinate before /// multiplying by the scale /// @deprecated Offsets are no longer used /// double getOffsetY() const; /** \brief * Sets <code>internal</code> to the precise representation of * <code>external</code>. * * @param external the original coordinate * @param internal the coordinate whose values will be changed to the * precise representation of <code>external</code> * @deprecated use makePrecise instead */ //void toInternal(const Coordinate& external, Coordinate* internal) const; /* * Returns the precise representation of <code>external</code>. * *@param external the original coordinate *@return * the coordinate whose values will be changed to the precise * representation of <code>external</code> * @deprecated use makePrecise instead */ //Coordinate* toInternal(const Coordinate& external) const; /* * Returns the external representation of <code>internal</code>. * *@param internal the original coordinate *@return the coordinate whose values will be changed to the * external representation of <code>internal</code> * @deprecated no longer needed, since internal representation is same as external representation */ //Coordinate* toExternal(const Coordinate& internal) const; /* * Sets <code>external</code> to the external representation of * <code>internal</code>. * * @param internal the original coordinate * @param external * the coordinate whose values will be changed to the * external representation of <code>internal</code> * @deprecated no longer needed, since internal representation is same as external representation */ //void toExternal(const Coordinate& internal, Coordinate* external) const; std::string toString() const; /// \brief /// Compares this PrecisionModel object with the specified object /// for order. // /// A PrecisionModel is greater than another if it provides greater /// precision. /// The comparison is based on the value returned by the /// getMaximumSignificantDigits method. /// This comparison is not strictly accurate when comparing floating /// precision models to fixed models; /// however, it is correct when both models are either floating or /// fixed. /// /// @param other the PrecisionModel with which this PrecisionModel /// is being compared /// @return a negative integer, zero, or a positive integer as this /// PrecisionModel is less than, equal to, or greater than the /// specified PrecisionModel. /// int compareTo(const PrecisionModel* other) const; private: /** \brief * Sets the multiplying factor used to obtain a precise coordinate. * * This method is private because PrecisionModel is intended to * be an immutable (value) type. * */ void setScale(double newScale); // throw IllegalArgumentException Type modelType; double scale; }; // Equality operator for PrecisionModel, deprecate it ? //inline bool operator==(const PrecisionModel& a, const PrecisionModel& b); } // namespace geos::geom } // namespace geos #ifdef GEOS_INLINE # include "geos/geom/PrecisionModel.inl" #endif #endif // ndef GEOS_GEOM_PRECISIONMODEL_H