/**********************************************************************

 *

 * GEOS - Geometry Engine Open Source

 * http://geos.osgeo.org

 *

 * Copyright (C) 2001-2002 Vivid Solutions 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/prep/BasicPreparedGeometry.java rev. 1.5 (JTS-1.10)

 *

 **********************************************************************/

#include <geos/geom/prep/BasicPreparedGeometry.h>

#include <geos/geom/Coordinate.h>

#include <geos/geom/IntersectionMatrix.h>

#include <geos/algorithm/PointLocator.h>

#include <geos/geom/util/ComponentCoordinateExtracter.h>

#include <geos/operation/distance/DistanceOp.h>

#include "geos/util.h"

namespace geos {

namespace geom { // geos.geom

namespace prep { // geos.geom.prep

/*            *

 * protected: *

 *            */

void

BasicPreparedGeometry::setGeometry(const geom::Geometry* geom)

{

    baseGeom = geom;

    geom::util::ComponentCoordinateExtracter::getCoordinates(*baseGeom, representativePts);

}

bool

BasicPreparedGeometry::envelopesIntersect(const geom::Geometry* g) const

{

    if (g->getGeometryTypeId() == GEOS_POINT) {

        auto pt = g->getCoordinate();

        if (pt == nullptr) {

            return false;

        }

        return baseGeom->getEnvelopeInternal()->intersects(*pt);

    }

    return baseGeom->getEnvelopeInternal()->intersects(g->getEnvelopeInternal());

}

bool

BasicPreparedGeometry::envelopeCovers(const geom::Geometry* g) const

{

    if (g->getGeometryTypeId() == GEOS_POINT) {

        auto pt = g->getCoordinate();

        if (pt == nullptr) {

            return false;

        }

        return baseGeom->getEnvelopeInternal()->covers(pt);

    }

    return baseGeom->getEnvelopeInternal()->covers(g->getEnvelopeInternal());

}

/*

 * public:

 */

BasicPreparedGeometry::BasicPreparedGeometry(const Geometry* geom)

{

    setGeometry(geom);

}

bool

BasicPreparedGeometry::isAnyTargetComponentInTest(const geom::Geometry* testGeom) const

{

    algorithm::PointLocator locator;

    for(const auto& c : representativePts) {

        if(locator.intersects(*c, testGeom)) {

            return true;

        }

    }

    return false;

}

bool

BasicPreparedGeometry::within(const geom::Geometry* g) const

{

    return getRelateNG().within(g);

}

bool

BasicPreparedGeometry::contains(const geom::Geometry* g) const

{

    return getRelateNG().contains(g);

}

bool

BasicPreparedGeometry::containsProperly(const geom::Geometry* g)  const

{

    return getRelateNG().relate(g, "T**FF*FF*");

}

bool

BasicPreparedGeometry::coveredBy(const geom::Geometry* g) const

{

    return getRelateNG().coveredBy(g);

}

bool

BasicPreparedGeometry::covers(const geom::Geometry* g) const

{

    return getRelateNG().covers(g);

}

bool

BasicPreparedGeometry::crosses(const geom::Geometry* g) const

{

    return getRelateNG().crosses(g);

}

bool

BasicPreparedGeometry::disjoint(const geom::Geometry* g)  const

{

    return getRelateNG().disjoint(g);

}

bool

BasicPreparedGeometry::intersects(const geom::Geometry* g) const

{

    return getRelateNG().intersects(g);

}

bool

BasicPreparedGeometry::overlaps(const geom::Geometry* g)  const

{

    return getRelateNG().overlaps(g);

}

bool

BasicPreparedGeometry::touches(const geom::Geometry* g) const

{

    return getRelateNG().touches(g);

}

bool

BasicPreparedGeometry::relate(const geom::Geometry* g, const std::string& pat) const

{

    return getRelateNG().relate(g, pat);

}

std::unique_ptr<IntersectionMatrix>

BasicPreparedGeometry::relate(const geom::Geometry* g) const

{

    return getRelateNG().relate(g);

}

std::unique_ptr<geom::CoordinateSequence>

BasicPreparedGeometry::nearestPoints(const geom::Geometry* g) const

{

    operation::distance::DistanceOp dist(baseGeom, g);

    return dist.nearestPoints();

}

double

BasicPreparedGeometry::distance(const geom::Geometry* g) const

{

    std::unique_ptr<geom::CoordinateSequence> coords = nearestPoints(g);

    if ( ! coords ) return DoubleInfinity;

    return coords->getAt(0).distance( coords->getAt(1) );

}

bool

BasicPreparedGeometry::isWithinDistance(const geom::Geometry* g, double dist) const

{

    return baseGeom->isWithinDistance(g, dist);

}

std::string

BasicPreparedGeometry::toString()

{

    return baseGeom->toString();

}

} // namespace geos.geom.prep

} // namespace geos.geom

} // namespace geos