Object cloneFilter( BinarySpatialOperator bso, Object extraData, Expression ex1, Expression ex2) { return ff.contains(ex1, ex2); } }.transform(filter, extraData);
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated modifiable */ public Object parse(ElementInstance instance, Node node, Object value) throws Exception { Expression[] operands = OGCUtils.spatial(node, filterFactory, geometryFactory); return filterFactory.contains(operands[0], operands[1]); } }
public BinarySpatialOperator buildSpatialContainsFilter() throws CQLException { Literal geom = this.resultStack.popLiteral(); Expression property = this.resultStack.popExpression(); FilterFactory2 ff = (FilterFactory2) filterFactory; // TODO this cast must be removed. It depends of Geometry // implementation return ff.contains(property, geom); }
public Object visit(Contains filter, Object arg1) { Expression[][] exps = visitBinarySpatialOp(filter); List combinedFilters = new ArrayList(exps.length); for (int i = 0; i < exps.length; i++) { Expression left = exps[i][0]; Expression right = exps[i][1]; Filter unrolled = ff.contains(left, right, filter.getMatchAction()); combinedFilters.add(unrolled); } Filter unrolled = combineOred(combinedFilters); return unrolled; }
/** * @return new instance of {@link Contains} operation * @throws CQLException */ protected Contains buildContains() throws CQLException { Expression[] params = buildParameters(); return getFilterFactory().contains(params[0], params[1]); }
return FILTER_FACT.contains(left, right);
public Object visit(Contains filter, Object extraData) { Expression geometry1 = visit(filter.getExpression1(), extraData); Expression geometry2 = visit(filter.getExpression2(), extraData); return getFactory(extraData).contains(geometry1, geometry2, filter.getMatchAction()); }
public static Contains contains() { return f.contains(f.property("the_geom"), f.literal(geometry())); }
static Contains contains() { return f.contains(f.property("the_geom"), f.literal(geometry())); }
public boolean hasNext() { while (next == null && delegate.hasNext()) { SimpleFeature f = delegate.next(); for (Object attribute : f.getAttributes()) { if (attribute instanceof Geometry) { Geometry geom = (Geometry) attribute; Filter overFilter = ff.contains(ff.property(dataGeomName), ff.literal(geom)); SimpleFeatureCollection subFeatureCollectionInclusion = this.secondFeatures.subCollection(overFilter); if (subFeatureCollectionInclusion.size() > 0) { next = f; } } } } return next != null; }
return factory.contains(geometry1, geometry2);
PropertyName expr2 = new AttributeExpressionImpl(testSchema, "testGeometry"); Contains filter = fac.contains(expr1, expr2); filter = fac.contains(expr1, function); LOGGER.finer(filter.toString()); LOGGER.finer("contains feature: " + filter.evaluate(testFeature)); assertTrue(filter.evaluate(testFeature)); filter = fac.contains(expr2, expr1); geom = gf.createPolygon(gf.createLinearRing(coords), new LinearRing[0]); expr1 = new LiteralExpressionImpl(geom); filter = fac.contains(expr1, expr2); assertFalse(filter.evaluate(testFeature)); filter = fac.contains(new LiteralExpressionImpl(null), expr2);
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated modifiable */ public Object parse(ElementInstance instance, Node node, Object value) throws Exception { Expression[] operands = OGCUtils.spatial(node, filterFactory, geometryFactory); return filterFactory.contains(operands[0], operands[1]); } }
public void testContainsFilter() throws Exception { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(null); // should match only "r2" GeometryFactory gf = new GeometryFactory(); PackedCoordinateSequenceFactory sf = new PackedCoordinateSequenceFactory(); LinearRing shell = gf.createLinearRing(sf.create(new double[] {2, -1, 2, 5, 4, 5, 4, -1, 2, -1}, 2)); Polygon polygon = gf.createPolygon(shell, null); Contains cs = ff.contains(ff.literal(polygon), ff.property(aname("geom"))); FeatureCollection features = dataStore.getFeatureSource(tname("road")).getFeatures(cs); checkSingleResult(features, "r2"); }
public BinarySpatialOperator buildSpatialContainsFilter() throws CQLException { Literal geom = this.resultStack.popLiteral(); Expression property = this.resultStack.popExpression(); FilterFactory2 ff = (FilterFactory2) filterFactory; // TODO this cast must be removed. It depends of Geometry implementation return ff.contains(property, geom); }
public Object visit(Contains filter, Object arg1) { Expression[][] exps = visitBinarySpatialOp(filter); List combinedFilters = new ArrayList(exps.length); for (int i = 0; i < exps.length; i++) { Expression left = exps[i][0]; Expression right = exps[i][1]; Filter unrolled = ff.contains(left, right, filter.getMatchAction()); combinedFilters.add(unrolled); } Filter unrolled = combineOred(combinedFilters); return unrolled; }
new Join( tname("ftjoin"), ff.contains( ff.property(aname("geom")), ff.property(aname("geometry")))));
public Object visit(Contains filter, Object extraData) { Expression geometry1 = visitBinaryChild(filter.getExpression1(), extraData, 0); Expression geometry2 = visitBinaryChild(filter.getExpression2(), extraData, 1); return getFactory(extraData).contains(geometry1, geometry2, filter.getMatchAction()); }
filter = fac.beyond(expr1, expr2, 0.1, ""); assertEquals(filter.getMatchAction(), MatchAction.ANY); filter = fac.contains(expr1, expr2); assertEquals(filter.getMatchAction(), MatchAction.ANY); filter = fac.crosses(expr1, expr2); filter = fac.beyond(expr1, expr2, 0.1, "", MatchAction.ONE); assertEquals(filter.getMatchAction(), MatchAction.ONE); filter = fac.contains(expr1, expr2, MatchAction.ALL); assertEquals(filter.getMatchAction(), MatchAction.ALL); filter = fac.crosses(expr1, expr2, MatchAction.ONE);