Java Literal.evaluate方法代码示例

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
protected Literal clipToWorld(Literal geometry) {
    if(geometry != null) {
        Geometry g = geometry.evaluate(null, Geometry.class);
        if(g != null) {
            g.apply(new GeometryComponentFilter() {
                @Override
                public void filter(Geometry geom) {
                    geom.apply(new CoordinateFilter() {
                        @Override
                        public void filter(Coordinate coord) {
                            coord.setCoordinate(new Coordinate(clipLon(coord.x),clipLat(coord.y)));
                        }
                    });
                }
            });
            geometry = CommonFactoryFinder.getFilterFactory(null).literal(g);

        }
    }

    return geometry;
}
 

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
/**
 * Returns true if the geometry covers the entire world
 * @param geometry
 * @return
 */
protected boolean isWorld(Literal geometry) {
    boolean result = false;
    if(geometry != null) {
        Geometry g = geometry.evaluate(null, Geometry.class);
        if(g != null) {
            result = JTS.toGeometry(WORLD).equalsTopo(g.union());
        }
    }
    return result;
}
 

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
/**
 * Returns true if the geometry is fully empty
 * @param geometry
 * @return
 */
protected boolean isEmpty(Literal geometry) {
    boolean result = false;
    if(geometry != null) {
        Geometry g = geometry.evaluate(null, Geometry.class);
        result = g == null || g.isEmpty();
    }
    return result;
}
 

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
/**
 * Returns true if the geometry covers the entire world
 * @param geometry
 * @return
 */
private boolean isWorld(Literal geometry) {
    if(geometry != null) {
        Geometry g = geometry.evaluate(null, Geometry.class);
        if(g != null) {
            return JTS.toGeometry(WORLD).equalsTopo(g.union());
        }
    }
    return false;
}
 

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
/**
 * Returns true if the geometry is fully empty
 * @param geometry
 * @return
 */
private boolean isEmpty(Literal geometry) {
    if(geometry != null) {
        Geometry g = geometry.evaluate(null, Geometry.class);
        return g == null || g.isEmpty();
    }
    return false;
}
 

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
protected Object evaluateLiteral(Literal expression, Class target ) {
    Object literal = null;

    // HACK: let expression figure out the right value for numbers,
    // since the context is almost always improperly set and the
    // numeric converters try to force floating points to integrals
    // JD: the above is no longer true, so instead do a safe conversion
    if(target != null) {
        // use the target type
        if (Number.class.isAssignableFrom(target)) {
            literal = safeConvertToNumber(expression, target);

            if (literal == null) {
                literal = safeConvertToNumber(expression, Number.class);
            }
        }
        else {
            literal = expression.evaluate(null, target);
        }
    }

    //check for conversion to number
    if (target == null) {
        // we don't know the target type, check for a conversion to a number

        Number number = safeConvertToNumber(expression, Number.class);
        if (number != null) {
            literal = number;
        }
    }

    // if the target was not known, of the conversion failed, try the
    // type guessing dance literal expression does only for the following
    // method call
    if(literal == null)
        literal = expression.evaluate(null);

    // if that failed as well, grab the value as is
    if(literal == null)
        literal = expression.getValue();

    return literal;
}
 

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
/**
 * Handles the common case of a PropertyName,Literal geometry binary spatial operator.
 */
protected Object visitBinarySpatialOperator(BinarySpatialOperator filter,
PropertyName property, Literal geometry, boolean swapped,
Object extraData) {
    Geometry geom  = (Geometry) geometry.evaluate(extraData, Geometry.class);
    System.out.println(geom.getSRID());
    //geom.setSRID(currentSRID);
    
    if (filter instanceof BBOX) {        
        Coordinate[] coords = geom.getCoordinates();

        double minX = 0;
        double maxX = 0;
        double minY = 0;
        double maxY = 0;

        for(Coordinate coord : coords) {
            if (coord.x < minX) minX = coord.x;
            if (coord.x > maxX) maxX = coord.x;
            if (coord.y < minY) minY = coord.y;
            if (coord.y > maxY) maxY = coord.y;
        }

        try {
            out.write(property.toString());
            out.write("_x >= ");
            out.write(String.valueOf(minX));
            out.write(" AND ");
            out.write(property.toString());
            out.write("_x <= ");
            out.write(String.valueOf(maxX));

            out.write(" AND ");

            out.write(property.toString());
            out.write("_y >= ");
            out.write(String.valueOf(minY));
            out.write(" AND ");
            out.write(property.toString());
            out.write("_y <= ");
            out.write(String.valueOf(maxY));
        } catch (IOException ex) {
            LOGGER.warning(ex.getMessage());
        }
    } else {
        throw new UnsupportedOperationException("Filter " + filter.getClass().getCanonicalName() + " not yet supported");
    }
    
    return extraData;
}
 

import org.opengis.filter.expression.Literal; //导入方法依赖的package包/类
private Literal clipToWorld(Literal geometry) {
    if(geometry != null) {
        Geometry g = geometry.evaluate(null, Geometry.class);
        if(g != null) {
            Envelope env = g.getEnvelopeInternal();
            // first, limit to world
            if(!WORLD.contains(env)) {
                g = sanitizePolygons(g.intersection(JTS.toGeometry(WORLD)));
            }
            
            // second, postgis will always use the shortest distance between two
            // points, if an arc is longer than 180 degrees the opposite will
            // be used instead, so we have to slice the geometry in parts
            env = g.getEnvelopeInternal();
            if(Math.sqrt(env.getWidth() * env.getWidth() + env.getHeight() * env.getHeight()) >= 180) {
                // slice in 90x90 degrees quadrants, none of them has a diagonal longer than 180
                final List<Polygon> polygons = new ArrayList<Polygon>();
                for(double lon = Math.floor(env.getMinX()); lon < env.getMaxX(); lon+= 90) {
                    for (double lat = Math.floor(env.getMinY()); lat < env.getMaxY(); lat += 90) {
                        Geometry quadrant = JTS.toGeometry(new Envelope(lon, lon + 90, lat, lat + 90));
                        Geometry cut = sanitizePolygons(g.intersection(quadrant));
                        if(!cut.isEmpty()) {
                            if(cut instanceof Polygon) {
                                polygons.add((Polygon) cut);
                            } else {
                                for (int i = 0; i < cut.getNumGeometries(); i++) {
                                    polygons.add((Polygon) cut.getGeometryN(i));
                                }
                            }
                        }
                    }
                }
                g = toPolygon(g.getFactory(), polygons);
            }
            
            geometry = CommonFactoryFinder.getFilterFactory(null).literal(g);

        }
    }
    
    return geometry;
}