Application: gvSIG desktop

import org.gvsig.expressionevaluator.impl.function.spatial.STAreaFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STAsTextFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STBufferFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STCentroidFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STContainsFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STConvexHullFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STCoveredByFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STCoversFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STCrossesFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STDiferenceFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STDimensionFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STDisjointFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STDistanceFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STEndPointFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STEnvelopeFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STGeomFromTextFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STGeometryNFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STIntersectionFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STIntersectsFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STIsSimpleFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STIsValidFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STNumGeometriesFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STNumPointsFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STOverlapsFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STPointNFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STStartPointFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STTouchesFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STUnionFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STWithinFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STXFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STYFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STZFunction;

        addFunction(new STAreaFunction());

        addFunction(new STAsTextFunction());

        addFunction(new STBufferFunction());

        addFunction(new STCentroidFunction());

        addFunction(new STContainsFunction());

        addFunction(new STConvexHullFunction());

        addFunction(new STCoveredByFunction());

        addFunction(new STCoversFunction());

        addFunction(new STCrossesFunction());

        addFunction(new STDiferenceFunction());

        addFunction(new STDimensionFunction());

        addFunction(new STDisjointFunction());

        addFunction(new STDistanceFunction());

        addFunction(new STEndPointFunction());

        addFunction(new STEnvelopeFunction());

        addFunction(new STGeomFromTextFunction());

        addFunction(new STGeometryNFunction());

        addFunction(new STIntersectionFunction());

        addFunction(new STIntersectsFunction());

        addFunction(new STIsSimpleFunction());

        addFunction(new STIsValidFunction());

        addFunction(new STNumGeometriesFunction());

        addFunction(new STNumPointsFunction());

        addFunction(new STOverlapsFunction());

        addFunction(new STPointNFunction());

        addFunction(new STStartPointFunction());

        addFunction(new STTouchesFunction());

        addFunction(new STUnionFunction());

        addFunction(new STWithinFunction());

        addFunction(new STXFunction());

        addFunction(new STYFunction());

        addFunction(new STZFunction());

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STIntersectionFunction extends AbstractFunction {

    public STIntersectionFunction() {

        super("OGC", "ST_Intersection", Range.is(2));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry r = getGeom(args, 0).intersection(getGeom(args, 1));

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.OrientablePrimitive;

import org.gvsig.fmap.geom.primitive.Point;

public class STPointNFunction extends AbstractFunction {

    public STPointNFunction() {

        super("OGC", "ST_PointN", Range.is(2));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry geom = getGeom(args, 0);

        if ( geom instanceof OrientablePrimitive ) {

            Point n = ((OrientablePrimitive) geom).getVertex(getInt(args, 1));

            return n;

        }

        return null;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.OrientablePrimitive;

import org.gvsig.fmap.geom.primitive.Point;

public class STStartPointFunction extends AbstractFunction {

    public STStartPointFunction() {

        super("OGC", "ST_StartPoint", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry geom = getGeom(args, 0);

        if ( geom instanceof OrientablePrimitive ) {

            Point n = ((OrientablePrimitive) geom).getVertex(0);

            return n;

        }

        return null;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

public class STYFunction extends AbstractFunction {

    public STYFunction() {

        super("OGC", "ST_Y", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        double r = getPoint(args, 0).getY();

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STBufferFunction extends AbstractFunction {

    public STBufferFunction() {

        super("OGC", "ST_Buffer", Range.is(2));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry r = getGeom(args, 0).buffer(getDouble(args, 1));

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.primitive.Primitive;

public class STGeometryNFunction extends AbstractFunction {

    public STGeometryNFunction() {

        super("OGC", "ST_GeometryN", Range.is(2));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry geom = getGeom(args, 0);

        if( geom instanceof Aggregate ) {

            Primitive r = ((Aggregate) geom).getPrimitiveAt(getInt(args, 1));

            return r;

        }

       return null;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

public class STGeomFromTextFunction extends AbstractFunction {

    public STGeomFromTextFunction() {

        super("OGC", "ST_GeomFromText", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        String wkt = getStr(args, 0);

        Geometry r = geomManager.createFrom(wkt);

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.OrientablePrimitive;

import org.gvsig.fmap.geom.primitive.Point;

public class STEndPointFunction extends AbstractFunction {

    public STEndPointFunction() {

        super("OGC", "ST_EndPoint", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry geom = getGeom(args, 0);

        if ( geom instanceof OrientablePrimitive ) {

            int n = ((OrientablePrimitive) geom).getNumVertices();

            Point p = ((OrientablePrimitive) geom).getVertex(n-1);

            return p;

        }

        return null;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STIsSimpleFunction extends AbstractFunction {

    public STIsSimpleFunction() {

        super("OGC", "ST_IsSimple", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        boolean r = getGeom(args, 0).isSimple();

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STConvexHullFunction extends AbstractFunction {

    public STConvexHullFunction() {

        super("OGC", "ST_ConvexHull", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry r = getGeom(args, 0).convexHull();

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STUnionFunction extends AbstractFunction {

    public STUnionFunction() {

        super("OGC", "ST_Union", Range.is(2));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry r = getGeom(args, 0).union(getGeom(args, 1));

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STIsValidFunction extends AbstractFunction {

    public STIsValidFunction() {

        super("OGC", "ST_IsValid", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        boolean r = getGeom(args, 0).isValid();

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.OrientablePrimitive;

public class STNumPointsFunction extends AbstractFunction {

    public STNumPointsFunction() {

        super("OGC", "ST_NumPoints", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry geom = getGeom(args, 0);

        if ( geom instanceof OrientablePrimitive ) {

            int n = ((OrientablePrimitive) geom).getNumVertices();

            return n;

        }

        return null;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

public class STXFunction extends AbstractFunction {

    public STXFunction() {

        super("OGC", "ST_X", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        double r = getPoint(args, 0).getX();

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

public class STAsTextFunction extends AbstractFunction {

    public STAsTextFunction() {

        super("OGC", "ST_AsText", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        String r = getGeom(args, 0).convertToWKT();

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STZFunction extends AbstractFunction {

    public STZFunction() {

        super("OGC", "ST_Z", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        double r = getPoint(args, 0).getCoordinateAt(Geometry.DIMENSIONS.Z);

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

public class STEnvelopeFunction extends AbstractFunction {

    public STEnvelopeFunction() {

        super("OGC", "ST_Envelope", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Envelope r = getGeom(args, 0).getEnvelope();

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.Aggregate;

public class STNumGeometriesFunction extends AbstractFunction {

    public STNumGeometriesFunction() {

        super("OGC", "ST_NumGeometries", Range.is(1));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry geom = getGeom(args, 0);

        if( geom instanceof Aggregate ) {

            int r = ((Aggregate) geom).getPrimitivesNumber();

            return r;

        }

       return null;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STDiferenceFunction extends AbstractFunction {

    public STDiferenceFunction() {

        super("OGC", "ST_Diference", Range.is(2));

    }

    @Override

    public Object call(Object[] args)  throws Exception {

        Geometry r = getGeom(args, 0).difference(getGeom(args, 1));

        return r;

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.type.GeometryType;

public class STDimensionFunction extends AbstractFunction {

    public STDimensionFunction() {

        super("OGC", "ST_Dimension", Range.is(1));

    }

    @Override

    public Object call(Object[] args) throws Exception {

        Geometry geom = getGeom(args, 0);

        GeometryType type = geom.getGeometryType();

        if( type.isSubTypeOf(Geometry.TYPES.POINT)

            || type.isSubTypeOf(Geometry.TYPES.MULTIPOINT) ) {

            return 0;

        }

        if( type.isSubTypeOf(Geometry.TYPES.CURVE)

            || type.isSubTypeOf(Geometry.TYPES.MULTICURVE) ) {

            return 1;

        }

        if( type.isSubTypeOf(Geometry.TYPES.SURFACE)

            || type.isSubTypeOf(Geometry.TYPES.MULTISURFACE) ) {

            return 2;

        }

        if( type.isSubTypeOf(Geometry.TYPES.SOLID) ) {

            return 3;

        }

        return -1;

    }

}

        super("Numeric", "TANH", Range.is(1));