PrecisionModel.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
 * 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)
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/geom/Coordinate.h>
#include <geos/export.h>
 
#include <cassert>
#include <string>
 
// Forward declarations
namespace geos {
namespace io {
class Unload;
}
namespace geom {
class Coordinate;
}
}
 
namespace geos {
namespace geom { // geos::geom
 
class GEOS_DLL PrecisionModel {
    friend class io::Unload;
 
public:
 
    typedef enum {
 
        FIXED,
 
        FLOATING,
 
        FLOATING_SINGLE
 
    } Type;
 
    PrecisionModel(void);
 
    PrecisionModel(Type nModelType);
 
    PrecisionModel(double newScale, double newOffsetX, double newOffsetY);
 
    PrecisionModel(double newScale);
 
    static const double maximumPreciseValue;
 
    double makePrecise(double val) const;
 
    void makePrecise(CoordinateXY& coord) const
    {
        // optimization for full precision
        if(modelType == FLOATING) {
            return;
        }
 
        coord.x = makePrecise(coord.x);
        coord.y = makePrecise(coord.y);
    };
 
    void makePrecise(CoordinateXY* coord) const
    {
        assert(coord);
        return makePrecise(*coord);
    };
 
    bool isFloating() const;
 
    int getMaximumSignificantDigits() const;
 
    Type getType() const
    {
        return modelType;
    };
 
    double getScale() const
    {
        assert(!(scale < 0));
        return scale;
    };
 
    double getGridSize() const
    {
        if (isFloating())
           return DoubleNotANumber;
 
        if (gridSize != 0)
            return gridSize;
 
        return 1.0 / scale;
    };
 
    double getOffsetX() const;
 
    double getOffsetY() const;
 
    /*
     *  Sets ´internal` to the precise representation of `external`.
     *
     * @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;
 
    int compareTo(const PrecisionModel* other) const;
 
private:
 
    void setScale(double newScale);
    // throw IllegalArgumentException
 
    static double snapToInt(double val, double tolerance);
 
    Type modelType;
 
    double scale;
 
    double gridSize = 0.0;
 
};
 
// Equality operator for PrecisionModel, deprecate it ?
//inline bool operator==(const PrecisionModel& a, const PrecisionModel& b);
 
} // namespace geos::geom
} // namespace geos