package dikuai;
|
import java.io.*;
|
import java.nio.charset.StandardCharsets;
|
import java.util.HashMap;
|
import java.util.Map;
|
import java.util.Properties;
|
|
/**
|
* 地块信息类
|
*/
|
public class Dikuai {
|
// 用户标识
|
private String userId;
|
// 地块编号
|
private String landNumber;
|
// 地块名称
|
private String landName;
|
// 边界原始坐标
|
private String boundaryOriginalCoordinates;
|
// 边界坐标（存储多边形坐标点集合）
|
private String boundaryCoordinates;
|
// 规划路径（存储路径坐标点集合）
|
private String plannedPath;
|
// 返回点坐标
|
private String returnPointCoordinates;
|
// 往返路径坐标（割草机完成割草作业返回的路径坐标，格式：X1,Y1;X2,Y2;...;XN,YN）
|
private String returnPathCoordinates;
|
// 往返路径原始坐标
|
private String returnPathRawCoordinates;
|
// 边界点间隔
|
private String boundaryPointInterval;
|
// 角度阈值
|
private String angleThreshold;
|
// 智能场景分析
|
private String intelligentSceneAnalysis;
|
// 地块面积，单位平方米
|
private String landArea;
|
// 基准站坐标
|
private String baseStationCoordinates;
|
// 创建时间
|
private String createTime;
|
// 最新更新时间
|
private String updateTime;
|
// 割草模式
|
private String mowingTrack;
|
// 割草实时轨迹
|
private String mowingPattern;
|
// 割草宽度
|
private String mowingWidth;
|
// 割草机割刀宽度（米），默认0.40米
|
private String mowingBladeWidth;
|
// 割草重叠距离（米），默认0.06米
|
private String mowingOverlapDistance;
|
// 割草安全距离（米）
|
private String mowingSafetyDistance;
|
|
// 存储多个地块的映射表，键为地块编号
|
private static Map<String, Dikuai> dikuaiMap = new HashMap<>();
|
|
/**
|
* 初始化方法 - 从dikuai.properties文件加载所有地块数据
|
*/
|
public static void initFromProperties() {
|
Properties properties = new Properties();
|
try {
|
// 从根目录加载dikuai.properties文件，使用UTF-8编码
|
FileInputStream input = new FileInputStream("dikuai.properties");
|
InputStreamReader reader = new InputStreamReader(input, StandardCharsets.UTF_8);
|
properties.load(reader);
|
reader.close();
|
input.close();
|
|
// 清空现有地块数据
|
dikuaiMap.clear();
|
|
// 遍历所有属性，按地块编号分组
|
Map<String, Properties> landProperties = new HashMap<>();
|
|
for (String key : properties.stringPropertyNames()) {
|
// 解析键名格式：landNumber.propertyName
|
String[] parts = key.split("\\.", 2);
|
if (parts.length == 2) {
|
String landNum = parts[0];
|
String propertyName = parts[1];
|
|
if (!landProperties.containsKey(landNum)) {
|
landProperties.put(landNum, new Properties());
|
}
|
|
landProperties.get(landNum).setProperty(propertyName, properties.getProperty(key));
|
}
|
}
|
|
// 为每个地块创建Dikuai对象
|
for (Map.Entry<String, Properties> entry : landProperties.entrySet()) {
|
String landNum = entry.getKey();
|
Properties landProps = entry.getValue();
|
|
Dikuai dikuai = new Dikuai();
|
dikuai.landNumber = landNum;
|
dikuai.userId = landProps.getProperty("userId", "-1");
|
dikuai.landName = landProps.getProperty("landName", "-1");
|
dikuai.boundaryOriginalCoordinates = landProps.getProperty("boundaryOriginalCoordinates", "-1");
|
dikuai.boundaryCoordinates = landProps.getProperty("boundaryCoordinates", "-1");
|
dikuai.plannedPath = landProps.getProperty("plannedPath", "-1");
|
dikuai.returnPointCoordinates = landProps.getProperty("returnPointCoordinates", "-1");
|
dikuai.returnPathCoordinates = landProps.getProperty("returnPathCoordinates", "-1");
|
dikuai.returnPathRawCoordinates = landProps.getProperty("returnPathRawCoordinates", "-1");
|
dikuai.boundaryPointInterval = landProps.getProperty("boundaryPointInterval", "-1");
|
dikuai.angleThreshold = landProps.getProperty("angleThreshold", "-1");
|
dikuai.intelligentSceneAnalysis = landProps.getProperty("intelligentSceneAnalysis", "-1");
|
dikuai.landArea = landProps.getProperty("landArea", "-1");
|
dikuai.baseStationCoordinates = landProps.getProperty("baseStationCoordinates", "-1");
|
dikuai.createTime = landProps.getProperty("createTime", "-1");
|
dikuai.updateTime = landProps.getProperty("updateTime", "-1");
|
dikuai.mowingPattern = landProps.getProperty("mowingPattern", "-1");
|
dikuai.mowingWidth = landProps.getProperty("mowingWidth", "-1");
|
dikuai.mowingTrack = landProps.getProperty("mowingTrack", "-1");
|
dikuai.mowingBladeWidth = landProps.getProperty("mowingBladeWidth", "0.40");
|
dikuai.mowingOverlapDistance = landProps.getProperty("mowingOverlapDistance", "0.06");
|
dikuai.mowingSafetyDistance = landProps.getProperty("mowingSafetyDistance", "-1");
|
|
dikuaiMap.put(landNum, dikuai);
|
}
|
|
} catch (IOException e) {
|
// 如果文件不存在或读取失败，输出错误信息
|
System.err.println("无法读取dikuai.properties文件: " + e.getMessage());
|
}
|
}
|
|
/**
|
* 根据地块编号获取地块对象
|
* @param landNumber 地块编号
|
* @return 地块对象，如果不存在则返回null
|
*/
|
public static Dikuai getDikuai(String landNumber) {
|
return dikuaiMap.get(landNumber);
|
}
|
|
/**
|
* 获取所有地块
|
* @return 所有地块的映射表
|
*/
|
public static Map<String, Dikuai> getAllDikuai() {
|
return new HashMap<>(dikuaiMap);
|
}
|
|
/**
|
* 添加或更新地块
|
* @param landNumber 地块编号
|
* @param dikuai 地块对象
|
*/
|
public static void putDikuai(String landNumber, Dikuai dikuai) {
|
dikuaiMap.put(landNumber, dikuai);
|
}
|
|
/**
|
* 删除指定地块
|
* @param landNumber 地块编号
|
* @return 是否删除成功
|
*/
|
public static boolean removeDikuai(String landNumber) {
|
return dikuaiMap.remove(landNumber) != null;
|
}
|
|
/**
|
* 更新指定地块的字段值
|
* @param landNumber 地块编号
|
* @param fieldName 字段名
|
* @param value 新值
|
* @return 是否更新成功
|
*/
|
public static boolean updateField(String landNumber, String fieldName, String value) {
|
Dikuai dikuai = dikuaiMap.get(landNumber);
|
if (dikuai == null) {
|
System.err.println("未找到地块编号: " + landNumber);
|
return false;
|
}
|
|
return dikuai.updateInstanceField(fieldName, value);
|
}
|
|
/**
|
* 实例方法：更新当前地块对象的字段值
|
* @param fieldName 字段名
|
* @param value 新值
|
* @return 是否更新成功
|
*/
|
public boolean updateInstanceField(String fieldName, String value) {
|
switch (fieldName) {
|
case "userId":
|
this.userId = value;
|
return true;
|
case "landNumber":
|
this.landNumber = value;
|
return true;
|
case "landName":
|
this.landName = value;
|
return true;
|
case "boundaryOriginalCoordinates":
|
this.boundaryOriginalCoordinates = value;
|
return true;
|
case "boundaryCoordinates":
|
this.boundaryCoordinates = value;
|
return true;
|
case "plannedPath":
|
this.plannedPath = value;
|
return true;
|
case "returnPointCoordinates":
|
this.returnPointCoordinates = value;
|
return true;
|
case "returnPathCoordinates":
|
this.returnPathCoordinates = value;
|
return true;
|
case "returnPathRawCoordinates":
|
this.returnPathRawCoordinates = value;
|
return true;
|
case "boundaryPointInterval":
|
this.boundaryPointInterval = value;
|
return true;
|
case "angleThreshold":
|
this.angleThreshold = value;
|
return true;
|
case "intelligentSceneAnalysis":
|
this.intelligentSceneAnalysis = value;
|
return true;
|
case "landArea":
|
this.landArea = value;
|
return true;
|
case "baseStationCoordinates":
|
this.baseStationCoordinates = value;
|
return true;
|
case "createTime":
|
this.createTime = value;
|
return true;
|
case "updateTime":
|
this.updateTime = value;
|
return true;
|
case "mowingPattern":
|
this.mowingPattern = value;
|
return true;
|
case "mowingWidth":
|
this.mowingWidth = value;
|
return true;
|
case "mowingTrack":
|
this.mowingTrack = value;
|
return true;
|
case "mowingBladeWidth":
|
this.mowingBladeWidth = value;
|
return true;
|
case "mowingOverlapDistance":
|
this.mowingOverlapDistance = value;
|
return true;
|
case "mowingSafetyDistance":
|
this.mowingSafetyDistance = value;
|
return true;
|
default:
|
System.err.println("未知字段: " + fieldName);
|
return false;
|
}
|
}
|
|
/**
|
* 保存所有地块数据到properties文件
|
*/
|
public static void saveToProperties() {
|
Properties properties = new Properties();
|
|
// 将所有地块数据写入Properties对象
|
for (Map.Entry<String, Dikuai> entry : dikuaiMap.entrySet()) {
|
String landNumber = entry.getKey();
|
Dikuai dikuai = entry.getValue();
|
|
if (dikuai.userId != null) properties.setProperty(landNumber + ".userId", dikuai.userId);
|
if (dikuai.landNumber != null) properties.setProperty(landNumber + ".landNumber", dikuai.landNumber);
|
if (dikuai.landName != null) properties.setProperty(landNumber + ".landName", dikuai.landName);
|
if (dikuai.boundaryOriginalCoordinates != null) properties.setProperty(landNumber + ".boundaryOriginalCoordinates", dikuai.boundaryOriginalCoordinates);
|
if (dikuai.boundaryCoordinates != null) properties.setProperty(landNumber + ".boundaryCoordinates", dikuai.boundaryCoordinates);
|
if (dikuai.plannedPath != null) properties.setProperty(landNumber + ".plannedPath", dikuai.plannedPath);
|
if (dikuai.returnPointCoordinates != null) properties.setProperty(landNumber + ".returnPointCoordinates", dikuai.returnPointCoordinates);
|
if (dikuai.returnPathCoordinates != null) properties.setProperty(landNumber + ".returnPathCoordinates", dikuai.returnPathCoordinates);
|
if (dikuai.returnPathRawCoordinates != null) properties.setProperty(landNumber + ".returnPathRawCoordinates", dikuai.returnPathRawCoordinates);
|
if (dikuai.boundaryPointInterval != null) properties.setProperty(landNumber + ".boundaryPointInterval", dikuai.boundaryPointInterval);
|
if (dikuai.angleThreshold != null) properties.setProperty(landNumber + ".angleThreshold", dikuai.angleThreshold);
|
if (dikuai.intelligentSceneAnalysis != null) properties.setProperty(landNumber + ".intelligentSceneAnalysis", dikuai.intelligentSceneAnalysis);
|
if (dikuai.landArea != null) properties.setProperty(landNumber + ".landArea", dikuai.landArea);
|
if (dikuai.baseStationCoordinates != null) properties.setProperty(landNumber + ".baseStationCoordinates", dikuai.baseStationCoordinates);
|
if (dikuai.createTime != null) properties.setProperty(landNumber + ".createTime", dikuai.createTime);
|
if (dikuai.updateTime != null) properties.setProperty(landNumber + ".updateTime", dikuai.updateTime);
|
if (dikuai.mowingPattern != null) properties.setProperty(landNumber + ".mowingPattern", dikuai.mowingPattern);
|
if (dikuai.mowingWidth != null) properties.setProperty(landNumber + ".mowingWidth", dikuai.mowingWidth);
|
if (dikuai.mowingTrack != null) properties.setProperty(landNumber + ".mowingTrack", dikuai.mowingTrack);
|
if (dikuai.mowingBladeWidth != null) properties.setProperty(landNumber + ".mowingBladeWidth", dikuai.mowingBladeWidth);
|
if (dikuai.mowingOverlapDistance != null) properties.setProperty(landNumber + ".mowingOverlapDistance", dikuai.mowingOverlapDistance);
|
if (dikuai.mowingSafetyDistance != null) properties.setProperty(landNumber + ".mowingSafetyDistance", dikuai.mowingSafetyDistance);
|
}
|
|
try {
|
// 保存到文件，使用UTF-8编码
|
FileOutputStream output = new FileOutputStream("dikuai.properties");
|
OutputStreamWriter writer = new OutputStreamWriter(output, StandardCharsets.UTF_8);
|
properties.store(writer, "Dikuai Properties");
|
writer.close();
|
output.close();
|
} catch (IOException e) {
|
System.err.println("无法保存dikuai.properties文件: " + e.getMessage());
|
}
|
}
|
|
// Getter 和 Setter 方法
|
public String getUserId() {
|
return userId;
|
}
|
|
public void setUserId(String userId) {
|
this.userId = userId;
|
}
|
|
public String getLandNumber() {
|
return landNumber;
|
}
|
|
public void setLandNumber(String landNumber) {
|
this.landNumber = landNumber;
|
}
|
|
public String getLandName() {
|
return landName;
|
}
|
|
public void setLandName(String landName) {
|
this.landName = landName;
|
}
|
|
public String getBoundaryOriginalCoordinates() {
|
return boundaryOriginalCoordinates;
|
}
|
|
public void setBoundaryOriginalCoordinates(String boundaryOriginalCoordinates) {
|
this.boundaryOriginalCoordinates = boundaryOriginalCoordinates;
|
}
|
|
public String getBoundaryCoordinates() {
|
return boundaryCoordinates;
|
}
|
|
public void setBoundaryCoordinates(String boundaryCoordinates) {
|
this.boundaryCoordinates = boundaryCoordinates;
|
}
|
|
public String getPlannedPath() {
|
return plannedPath;
|
}
|
|
public void setPlannedPath(String plannedPath) {
|
this.plannedPath = plannedPath;
|
}
|
|
public String getReturnPointCoordinates() {
|
return returnPointCoordinates;
|
}
|
|
public void setReturnPointCoordinates(String returnPointCoordinates) {
|
this.returnPointCoordinates = returnPointCoordinates;
|
}
|
|
public String getReturnPathCoordinates() {
|
return returnPathCoordinates;
|
}
|
|
public void setReturnPathCoordinates(String returnPathCoordinates) {
|
this.returnPathCoordinates = returnPathCoordinates;
|
}
|
|
public String getReturnPathRawCoordinates() {
|
return returnPathRawCoordinates;
|
}
|
|
public void setReturnPathRawCoordinates(String returnPathRawCoordinates) {
|
this.returnPathRawCoordinates = returnPathRawCoordinates;
|
}
|
|
public String getBoundaryPointInterval() {
|
return boundaryPointInterval;
|
}
|
|
public void setBoundaryPointInterval(String boundaryPointInterval) {
|
this.boundaryPointInterval = boundaryPointInterval;
|
}
|
|
public String getAngleThreshold() {
|
return angleThreshold;
|
}
|
|
public void setAngleThreshold(String angleThreshold) {
|
this.angleThreshold = angleThreshold;
|
}
|
|
public String getIntelligentSceneAnalysis() {
|
return intelligentSceneAnalysis;
|
}
|
|
public void setIntelligentSceneAnalysis(String intelligentSceneAnalysis) {
|
this.intelligentSceneAnalysis = intelligentSceneAnalysis;
|
}
|
|
public String getLandArea() {
|
return landArea;
|
}
|
|
public void setLandArea(String landArea) {
|
this.landArea = landArea;
|
}
|
|
public String getBaseStationCoordinates() {
|
return baseStationCoordinates;
|
}
|
|
public void setBaseStationCoordinates(String baseStationCoordinates) {
|
this.baseStationCoordinates = baseStationCoordinates;
|
}
|
|
public String getCreateTime() {
|
return createTime;
|
}
|
|
public void setCreateTime(String createTime) {
|
this.createTime = createTime;
|
}
|
|
public String getUpdateTime() {
|
return updateTime;
|
}
|
|
public void setUpdateTime(String updateTime) {
|
this.updateTime = updateTime;
|
}
|
|
public String getMowingPattern() {
|
return mowingPattern;
|
}
|
|
public void setMowingPattern(String mowingPattern) {
|
this.mowingPattern = mowingPattern;
|
}
|
|
public String getMowingWidth() {
|
return mowingWidth;
|
}
|
|
public void setMowingWidth(String mowingWidth) {
|
this.mowingWidth = mowingWidth;
|
}
|
|
public String getMowingTrack() {
|
return mowingTrack;
|
}
|
|
public void setMowingTrack(String mowingTrack) {
|
this.mowingTrack = mowingTrack;
|
}
|
|
public String getMowingBladeWidth() {
|
return mowingBladeWidth;
|
}
|
|
public void setMowingBladeWidth(String mowingBladeWidth) {
|
this.mowingBladeWidth = mowingBladeWidth;
|
}
|
|
public String getMowingOverlapDistance() {
|
return mowingOverlapDistance;
|
}
|
|
public void setMowingOverlapDistance(String mowingOverlapDistance) {
|
this.mowingOverlapDistance = mowingOverlapDistance;
|
}
|
|
public String getMowingSafetyDistance() {
|
return mowingSafetyDistance;
|
}
|
|
public void setMowingSafetyDistance(String mowingSafetyDistance) {
|
this.mowingSafetyDistance = mowingSafetyDistance;
|
}
|
|
@Override
|
public String toString() {
|
return "Dikuai{" +
|
"userId='" + userId + '\'' +
|
", landNumber='" + landNumber + '\'' +
|
", landName='" + landName + '\'' +
|
", boundaryOriginalCoordinates='" + boundaryOriginalCoordinates + '\'' +
|
", boundaryCoordinates='" + boundaryCoordinates + '\'' +
|
", plannedPath='" + plannedPath + '\'' +
|
", returnPointCoordinates='" + returnPointCoordinates + '\'' +
|
", returnPathCoordinates='" + returnPathCoordinates + '\'' +
|
", returnPathRawCoordinates='" + returnPathRawCoordinates + '\'' +
|
", boundaryPointInterval='" + boundaryPointInterval + '\'' +
|
", angleThreshold='" + angleThreshold + '\'' +
|
", intelligentSceneAnalysis='" + intelligentSceneAnalysis + '\'' +
|
", landArea='" + landArea + '\'' +
|
", baseStationCoordinates='" + baseStationCoordinates + '\'' +
|
", createTime='" + createTime + '\'' +
|
", updateTime='" + updateTime + '\'' +
|
", mowingPattern='" + mowingPattern + '\'' +
|
", mowingWidth='" + mowingWidth + '\'' +
|
'}';
|
}
|
}
|
