Filter filter = query.getFilter() != null ? query.getFilter() : Filter.INCLUDE; Filter defaultedFilter = (Filter) filter.accept(defaultCRSVisitor, null); Filter reprojectedFilter = (Filter) defaultedFilter.accept(reprojectingVisitor, null); Query reprojectedQuery = new Query(query); reprojectedQuery.setFilter(reprojectedFilter); return reprojectedQuery;
private <T> Predicate<T> toPredicate(Filter filter) { if (filter != null && filter != Filter.INCLUDE) { return o -> filter.evaluate(o); } else { return CatalogInfoLookup.TRUE; } }
Filter filter = query.getFilter(); while (it.hasNext()) { SimpleFeature feature = it.next(); if (filter.evaluate(feature)) { count++; count--; } else { modifiedFids.add(ff.featureId(feature.getID())); if (filter.evaluate(feature)) { modifiedPostCount++; Id idFilter = ff.id(modifiedFids); Query q = new Query(query); q.setFilter(ff.and(idFilter, query.getFilter())); int modifiedPreCount = getCountInternal(q); if (modifiedPreCount == -1) {
private <T> void testOrOverlappingRanges(Class<T> type, T min, T max) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); // excluding extrema, not possible to turn it into a between filter Filter original = ff.or( Arrays.asList( // (Filter) ff.greater(ff.property("a"), ff.literal(min)), // ff.greater(ff.property("a"), ff.literal(max)))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(ff.greater(ff.property("a"), ff.literal(min)), simplified); }
(FeatureSource<FeatureType, Feature>) layer.getFeatureSource(); FeatureType schema = source.getSchema(); Query query = new Query(Query.ALL); Filter filter = null; query = new Query(schema.getName().getLocalPart()); query.setFilter(filter); query.setProperties(attributes); processRuleForQuery(styleList, query); SimplifyingFilterVisitor simplifier = new SimplifyingFilterVisitor(); simplifier.setFeatureType(source.getSchema()); Filter simplifiedFilter = (Filter) query.getFilter().accept(simplifier, null); query.setFilter(simplifiedFilter);
private <T> void testAndDisjointRanges(Class<T> type, T max, T min) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); Filter original = ff.and( ff.greater(ff.property("a"), ff.literal(max)), ff.less(ff.property("a"), ff.literal(min))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(original, simplified); visitor.setFeatureType(schema); Filter simplified2 = (Filter) original.accept(visitor, null); assertEquals(Filter.EXCLUDE, simplified2); }
@Test public void testAndDisjoint() { Coordinate[] coords = new Coordinate[] {new Coordinate(0, 0), new Coordinate(10, 10)}; LineString lineString = new GeometryFactory().createLineString(coords); Filter filter = ff.disjoint(ff.property("name"), ff.literal(lineString)); filter = ff.and(filter, ff.bbox(ff.property("geom"), 50, 50, 150, 150, null)); Envelope env = (Envelope) filter.accept(visitor, null); assertEquals(new Envelope(50, 150, 50, 150), env); }
@Test public void testBeyond() { Coordinate[] coords = new Coordinate[] {new Coordinate(0, 0), new Coordinate(10, 10)}; LineString lineString = new GeometryFactory().createLineString(coords); Filter filter = ff.beyond(ff.property("name"), ff.literal(lineString), 100, "m"); Envelope env = (Envelope) filter.accept(visitor, null); assertEquals(infinity, env); }
final MosaicProducer dryRunVisitor = new MosaicProducer(true, collectors); final Utils.BBOXFilterExtractor bboxExtractor = new Utils.BBOXFilterExtractor(); query.getFilter().accept(bboxExtractor, null); query.setFilter( FeatureUtilities.DEFAULT_FILTER_FACTORY.bbox( FeatureUtilities.DEFAULT_FILTER_FACTORY.property( rasterManager .getGranuleCatalog() .getName()), bboxExtractor.getBBox())); query.setMaxFeatures(1); rasterManager.getGranuleDescriptors(query, dryRunVisitor); if (dryRunVisitor.granulesNumber > 0) {
return null; } else { Query q = new Query(targetQuery); if (q.getPropertyNames() != null) { String[] names = Arrays.copyOf(q.getPropertyNames(), q.getPropertyNames().length); for (int i = 0; i < names.length; i++) { if (names[i].equals(target)) { (Filter) q.getFilter() .accept( new DuplicatingFilterVisitor() { @Override
public void testNegateLessOrEqual() { Filter f = ff.not(ff.lessOrEqual(ff.property("prop"), ff.literal(10))); Filter result = (Filter) f.accept(simpleVisitor, null); assertEquals(ff.greater(ff.property("prop"), ff.literal(10)), result); // not simplified for complex features result = (Filter) f.accept(complexVisitor, null); assertEquals(f, result); }
public Object visit(Not filter, Object extraData) { FilterFactory2 ff = getFactory(extraData); Filter inner = filter.getFilter(); if (inner instanceof Not) { return innerNot.getFilter().accept(this, extraData); } else if (inner instanceof And) { List<Filter> negatedChildren = new ArrayList<>(); for (Filter child : children) { negatedChildren.add((Filter) ff.not(child).accept(this, extraData)); return ff.or(negatedChildren); } else if (inner instanceof Or) { List<Filter> negatedChildren = new ArrayList<>(); for (Filter child : children) { negatedChildren.add((Filter) ff.not(child).accept(this, extraData)); return ff.and(negatedChildren); } else if (isSimpleFeature()) { Filter simplified = (Filter) inner.accept(this, extraData); if (simplified == Filter.INCLUDE) { return Filter.EXCLUDE;
private <T> void testAndOverlappingRangesToBetween(Class<T> type, T min, T mid, T max) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); // excluding extrema, not possible to turn it into a between filter Filter original = ff.and( Arrays.asList( // (Filter) ff.greaterOrEqual(ff.property("a"), ff.literal(min)), // ff.less(ff.property("a"), ff.literal(max)), // ff.lessOrEqual(ff.property("a"), ff.literal(mid)))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(ff.between(ff.property("a"), ff.literal(min), ff.literal(mid)), simplified); }
public void testRangeExpression() throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "pop:String"); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); Function func = ff.function("parseLong", ff.property("pop")); Filter f1 = ff.less(func, ff.literal(20000)); Filter f2 = ff.between(func, ff.literal(20000), ff.literal(50000)); Filter or = ff.or(f1, f2); Filter simplified = (Filter) or.accept(visitor, null); assertEquals(ff.lessOrEqual(func, ff.literal(50000)), simplified); }
public void testNegateGreaterOrEqual() { Filter f = ff.not(ff.greaterOrEqual(ff.property("prop"), ff.literal(10))); Filter result = (Filter) f.accept(simpleVisitor, null); assertEquals(ff.less(ff.property("prop"), ff.literal(10)), result); // not simplified for complex features result = (Filter) f.accept(complexVisitor, null); assertEquals(f, result); }
private Filter buildCombinedFilter(List<String> ids) { // Ids in filter: Filter idsIn = IndexQueryUtils.buildIdInExpression(ids, mapping); // build new and/or operator IndexCombinedFilterTransformerVisitor visitor = new IndexCombinedFilterTransformerVisitor( indexedParentLogicOperator, indexedFilters, idsIn); Filter resultFilter = (Filter) query.getFilter().accept(visitor, ff); return resultFilter; } }
private <T> void testAndTouchingRanges(Class<T> type, T value) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); Filter original = ff.and( ff.greaterOrEqual(ff.property("a"), ff.literal(value)), ff.lessOrEqual(ff.property("a"), ff.literal(value))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(ff.equal(ff.property("a"), ff.literal(value), false), simplified); }