import org.gdal.ogr.Feature; //导入依赖的package包/类
public FeatureNative(Feature javaObject, long cPtr) {
  super(javaObject, refQueue);

  if (cleanupThread == null)
  {
      /* We didn't manage to have a daemon cleanup thread */
      /* so let's clean manually */
      while(true)
      {
          FeatureNative nativeObject =
              (FeatureNative) refQueue.poll();
          if (nativeObject != null)
              nativeObject.delete();
          else
              break;
      }
  }

  refList.add(this);

  swigCPtr = cPtr;
}
 

import org.gdal.ogr.Feature; //导入依赖的package包/类
public static void reprojectShapeFile(String pathFile, String outPathFile) {
	ogr.RegisterAll();

	DataSource vector = ogr.Open(pathFile);

	SpatialReference src = new SpatialReference(WKTString.WKT3995);
	SpatialReference dst = new SpatialReference(WKTString.WKTWGS84);
	CoordinateTransformation tr = new CoordinateTransformation(src, dst);

	Driver drv = ogr.GetDriverByName("ESRI Shapefile");
	File file = new File(outPathFile);
	if (file.exists())
		drv.DeleteDataSource(outPathFile);

	DataSource outputDs = drv.CreateDataSource(outPathFile);
	Layer outLayer = outputDs.CreateLayer(outPathFile, dst);
	
	FieldDefn field_def = new FieldDefn("DN",ogr.OFTInteger);
	outLayer.CreateField(field_def);
	 
	Layer ll = vector.GetLayer(0);
	// Get the Layer's Feature Definition
	FeatureDefn featureDefn = ll.GetLayerDefn();
	
	int n = ll.GetFeatureCount();

	// outLayer.StartTransaction();
	for (int i = 0; i < n; i++) {
		Feature feat = ll.GetNextFeature();
		Geometry gg = feat.GetGeometryRef();
		Geometry newgg = new Geometry(ogr.wkbPolygon);

		int srcType = gg.GetGeometryType() ;//& (ogrConstants.wkb25DBit);
		if (srcType == ogr.wkbPolygon) {
			//int resg = gg.Transform(tr);
			newgg.AddGeometry(gg);
		} else if (srcType == ogr.wkbMultiPolygon) {
			int geomCount = gg.GetGeometryCount();
			for (int geomIndex = 0; geomIndex < geomCount; geomIndex++) {
				Geometry g=gg.GetGeometryRef(geomIndex);
				int resg = g.Transform(tr);
				newgg.AddGeometry(g);
			}
		}

		// create a new feature
		Feature f = new Feature(featureDefn);
		f.SetGeometry(newgg);
		// f.SetFID(i);
		for (int j = 0; j < feat.GetFieldCount(); j++) {
			String type = feat.GetFieldDefnRef(j).GetFieldTypeName(feat.GetFieldType(j));
			if (type.equals("String")) {
				f.SetField(feat.GetFieldDefnRef(j).GetName(), feat.GetFieldAsString(j));
			} else if (type.equals("StringList")) {

			} else if (type.equals("Integer")) {
				f.SetField(feat.GetFieldDefnRef(j).GetName(), feat.GetFieldAsInteger(j));
			} else if (type.equals("IntegerList")) {
			} else if (type.equals("Real")) {
				f.SetField(feat.GetFieldDefnRef(j).GetName(), feat.GetFieldAsDouble(j));
			} else if (type.equals("RealList")) {
			}
		}

		// Add new feature to output Layer
		int res = outLayer.CreateFeature(f);

		System.out.println("create feature:" + res);

		gg.delete();
		feat.delete();
	}
	// outLayer.CommitTransaction();

}
 

import org.gdal.ogr.Feature; //导入依赖的package包/类
private static Layer createEdgeLayer(final DataSource       dataSource,
                                     final Collection<Node> nodes,
                                     final Iterable<Edge>   edges,
                                     final SpatialReference spatialReference)
{
     final Map<Integer, Node> nodeMap = new HashMap<>(nodes.size());

    for(final Node node : nodes)
    {
        nodeMap.put(node.getIdentifier(), node);
    }

    final Layer edgeLayer = dataSource.CreateLayer("edges",
                                                   spatialReference,
                                                   ogrConstants.wkbLineString);

    try
    {
        for(final Edge edge : edges)
        {
            final Feature edgeFeature = new Feature(edgeLayer.GetLayerDefn());

            final Geometry line = new Geometry(ogrConstants.wkbLineString);

            final Node node0 = nodeMap.get(edge.getFrom());
            final Node node1 = nodeMap.get(edge.getTo());

            line.AddPoint(node0.getX(), node0.getY());
            line.AddPoint(node1.getX(), node1.getY());

            if(edgeFeature.SetGeometry(line) != gdalconstConstants.CE_None)
            {
                throw new RuntimeException(new GdalError().getMessage());
            }

            if(edgeLayer.CreateFeature(edgeFeature) != gdalconstConstants.CE_None)
            {
                throw new RuntimeException(new GdalError().getMessage());
            }
        }
    }
    catch(final Throwable th)
    {
        edgeLayer.delete();
        throw th;
    }

    return edgeLayer;
}