How to use

setUserData

method

in

com.vividsolutions.jts.geom.Geometry

/**
 * JTS 1.14 does not support intersection on a {@link GeometryCollection}. This function works around this
 * by performing intersection on a flat list of geometry. The resulting list is pre-filtered for invalid
 * or empty geometry (outside of bounds). Invalid geometry are logged as errors.
 *
 * @param envelope non-list geometry defines bounding area
 * @param dataGeoms geometry pre-passed through {@link #flatFeatureList(Geometry)}
 * @return list of geometry from {@code data} intersecting with {@code envelope}.
 */
private static List<Geometry> flatIntersection(Geometry envelope, List<Geometry> dataGeoms) {
  final List<Geometry> intersectedGeoms = new ArrayList<>(dataGeoms.size());
  Geometry nextIntersected;
  for(Geometry nextGeom : dataGeoms) {
    try {
      // AABB intersection culling
      if(envelope.getEnvelopeInternal().intersects(nextGeom.getEnvelopeInternal())) {
        nextIntersected = envelope.intersection(nextGeom);
        if(!nextIntersected.isEmpty()) {
          nextIntersected.setUserData(nextGeom.getUserData());
          intersectedGeoms.add(nextIntersected);
        }
      }
    } catch (TopologyException e) {
      //LoggerFactory.getLogger(JtsAdapter.class).error(e.getMessage(), e);
    }
  }
  return intersectedGeoms;
}

nextTransformGeom.setUserData(nextUserData);

if (nextGeom != null) {
  tileGeoms.add(nextGeom);
  nextGeom.setUserData(tagConverter.toUserData(id, nextFeature.getTagsList(), keysList, valuesList));

  /**
   * Input is assumed to be a multiGeometry
   * in which every component has its userData
   * set to be a Coordinate which is the key to the output data.
   * The Coordinate is used to determine
   * the output data object to be written back into the component. 
   * 
   * @param targetGeom
   */
  public void transferData(Geometry targetGeom)
  {
    for (int i = 0; i < targetGeom.getNumGeometries(); i++) {
      Geometry geom = targetGeom.getGeometryN(i);
      Coordinate vertexKey = (Coordinate) geom.getUserData();
      if (vertexKey == null) continue;
      geom.setUserData(coordDataMap.get(vertexKey));
    }
  }
}

  @Override
  public void filter(Geometry g) {
    g.setUserData(crs);
  }
}

  private static Geometry clipGeometryCollection(Geometry geom, Envelope clipEnv)
  {
    Geometry clipPoly = geom.getFactory().toGeometry(clipEnv);
    List clipped = new ArrayList();
    for (int i = 0; i < geom.getNumGeometries(); i++) {
      Geometry g = geom.getGeometryN(i);
      Geometry result = null;
      // don't clip unless necessary
      if (clipEnv.contains(g.getEnvelopeInternal()))
          result = g;
      else if (clipEnv.intersects(g.getEnvelopeInternal())) {
        result = clipPoly.intersection(g);
        // keep vertex key info
        result.setUserData(g.getUserData());
      }

      if (result != null && ! result.isEmpty()) {
        clipped.add(result);
      }
    }
    return geom.getFactory().createGeometryCollection(GeometryFactory.toGeometryArray(clipped));
  }
}

public void setUserData(Object userData) {
  geometry.setUserData(userData);
}

private void handleNonSpatialDataToGeometry(Geometry geometry, List<String> splitedGeometryData)
{
  LinkedList<String> splitedGeometryDataList = new LinkedList<String>(splitedGeometryData);
  if (carryInputData) {
    if (this.splitter != FileDataSplitter.GEOJSON){
      //remove spatial data position
      splitedGeometryDataList.remove(this.startOffset);
    }
    geometry.setUserData(String.join("\t", splitedGeometryDataList));
  }
}

  private Geometry readGeometry(Kryo kryo, Input input)
  {
    Geometry geometry = ShapeSerde.deserialize(input, geometryFactory);
    geometry.setUserData(readUserData(kryo, input));
    return geometry;
  }
}

  private Geometry readGeometry(Kryo kryo, Input input)
  {
    Geometry geometry = ShapeSerde.deserialize(input, geometryFactory);
    geometry.setUserData(readUserData(kryo, input));
    return geometry;
  }
}

  public Geometry getShape(GeometryFactory geometryFactory)
      throws IOException, TypeUnknownException
  {
    ShapeParser parser = shapeType.getParser(geometryFactory);
    ByteBuffer shapeBuffer = ByteBuffer.wrap(primitiveRecord);
    Geometry shape = parser.parseShape(ShapeReaderFactory.fromByteBuffer(shapeBuffer));
    if (attributes != null) {
      shape.setUserData(attributes);
    }
    return shape;
  }
}

