public SimpleFeatureBuilder(SimpleFeatureType featureType, FeatureFactory factory) { super(featureType, factory); this.featureType = featureType; this.factory = factory; if (featureType instanceof SimpleFeatureTypeImpl) { index = ((SimpleFeatureTypeImpl) featureType).index; } else { this.index = SimpleFeatureTypeImpl.buildIndex(featureType); } reset(); }
/** * Initialize the builder with the provided feature. * * <p>This method adds all the attributes from the provided feature. It is useful when copying a * feature. */ public void init(SimpleFeature feature) { reset(); // optimize the case in which we just build if (feature instanceof SimpleFeatureImpl) { SimpleFeatureImpl impl = (SimpleFeatureImpl) feature; System.arraycopy(impl.values, 0, values, 0, impl.values.length); if (impl.userData != null) { featureUserData = new HashMap(impl.userData); } } else { for (Object value : feature.getAttributes()) { add(value); } if (!feature.getUserData().isEmpty()) { featureUserData = new HashMap(feature.getUserData()); } } }
Map<Object, Object>[] userData = this.userData; Map<Object, Object> featureUserData = this.featureUserData; reset(); SimpleFeature sf = factory.createSimpleFeature(values, featureType, id);
public boolean hasNext() { while (next == null && firstDelegate.hasNext()) { SimpleFeature f = firstDelegate.next(); for (PropertyDescriptor property : fb.getFeatureType().getDescriptors()) { fb.set(property.getName(), f.getAttribute(property.getName())); } next = fb.buildFeature(Integer.toString(iterationIndex)); fb.reset(); iterationIndex++; } while (next == null && secondDelegate.hasNext() && !firstDelegate.hasNext()) { SimpleFeature f = secondDelegate.next(); for (PropertyDescriptor property : fb.getFeatureType().getDescriptors()) { fb.set(property.getName(), f.getAttribute(property.getName())); } next = fb.buildFeature(Integer.toString(iterationIndex)); fb.reset(); iterationIndex++; } return next != null; }
/** * Copies an existing feature, retyping it in the process. * * <p>If the feature type contains attributes in which the original feature does not have a * value for, the value in the resulting feature is set to <code>null</code>. * * @param feature The original feature. * @param SimpleFeatureBuilder A builder for the target feature type * @return The copied feature, with a new type. * @since 2.5.3 */ public static SimpleFeature retype(SimpleFeature feature, SimpleFeatureBuilder builder) { builder.reset(); for (AttributeDescriptor att : builder.getFeatureType().getAttributeDescriptors()) { Object value = feature.getAttribute(att.getName()); builder.set(att.getName(), value); } return builder.buildFeature(feature.getID()); }
public boolean hasNext() { while (next == null && delegate.hasNext()) { SimpleFeature f = delegate.next(); for (Object value : f.getAttributes()) { if (value instanceof Geometry) { Double fDistance = distance; if (this.attribute != null) { fDistance = Converters.convert( f.getAttribute(this.attribute), Double.class); } if (fDistance != null && fDistance != 0.0) { value = ((Geometry) value).buffer(fDistance); } } fb.add(value); } next = fb.buildFeature("" + count); count++; fb.reset(); } return next != null; }
public SimpleFeatureBuilder(SimpleFeatureType featureType, FeatureFactory factory) { this.featureType = featureType; this.factory = factory; if(featureType instanceof SimpleFeatureTypeImpl) { index = ((SimpleFeatureTypeImpl) featureType).index; } else { this.index = SimpleFeatureTypeImpl.buildIndex(featureType); } reset(); }
@Override public RevFeature apply(ResultSet rs) { builder.reset(); try { for (String attName : attNames) { Object value = rs.getObject(attName); if (attName.equals(geometryAttribute) && value != null) { byte[] bytes = (byte[]) value; value = new GeoPkgGeomReader(bytes).get(); } builder.set(attName, value); } SimpleFeature feature = builder.buildFeature("fakeId"); return RevFeatureBuilder.build(feature); } catch (SQLException | IOException e) { throw Throwables.propagate(e); } } }
@Override public RevFeature apply(ResultSet rs) { builder.reset(); try { for (String attName : attNames) { Object value = rs.getObject(attName); if (attName.equals(geometryAttribute) && value != null) { byte[] bytes = (byte[]) value; value = new GeoPkgGeomReader(bytes).get(); } builder.set(attName, value); } SimpleFeature feature = builder.buildFeature("fakeId"); return RevFeature.builder().build(feature); } catch (SQLException | IOException e) { throw new RuntimeException(e); } } }
public void execute(Tuple tuple) { final String[] attributes = tuple.getValue(0).toString().split(","); // Only ingest attributes that have a latitude and longitude if (attributes.length == 2 && attributes[LATITUDE_COL_IDX] != null && attributes[LONGITUDE_COL_IDX] != null) { featureBuilder.reset(); final SimpleFeature simpleFeature = featureBuilder.buildFeature(String.valueOf(UUID.randomUUID().getMostSignificantBits())); simpleFeature.setDefaultGeometry(getGeometry(attributes)); try { final SimpleFeature next = featureWriter.next(); for (int i = 0; i < simpleFeature.getAttributeCount(); i++) { next.setAttribute(i, simpleFeature.getAttribute(i)); } ((FeatureIdImpl)next.getIdentifier()).setID(simpleFeature.getID()); featureWriter.write(); } catch (IOException e) { log.error("Exception writing feature", e); } } }
public @Override SimpleFeature apply(DiffObjectInfo<RevFeature> info) { DiffEntry entry = info.entry(); final String id = entry.name(); RevFeature oldFeature = info.oldValue().orElse(null); RevFeature newFeature = info.newValue().orElse(null); SimpleFeature oldValue; SimpleFeature newValue; oldValue = (SimpleFeature) (oldFeature == null ? null : valueBuilder.build(id, oldFeature, geometryFactory)); newValue = (SimpleFeature) (newFeature == null ? null : valueBuilder.build(id, newFeature, geometryFactory)); SimpleFeature diffFeature; diffFeatureBuilder.reset(); final ChangeType changeType = info.entry().changeType(); diffFeatureBuilder.set(BulkFeatureRetriever.DIFF_FEATURE_CHANGETYPE_ATTNAME, Integer.valueOf(changeType.value())); diffFeatureBuilder.set("old", oldValue); diffFeatureBuilder.set("new", newValue); diffFeature = diffFeatureBuilder.buildFeature(id); return diffFeature; } }
private SimpleFeature poiFeature(SimpleFeatureBuilder builder, int i) { builder.reset(); builder.set("sp", "string_" + i); builder.set("ip", i); try { builder.set("pp", new WKTReader().read(String.format("POINT(%f %f)", i / 100d, i / 100d))); } catch (ParseException e) { throw new RuntimeException(e); } SimpleFeature f = builder.buildFeature(String.valueOf(i)); return f; } }
public boolean hasNext() { while (next == null && firstDelegate.hasNext()) { SimpleFeature f = firstDelegate.next(); for (PropertyDescriptor property : fb.getFeatureType().getDescriptors()) { fb.set(property.getName(), f.getAttribute(property.getName())); } next = fb.buildFeature(Integer.toString(iterationIndex)); fb.reset(); iterationIndex++; } while (next == null && secondDelegate.hasNext() && !firstDelegate.hasNext()) { SimpleFeature f = secondDelegate.next(); for (PropertyDescriptor property : fb.getFeatureType().getDescriptors()) { fb.set(property.getName(), f.getAttribute(property.getName())); } next = fb.buildFeature(Integer.toString(iterationIndex)); fb.reset(); iterationIndex++; } return next != null; }
public SimpleFeature next() throws NoSuchElementException { SimpleFeature sourceFeature = delegate.next(); for (Object attribute : sourceFeature.getAttributes()) { if (attribute instanceof Geometry) { // centroid or interior point Geometry geometry = (Geometry) attribute; Point center = geometry.getCentroid(); if (useInside && shapeType == SimpleShapeType.POLYGON && !geometry.contains(center)) { center = geometry.getInteriorPoint(); } attribute = center; } builder.add(attribute); } SimpleFeature nextFeature = builder.buildFeature(sourceFeature.getID()); builder.reset(); return nextFeature; } }
public boolean hasNext() { while (next == null && delegate.hasNext()) { // repair geometry SimpleFeature feature = delegate.next(); Geometry repaired = validate((Geometry) feature.getDefaultGeometry()); if (repaired == null) { continue; } // build the next feature for (Object attribute : feature.getAttributes()) { if (attribute instanceof Geometry) { attribute = repaired; } builder.add(attribute); } next = builder.buildFeature(buildID(typeName, ++featureID)); builder.reset(); } return next != null; }
/** * Copies an existing feature, retyping it in the process. * <p> * If the feature type contains attributes in which the original feature * does not have a value for, the value in the resulting feature is set to * <code>null</code>. * </p> * @param feature The original feature. * @param SimpleFeatureBuilder A builder for the target feature type * * @return The copied feature, with a new type. * @since 2.5.3 */ public static SimpleFeature retype(SimpleFeature feature, SimpleFeatureBuilder builder) { builder.reset(); for (AttributeDescriptor att : builder.getFeatureType().getAttributeDescriptors()) { Object value = feature.getAttribute( att.getName() ); builder.set(att.getName(), value); } return builder.buildFeature(feature.getID()); }
public SimpleFeature next() throws NoSuchElementException { SimpleFeature feature = delegate.next(); Double distanceTolerance = tolerance.evaluate(feature, Double.class); for (Object attribute : feature.getAttributes()) { if (attribute instanceof Geometry) { if (distanceTolerance != null && distanceTolerance > 0) { Geometry geometry = (Geometry) attribute; geometry = Densifier.densify(geometry, distanceTolerance); if (geometry != null && !geometry.isEmpty()) { geometry.setUserData(((Geometry) attribute).getUserData()); attribute = geometry; } } } builder.add(attribute); } SimpleFeature nextFeature = builder.buildFeature(feature.getID()); builder.reset(); return nextFeature; } }
public boolean hasNext() { while (next == null && delegate.hasNext()) { SimpleFeature source = delegate.next(); Double eval = distance.evaluate(source, Double.class); if (eval != null) { next = builder.buildFeature(buildID(typeName, ++count)); // transfer attributes transferAttribute(source, next); // envelope to polygon geometry Geometry geometry = (Geometry) source.getDefaultGeometry(); double converted = UnitConverter .convertDistance(eval, distanceUnit, targetUnit); next.setDefaultGeometry(BufferOp.bufferOp(geometry, converted, bufParams)); next.setAttribute(BUFFER_FIELD, eval); builder.reset(); } } return next != null; }