c语言sscanf函数的用法是什么
318
2022-12-31
java使用GeoTools读取shp文件并画图的操作代码
java使用GeoTools读取shp文件并画图的操作代码
GeoTools是ArcGis地图与java对象的桥梁，恰如jdbc之于oracle与java。
shp文件本身是存有地理对象边界坐标、对象中心城市及城市编号的多多边形字符串。
需要使用的依赖如下
对象：
public class CutProperty {
private String province;
private int x;
private int y;
/**
* 图片宽
* */
private int width;
/**
* 图片高
* */
private int height;
/**
* 画图时线条粗细
* */
private float weight;
/**
* 地图坐标右边界
* */
private int rightborder;
/**
* 地图坐标放大倍数
* */
private int bei;
/**
* 文字大小
* */
private int stringsize;
来自@author yukun24@126.com的工具类，读取shp文件：
package com.gwhn.geotools;
import org.geotools.data.FeatureWriter;
import org.geotools.data.FileDataStoreFactorySpi;
import org.geotools.data.Transaction;
import org.geotools.data.shapefile.ShapefileDataStore;
import org.geotools.data.shapefile.ShapefileDataStoreFactory;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.geotools.data.simple.SimpleFeatureSource;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
import org.geotools.referencing.crs.DefaultGeographicCRS;
import org.junit.Test;
import org.locationtech.jts.geom.*;
import org.opengis.feature.Property;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import java.io.File;
import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.*;
public class ShapeUtil {
//读shp文件【几何信息+属性信息】
public List
List
//基于上面新建的shapfile文件，进行读取
//构建shapefile数据存储的实例
ShapefileDataStoreFactory dataStoreFactory = new ShapefileDataStoreFactory();
//基于路径构建文件对象
File file = new File(path);
//构建一个已存在的shapfile数据源
//ShapefileDataStore:数据存储实现，允许从Shapefiles读取和写入
ShapefileDataStore ds = (ShapefileDataStore) dataStoreFactory.createDataStore(file.toURI().toURL());
//设置编码，防止中文读取乱码
ds.setCharset(Charset.forName("UTF-8"));
//getFeatureSource():ContentFeatureSource
//这个特性是由 FeatureCollection提供的操作完成的。单独的特征记忆实现由子类提供:
//SimpleFeatureSource特征资源明确地使用FeatureCollection【集合】，可迭代
SimpleFeatureSource featureSource = ds.getFeatureSource();
//getFeatures():以FeatureCollection的形式检索所有特性。
//一个用于处理FeatureCollection的实用工具类。提供一个获取FeatureCollection实例的机制
FeatureCollection
System.out.println("几何对象总共有：" + result.size());
//features():返回一个FeatureIterator迭代器
SimpleFeatureIterator it = (SimpleFeatureIterator) result.features();
while (it.hasNext()) {
SimpleFeature feature = it.next();
//迭代属性【属性我们可以理解为一个几何对象的属性节点，也就是对一个几何图形的描述字段】
Iterator
// System.out.println("========================");
//再来个while
while (ip.hasNext()) {
Property pro = ip.next();
// System.out.println(pro.getName()+" = "+pro.getValue());
propertyList.add(pro);
}//end 属性迭代
}
it.close();
return propertyList;
}
}
来自@author yukun24@126.com的工具类，此处用来将shp中获取的字符串转化为多多边形对象MultiPolygon
package com.gwhn.geotools;
import org.locationtech.jts.geom.*;
import org.locationtech.jts.io.ParseException;
import org.locationtech.jts.io.WKTReader;
import java.util.List;
/**
* 几何对象构建器
*
* @author yukun24@126.com
* @version V1.0.1
* @blob http://blog.csdn.net/appleyk
* @date 2017年12月8日10:38:49
*/
//单例模式
public class GeometryCreator {
public static GeometryCreator geometryCreator = null;
private GeometryFactory geometryFactory = new GeometryFactory();
public GeometryCreator() {
}
/**
* 返回本类的唯一实例
*
* @return
*/
public static GeometryCreator getInstance() {
if (geometryCreator == null) {
return new GeometryCreator();
}
return geometryCreator;
}
/**
* 1.构建点
*/
/**
* 1.1根据X，Y坐标构建一个几何对象： 点 【Point】
*
* @param x
* @param y
* @return
*/
public Point createPoint(double x, double y) {
Coordinate coord = new Coordinate(x, y);
Point point = geometryFactory.createPoint(coord);
return point;
}
/**
* 1.2根据几何对象的WKT描述【String】创建几何对象： 点 【Point】
*
* @return
* @throws ParseException
*/
public Point createPointByWKT(String PointWKT) throws ParseException {
WKTReader reader = new WKTReader(geometryFactory);
Point point = (Point) reader.read(PointWKT);
return point;
}
/**
* 1.3根据几何对象的WKT描述【String】创建几何对象：多点 【MultiPoint】
*
* @return
* @throws ParseException
*/
public MultiPoint createMulPointByWKT(String MPointWKT) throws ParseException {
WKTReader reader = new WKTReader(geometryFactory);
MultiPoint mpoint = (MultiPoint) reader.read(MPointWKT);
return mpoint;
}
/**
* 2.构建线
*/
/**
* 2.1根据两点 创建几何对象：线 【LineString】
*
* @param ax
* @param ay
* @param bx
* @param by
* @return
*/
public LineString createLine(double ax, double ay, double bx, double by) {
Coordinate[] coords = new Coordinate[]{new Coordinate(ax, ay), new Coordinate(bx, by)};
LineString line = geometryFactory.createLineString(coords);
return line;
}
/**
* 2.2根据线的WKT描述创建几何对象：线 【LineString】
*
* @param LineStringWKT
* @return
* @throws ParseException
*/
public LineString createLineByWKT(String LineStringWKT) throws ParseException {
WKTReader reader = new WKTReader(geometryFactory);
LineString line = (LineString) reader.read("LINESTRING(0 0, 2 0)");
return line;
}
/**
* 2.3根据点组合的线数组，创建几何对象：多线 【MultiLineString】
*
* @param list
* @return
*/
public MultiLineString createMLine(List
MultiLineString ms = null;
if (list == null) {
return ms;
}
LineString[] lineStrings = new LineString[list.size()];
// Coordinate[] coords1 = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)};
// LineString line1 = geometryFactory.createLineString(coords1);
//
// Coordinate[] coords2 = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)};
// LineString line2 = geometryFactory.createLineString(coords2);
int i = 0;
for (Coordinate[] coordinates : list) {
lineStrings[i] = geometryFactory.createLineString(coordinates);
}
ms = geometryFactory.createMultiLineString(lineStrings);
return ms;
}
/**
* 2.4根据几何对象的WKT描述【String】创建几何对象 ： 多线【MultiLineString】
*
* @param MLineStringWKT
* @return
* @throws ParseException
*/
public MultiLineString createMLineByWKT(String MLineStringWKT) throws ParseException {
WKTReader reader = new WKTReader(geometryFactory);
MultiLineString line = (MultiLineString) reader.read(MLineStringWKT);
return line;
}
/**
* 3.构建多边形
*/
/**
* 3.1 根据几何对象的WKT描述【String】创建几何对象：多边形 【Polygon】
*
* @param PolygonWKT
* @return
* @throws ParseException
*/
public Polygon createPolygonByWKT(String PolygonWKT) throws ParseException {
WKTReader reader = new WKTReader(geometryFactory);
Polygon polygon = (Polygon) reader.read(PolygonWKT);
return polygon;
}
/**
* 3.2 根据几何对象的WKT描述【String】创建几何对象： 多多边形 【MultiPolygon】
*
* @param MPolygonWKT
* @return
* @throws ParseException
*/
public MultiPolygon createMulPolygonByWKT(String MPolygonWKT) throws ParseException {
WKTReader reader = new WKTReader(geometryFactory);
MultiPolygon mpolygon = (MultiPolygon) reader.read(MPolygonWKT);
return mpolygon;
}
/**
* 根据多边形数组 进行多多边形的创建
*
* @param polygons
* @return
* @throws ParseException
*/
public MultiPolygon createMulPolygonByPolygon(Polygon[] polygons) throws ParseException {
return geometryFactory.createMultiPolygon(polygons);
}
/**
* 4.构建几何对象集合
*/
/**
* 4.1 根据几何对象数组，创建几何对象集合：【GeometryCollection】
*
* @return
* @throws ParseException
*/
public GeometryCollection createGeoCollect(Geometry[] geoArray) throws ParseException {
// LineString line = createLine(125.12,25.4,85.63,99.99);
// Polygon poly = createPolygonByWKT("POLYGON((20 10, 30 0, 40 10, 30 20, 20 10))");
// Geometry g1 = geometryFactory.createGeometry(line);
// Geometry g2 = geometryFactory.createGeometry(poly);
// Geometry[] geoArray = new Geometry[]{g1,g2};
GeometryCollection gc = geometryFactory.createGeometryCollection(geoArray);
return gc;
}
/**
* 5.构建圆
*/
/**
* 5.1 根据圆点以及半径创建几何对象：特殊的多边形--圆 【Polygon】
*
* @param x
* @param y
* @param RADIUS
* @return
*/
public Polygon createCircle(double x, double y, final double RADIUS) {
final int SIDES = 32;//圆上面的点个数
Coordinate coords[] = new Coordinate[SIDES + 1];
for (int i = 0; i < SIDES; i++) {
double angle = ((double) i / (double) SIDES) * Math.PI * 2.0;
double dx = Math.cos(angle) * RADIUS;
double dy = Math.sin(angle) * RADIUS;
coords[i] = new Coordinate((double) x + dx, (double) y + dy);
}
coords[SIDES] = coords[0];
//线性环
LinearRing ring = geometryFactory.createLinearRing(coords);
Polygon polygon = geometryFactory.createPolygon(ring, null);
return polygon;
}
/**
* 6.构建环
*/
/**
* 6.1 根据WKT创建环
*
* @param ringWKT
* @return
* @throws ParseException
*/
public LinearRing createLinearRingByWKT(String ringWKT) throws ParseException {
WKTReader reader = new WKTReader(geometryFactory);
LinearRing ring = (LinearRing) reader.read(ringWKT);
return ring;
}
}
有xml如下：
xml读取以获取shp文件位置和图片输出位置：
package com.gwhn.Util;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Text;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.Iterator;
/**
* @author banxian
* @date 2021/1/21 15:56
*/
public class YereeXmlContext {
/**
* 根据一二三级字节点的key，迭代到第三级节点根据三级key获取值
*
*
*
*
*
*
*
* @param key1
* @param key2
* @param key3
* @return
* @author banxian
* @date: 2021/1/21 19:51
*/
public String getXmlValue(String key1, String key2, String key3) {
try {
//1.创建Reader对象
SAXReader reader = new SAXReader();
//2.加载xml
String directoryPath = Thread.currentThread().getContextClassLoader().getResource("config.xml").getPath();//获取项目根目录
Document document = reader.read(new File(directoryPath));
//3.获取根节点
Element rootElement = document.getRootElement();
Element moduleElement = getTargetElement(key1, rootElement);
Element groupElement = getTargetElement(key2, moduleElement);
Element configElement = getTargetElement(key3, groupElement);
Attribute attribute = (Attribute) configElement.attributes().get(0);
String key = attribute.getValue();
Text text3 = (Text) configElement.content().get(0);
String value = text3.getText();
return value;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 获取和targetKey匹配的一个子节点
*
* @param targetKey
* @param parentElement
* @return
* @author banxian
* @date: 2021/1/21 19:53
*/
public Element getTargetElement(String targetKey, Element parentElement) {
Iterator iterator = parentElement.elementIterator();
Element childElement = null;
while (iterator.hasNext()) {
Element element = (Element) iterator.next();
Attribute attribute = (Attribute) element.attributes().get(0);
String key = attribute.getValue();
if (key.equals(targetKey) || key == targetKey) {
childElement = element;
break;
}
}
return childElement;
}
}
核心类：用多边形绘图
package com.gwhn.Util;
import com.gwhn.entity.CutProperty;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.MultiPolygon;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.List;
/**
* @author banxian
* @date 2021/6/28 12:37
*/
public class PolygonUtil {
ImageUtils imageUtils = new ImageUtils();
TxtUtil txtUtil = new TxtUtil();
/**
* 根据多多边形画图
* @param path
* @param cutProperty
* @param multiPolygonList
* @return
* @author banxian
* @date: 2021/6/30 15:31
*/
public void graphicsByMultiPolygon(String path, List
try {
int imageWidth = cutProperty.getWidth();// 图片的宽度
int imageHeight = cutProperty.getHeight();// 图片的高度
BufferedImage image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
Graphics2D graphics = (Graphics2D) image.getGraphics();
graphics.setColor(Color.white);
graphics.fillRect(0, 0, imageWidth, imageHeight);
graphics.setColor(Color.black);
int m = cutProperty.getBei() / 100;
graphics.setStroke(new BasicStroke(cutProperty.getWeight() * m));//线条粗细
Font font = new Font("宋体", Font.BOLD, 1200);
graphics.setFont(font);
graphics.drawString(cutProperty.getProvince(), 12500, 1500);
for (MultiPolygon multiPolygon : multiPolygonList) {
int num = multiPolygon.getNumGeometries();
for (int i = 0; i < num; i++) {
Geometry geometry = multiPolygon.getGeometryN(i);
drawPolygon(geometry, cutProperty, graphics);
}
}
imageUtils.createImage(path, image);
System.out.println(path + ":" + font.getSize());
} catch (
Exception e) {
e.printStackTrace();
}
}
/**
* 画出一个多边形
* @param geometry
* @param cutProperty
* @param graphics2D
* @return
* @author banxian
* @date: 2021/6/28 12:37
*/
public void drawPolygon(Geometry geometry, CutProperty cutProperty, Graphics2D graphics2D) {
int m = cutProperty.getBei() / 100;
Double xtemp = Double.valueOf(cutProperty.getX() * m);
Double ytemp = Double.valueOf(cutProperty.getY() * m);
//处理飞地
if (geometry.toString().contains("),")) {
String geoStr = geometry.toString();
String tempStr = geoStr.substring(9, geoStr.length() - 1) + ",";
while (tempStr.contains("),")) {
String temp = tempStr.substring(0, tempStr.indexOf("),") + 2);
tempStr = tempStr.substring(temp.length()).trim();
Polygon polygon = txtUtil.getPolygonByStr(temp,cutProperty);
graphics2D.drawPolygon(polygon);
}
} else {
Coordinate[] coordinates = geometry.getCoordinates();
Polygon polygon = new Polygon();
Double x, y;
for (int j = 0; j < coordinates.length; j++) {
Coordinate coordinate = coordinates[j];
x = coordinate.getX() * cutProperty.getBei() - xtemp;
y = cutProperty.getRightborder() * m - coordinate.getY() * cutProperty.getBei() - ytemp;
polygon.addPoint(x.intValue(), y.intValue());
}
graphics2D.drawPolygon(polygon);
}
}
}
工具类：处理特殊的边界，一般由飞地、岛屿组成
package com.gwhn.Util;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.gwhn.entity.CutProperty;
import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author banxian
* @date 2021/5/10 15:57
*/
public class TxtUtil {
public Polygon getPolygonByStr(String polygonStr,CutProperty cutProperty) {
polygonStr = polygonStr.substring(1, polygonStr.length() - 2) + ",";
List
while (polygonStr.contains(",")) {
String pointStr = polygonStr.substring(0, polygonStr.indexOf(",")).trim();
polygonStrList.add(pointStr);
polygonStr = polygonStr.substring(polygonStr.indexOf(",") + 1);
}
return transPointStrToPolygon(polygonStrList, cutProperty);
}
public Polygon transPointStrToPolygon(List
int m = cutProperty.getBei() / 100;
Double xtemp = Double.valueOf(cutProperty.getX() * m);
Double ytemp = Double.valueOf(cutProperty.getY() * m);
Polygon polygon = new Polygon();
for (String pointStr : polygonStrList) {
Double x = Double.parseDouble(pointStr.substring(0, pointStr.indexOf(" ")));
Double y = Double.parseDouble(pointStr.substring(pointStr.indexOf(" ")).trim());
x = x * cutProperty.getBei() - xtemp;
y = cutProperty.getRightborder()*m - y * cutProperty.getBei()-ytemp;
polygon.addPoint(x.intValue(), y.intValue());
}
return polygon;
}
//读取json文件
public String readJsonFile(String fileName) {
String jsonStr = "";
try {
File jsonFile = new File(fileName);
FileReader fileReader = new FileReader(jsonFile);
Reader reader = new InputStreamReader(new FileInputStream(jsonFile), "utf-8");
int ch = 0;
StringBuffer sb = new StringBuffer();
while ((ch = reader.read()) != -1) {
sb.append((char) ch);
}
fileReader.close();
reader.close();
jsonStr = sb.toString();
return jsonStr;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
/**
* 读取json获取图片剪切参数
*
* @param
* @return
* @author banxian
* @date: 2021/6/25 8:16
*/
public Map
String path = Thread.currentThread().getContextClassLoader().getResource("property.json").getPath();//获取项目根目录
String s = readJsonFile(path);
JSONObject jsonObject = JSON.parseObject(s);
JSONArray jsonArray = jsonObject.getJSONArray("properties");//构建JSONArray数组
List
Map
for (CutProperty cutProperty : cutPropertyList) {
cutPropertyMap.put(cutProperty.getProvince(), cutProperty);
}
return cutPropertyMap;
}
}
核心类：从读到的shp文件数据中提取字符串转化为多多边形，绘图
package com.gwhn.controller;
import com.gwhn.Util.PolygonUtil;
import com.gwhn.Util.TxtUtil;
import com.gwhn.Util.YereeXmlContext;
import com.gwhn.entity.CutProperty;
import com.gwhn.geotools.GeometryCreator;
import com.gwhn.geotools.ShapeUtil;
import org.locationtech.jts.geom.MultiPolygon;
import org.opengis.feature.Property;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* @author banxian
* @date 2021/6/1 8:12
*/
public class ShpPictureController {
PolygonUtil polygonUtil = new PolygonUtil();
TxtUtil txtUtil = new TxtUtil();
Map
/**
* 根据国家shp文件画出中国地图
* @param
* @return
* @author banxian
* @date: 2021/6/28 12:35
*/
public void doNation() {
YereeXmlContext yereeXmlContext = new YereeXmlContext();
GeometryCreator geometryCreator = new GeometryCreator();
String shapePath = yereeXmlContext.getXmlValue("Http", "FileExport", "ProvincePath") + "province.shp";
ShapeUtil shapeUtil = new ShapeUtil();
try {
List
List
for (int i = 0; i * 8 < propertyList.size(); i++) {
Property property = propertyList.get(i * 8);
String valueStr = property.getValue().toString();
MultiPolygon multiPolygon = geometryCreator.createMulPolygonByWKT(valueStr);
multiPolygonList.add(multiPolygon);
}
String path = yereeXmlContext.getXmlValue("Http", "FileExport", "ExportPath");
File newFileDir = new File(path);
//如果不存在 则创建
if (!newFileDir.exists()) {
newFileDir.mkdirs();
}
// String picturName = imageUtils.genImageName() + ".jpg";
String picturName = "中国.jpg";
CutProperty cutProperty = cutPropertyMap.get("中国");
polygonUtil.graphicsByMultiPolygon(path + picturName, multiPolygonList, cutProperty);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("完成");
}
/**
* 根据分省shp文件画出地图
* @param
* @return
* @author banxian
* @date: 2021/6/28 12:35
*/
public void doProvince() {
YereeXmlContext yereeXmlContext = new YereeXmlContext();
GeometryCreator geometryCreator = new GeometryCreator();
ShapeUtil shapeUtil = new ShapeUtil();
String shapeDirPath = yereeXmlContext.getXmlValue("Http", "FileExport", "ProvinceShapePath");
List
fileList = getFileList(shapeDirPath, fileList);
for (int j = 0; j < fileList.size(); j++) {
File file = fileList.get(j);
if (file.getName().contains(".shp")) {
File parentFile = file.getParentFile();
String province = parentFile.getName();
System.out.println(province);
int size = 7;
if (province.equals("湖北") || province == "湖北" || province.equals("安徽") || province == "安徽") {
size = 10;
}
CutProperty cutProperty = cutPropertyMap.get(province);
try {
List
List
for (int i = 0; i * size < propertyList.size(); i++) {
http:// String valueStr = propertyList.get(i * size).getValue().toString();
MultiPolygon multiPolygon = geometryCreator.createMulPolygonByWKT(valueStr);
multiPolygonList.add(multiPolygon);
}
String path = yereeXmlContext.getXmlValue("Http", "FileExport", "ExportPath");
;
File newFileDir = new File(path);
//如果不存在 则创建
if (!newFileDir.exists()) {
newFileDir.mkdirs();
}
String picturName = province + ".jpg";
polygonUtil.graphicsByMultiPolygon(path + picturName, multiPolygonList, cutProperty);
} catch (Exception e) {
e.printStackTrace();
}
}
}
System.out.println("完成");
}
/**
* 获取shp文件集合
* @param dirPath
* @param fileList
* @return
* @author banxian
* @date: 2021/6/28 12:36
*/
public List
File dir = new File(dirPath);
if (!dir.exists()) {
dir.mkdirs();
}
for (File file : dir.listFihttp://les()) {
if (!file.isDirectory()) {
fileList.add(file);
} else {
getFileList(file.getPath(), fileList);
}
}
return fileList;
}
}
地图坐标截取参数
{
"properties": [
{
"province": "中国",
"x": 8000,
"y": 18600,
"width": 25000,
"height": 15000,
"weight": 5.0,
"bei":350,
"rightborder": 25000,
"stringsize": 500
},
{
"province": "上海",
"x": 12050,
"y": 21800,
"width": 23000,
"height": 16000,
"weight": 0.8,
"bei": 10000,
"rightborder": 25000,
"stringsize": 500
},
{
"province": "云南",
"x": 9700,
"y": 22000,
"width": 25000,
"height": 25000,
"weight": 2.0,
"bei": 2500,
"rightborder": 25000,
"stringsize": 50
},
{
"province": "内蒙古",
"x": 9000,
"y": 19000,
"width": 25000,
"height": 15000,
"weight": 3.0,
"bei": 600,
"rightborder": 25000,
"stringsize": 180
},
{
"province": "北京",
"x": 11515,
"y": 20830,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 10000,
"rightborder": 25000,
"stringsize": 600
},
{
"province": "吉林",
"x": 12100,
"y": 20200,
"width": 25000,
"height": 17000,
"weight": 2.0,
"bei": 2100,
"rightborder": 25000,
"stringsize": 40
},
{
"province": "四川",
"x": 9600,
"y": 21500,
"width": 25000,
"height": 20000,
"weight": 2.0,
"bei": 1900,
"rightborder": 25000,
"stringsize": 40
},
{
"province": "天津",
"x": 11600,
"y": 20920,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 10000,
"rightborder": 25000,
"stringsize": 600
},
{
"province": "宁夏",
"x": 10400,
"y": 20960,
"width": 20000,
"height": 25000,
"weight": 1.0,
"bei": 4210,
"rightborder": 25000,
"stringsize": 40
},
{
"province": "安徽",
"x": 11350,
"y": 21500,
"width": 25000,
"height": 22000,
"weight": 1.0,
"bei": 3300,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "山东",
"x": 11430,
"y": 21050,
"width": 25000,
"height": 20000,
"weight": 1.0,
"bei": 2900,
"rightborder": 25000,
"stringsize": 35
},
{
"province": "山西",
"x": 10900,
"y": 20850,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 3500,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "广东",
"x": 10750,
"y": 22400,
"width": 25000,
"height": 15000,
"weight": 1.0,
"bei": 2200,
"rightborder": 25000,
"stringsize": 40
},
{
"province": "广西",
"x": 10400,
"y": 22200,
"width": 25000,
"height": 18000,
"weight": 1.0,
"bei": 2600,
"rightborder": 25000,
"stringsize": 35
},
{
"province": "新疆",
"x": 7200,
"y": 19800,
"width": 25000,
"height": 20000,
"weight": 2.0,
"bei": 900,
"rightborder": 25000,
"stringsize": 150
},
{
"province": "江苏",
"x": 11550,
"y": 21400,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 4000,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "江西",
"x": 11250,
"y": 21950,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 4000,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "河北",
"x": 11250,
"y": 20600,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 3000,
"rightborder": 25000,
"stringsize": 40
},
{
"province": "河南",
"x": 10900,
"y": 21200,
"width": 25000,
"height": 23000,
"weight": 1.0,
"bei": 2700,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "浙江",
"x": 11800,
"y": 21800,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 5000,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "湖北",
"x": 10800,
"y": 21500,
"width": 25000,
"height": 20000,
"weight": 1.0,
"bei": 3000,
"rightborder": 25000,
"stringsize": 30
},
{
"province": "湖南",
"x": 10800,
"y": 21900,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 3500,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "甘肃",
"x": 9000,
"y": 20300,
"width": 25000,
"height": 25000,
"weight": 2.0,
"bei": 1200,
"rightborder": 25000,
"stringsize": 70
},
{
"province": "福建",
"x": 11550,
"y": 22050,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 4000,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "西藏",
"x": 7500,
"y": 21000,
"width": 25000,
"height": 15000,
"weight": 1.5,
"bei": 1000,
"rightborder": 25000,
"stringsize": 100
},
{
"province": "贵州",
"x": 10350,
"y": 21900,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 3200,
"rightborder": 25000,
"stringsize": 35
},
{
"province": "辽宁",
"x": 11850,
"y": 20500,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 3300,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "重庆",
"x": 10500,
"y": 21700,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 4700,
"rightborder": 25000,
"stringsize": 20
},
{
"province": "陕西",
"x": 10450,
"y": 21000,
"width": 25000,
"height": 25000,
"weight": 1.0,
"bei": 2900,
"rightborder": 25000,
"stringsize": 25
},
{
"province": "青海",
"x": 8700,
"y": 20900,
"width": 25000,
"height": 15000,
"weight": 2.0,
"bei": 1500,
"rightborder": 25000,
"stringsize": 70
},
{
"province": "黑龙江",
"x": 12000,
"y": 19500,
"width": 25000,
"height": 18000,
"weight": 1.0,
"bei": 1500,
"rightborder": 25000,
"stringsize": 60
}
]
}
测试类
public static void main(String[] args) {
try {
ShpPictureController shpPictureController = new ShpPictureController();
// shpPictureController.doProvince();
shpPictureController.doNation();
} catch (Exception e) {
e.printStackTrace();
}
}
最终画出的图片效果如下:
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
发表评论
暂时没有评论，来抢沙发吧~