public <T extends Geometry> void addMultiGeometry(GeometryCollection multiGeometry, List<T> result)
{
  for (int i = 0; i < multiGeometry.getNumGeometries(); i++) {
    T geometry = (T) multiGeometry.getGeometryN(i);
    geometry.setUserData(multiGeometry.getUserData());
    result.add(geometry);
  }
}

  public Geometry getShape(GeometryFactory geometryFactory)
      throws IOException, TypeUnknownException
  {
    ShapeParser parser = shapeType.getParser(geometryFactory);
    ByteBuffer shapeBuffer = ByteBuffer.wrap(primitiveRecord);
    Geometry shape = parser.parseShape(ShapeReaderFactory.fromByteBuffer(shapeBuffer));
    if (attributes != null) {
      shape.setUserData(attributes);
    }
    return shape;
  }
}

public <T extends Geometry> void addMultiGeometry(GeometryCollection multiGeometry, List<T> result)
{
  for (int i = 0; i < multiGeometry.getNumGeometries(); i++) {
    T geometry = (T) multiGeometry.getGeometryN(i);
    geometry.setUserData(multiGeometry.getUserData());
    result.add(geometry);
  }
}

private Geometry removeHoles(Geometry inputPolygon) {
  Class<?> geomBinding = inputPolygon.getClass();
  Geometry finalGeom = inputPolygon;
  if (Polygon.class.equals(geomBinding)) {
    finalGeom = removeHoles((Polygon) inputPolygon);
  } else if (MultiPolygon.class.equals(geomBinding)) {
    List<Polygon> polygons = new ArrayList<Polygon>();
    for (int index = 0; index < inputPolygon.getNumGeometries(); index++) {
      Polygon polygon = (Polygon) inputPolygon.getGeometryN(index);
      polygons.add((Polygon) removeHoles(polygon));
    }
    finalGeom = inputPolygon.getFactory().createMultiPolygon(
        GeometryFactory.toPolygonArray(polygons));
  }
  finalGeom.setUserData(inputPolygon.getUserData());
  return finalGeom;
}

private Geometry removeSmallHoles(Geometry inputPolygon, double areaTolerance) {
  Class<?> geomBinding = inputPolygon.getClass();
  Geometry finalGeom = inputPolygon;
  if (Polygon.class.equals(geomBinding)) {
    finalGeom = removeSmallHoles((Polygon) inputPolygon, areaTolerance);
  } else if (MultiPolygon.class.equals(geomBinding)) {
    List<Polygon> polygons = new ArrayList<Polygon>();
    for (int index = 0; index < inputPolygon.getNumGeometries(); index++) {
      Polygon polygon = (Polygon) inputPolygon.getGeometryN(index);
      polygons.add((Polygon) removeSmallHoles(polygon, areaTolerance));
    }
    finalGeom = inputPolygon.getFactory().createMultiPolygon(
        GeometryFactory.toPolygonArray(polygons));
  }
  finalGeom.setUserData(inputPolygon.getUserData());
  return finalGeom;
}

private Geometry removeHoles(Polygon polygon) {
  GeometryFactory factory = polygon.getFactory();
  LineString exteriorRing = polygon.getExteriorRing();
  Geometry finalGeom = factory.createPolygon((LinearRing) exteriorRing, null);
  finalGeom.setUserData(polygon.getUserData());
  return finalGeom;
}

  private Geometry removeHoles(Polygon polygon) {
    GeometryFactory factory = polygon.getFactory();
    LineString exteriorRing = polygon.getExteriorRing();
    Geometry finalGeom = factory.createPolygon((LinearRing) exteriorRing, null);
    finalGeom.setUserData(polygon.getUserData());
    return finalGeom;
  }
}

  @Override
  public SimpleFeature next() throws NoSuchElementException {
    SimpleFeature feature = delegate.next();
    for (Object attribute : feature.getAttributes()) {
      if (attribute instanceof Geometry) {
        Geometry geometry = (Geometry) attribute;
        geometry.setUserData(forcedCRS);
      }
      builder.add(attribute);
    }
    return builder.buildFeature(feature.getID());
  }
}

  public Object visit(Literal expression, Object extraData) {
    if (!(expression.getValue() instanceof Geometry))
      return super.visit(expression, extraData);

    // check if reprojection is needed
    Geometry geom = (Geometry) expression.getValue();
    if(geom.getUserData() != null && geom.getUserData() instanceof CoordinateReferenceSystem)
      return super.visit(expression, extraData);
    
    // clone the geometry and assign the new crs
    Geometry clone = geom.getFactory().createGeometry(geom);
    clone.setUserData(defaultCrs);

    // clone
    return ff.literal(clone);
  }
}