转点公式

blade-service/blade-manager/src/main/java/com/mixsmart/utils/CustomFunction.java

@@ -2528,11 +2528,11 @@ public class CustomFunction {
 	 * @Author yangyj
 	 * @Date 2020.12.11 09:44
 	 **/
-	public static ArrayList<HashMap<String,Object>> objToArray(Object obj){
+	public static List<HashMap<String,Object>> objToArray(Object obj){
 		if(obj instanceof  ArrayList){
-			return (ArrayList<HashMap<String, Object>>) obj;
+			return (List<HashMap<String, Object>>) obj;
 		}else if(obj instanceof  HashMap){
-			ArrayList<HashMap<String, Object>> array = new ArrayList<HashMap<String, Object>>();
+			List<HashMap<String, Object>> array = new ArrayList<>();
 			HashMap<String, Object> map =	(HashMap<String, Object>) obj  ;
 			if(map.size()>0){
 				array.add(map);

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/ITurnPointCalculator.java

@@ -1,20 +1,203 @@
 package org.springblade.manager.formula;
 
-import com.mixsmart.utils.CustomFunction;
+import com.mixsmart.utils.ListUtils;
 import com.mixsmart.utils.StringUtils;
 
-import java.util.List;
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.mixsmart.utils.CustomFunction.rangeList;
+import static com.mixsmart.utils.CustomFunction.objToArray;
+import static java.math.BigDecimal.ROUND_HALF_UP;
 
 /**
  * @author yangyj
  */
 public interface ITurnPointCalculator {
-    /**
-     * 转点生成方法
-     * */
-     List<NextPoint> turnPoint(LevelInfo levelInfo,NextPoint nextPoint);
-     /**闭合转点生成方法
-      * */
-     List<NextPoint> closePoint(List<NextPoint> forward,LevelInfo levelInfo);
+    public static final String TURN_POINT_FIELD="测点,仪器高,前视,后视,实测高程,设计高程,偏差值";
+
+
+     static List<Object> create(Object tableData, Map<String,String> configMap){
+        if(tableData!=null&&configMap!=null){
+            List<HashMap<String,Object>> data=objToArray(tableData);
+            if(ListUtils.isNotEmpty(data)){
+                LevelInfo levelInfo = new LevelInfo();
+                List<TurnPoint> tmp =new ArrayList<>();
+                for(int i=0;i<data.size();i++){
+                    HashMap<String,Object>dm = data.get(i);
+                    Map<String,Object> dataMap = new HashMap<>();
+                    TurnPoint tp = new TurnPoint(levelInfo,dataMap);
+                    for(Map.Entry<String,String> kv:configMap.entrySet()){
+                        String key =kv.getKey();
+                        String field =kv.getValue();
+                        String value= StringUtils.handleNull(dm.get(field));
+                        switch (key){
+                            case "测点":tp.setName(value);break;
+                            case "仪器高":tp.setBmd(value);break;
+                            case "前视":tp.setQ(value);break;
+                            case "后视":tp.setH(value);break;
+                            case "实测高程":tp.setSc(value);break;
+                            case "设计高程":tp.setSj(value);break;
+                            case "偏差值":tp.setDx(value);break;
+                            default:dataMap.put(key,value);
+                        }
+                    }
+                    if(i==0){
+                        if(StringUtils.isNotEmpty(tp.getSj(),tp.getH())){
+                            tp.setType(TurnPoint.BMD);
+                            tp.setBmd(tp.getSj0L()+tp.getH0L());
+                            levelInfo.setBmdName(tp.getName());
+                            levelInfo.setBmdSj(tp.getSj0L());
+                            levelInfo.setSightHeight(tp.getBmd0L());
+                        }else{
+                            return Collections.emptyList();
+                        }
+                    }else if(tp.getName().matches("(?i)zd\\d+")){
+                        tp.setType(TurnPoint.ZD);
+                    }else if(i==data.size()-1){
+                        if(StringUtils.isEquals(tp.getName(),levelInfo.getBmdName())){
+                            if(tp.getSj()==null){
+                                tp.setSj(levelInfo.getBmdSj());
+                            }
+                            if(tp.getSc()==null&&tp.getQ()==null){
+                                double ldx=Double.parseDouble(rangeList(1, 0, levelInfo.getDx(), 0.001, 3, 1).get(0).toString());
+                                tp.setSc(tp.getSj0L()+ldx);
+                                tp.setDx(ldx);
+                            }
+                            tp.setType(TurnPoint.CLOSE);
+                        }else{
+                            tp.setType(TurnPoint.CE);
+                            tmp.add(tp);
+                            TurnPoint close = new TurnPoint(levelInfo,new HashMap<>());
+                            close.setName(levelInfo.getBmdName());
+                            close.setSj(levelInfo.getBmdSj());
+                            double ldx= Double.parseDouble(rangeList(1, 0, levelInfo.getDx(), 0.001, 3, 1).get(0).toString());
+                            close.setSc(close.getSj0L()+ldx);
+                            close.setDx(ldx);
+                            close.setType(TurnPoint.CLOSE);
+                            close.getDataMap().put("测点", close.getName());
+                            close.getDataMap().put("仪器高",close.getBmd());
+                            close.getDataMap().put("前视", close.getQ());
+                            close.getDataMap().put("后视", close.getH());
+                            tmp.add(close);
+                            break;
+                        }
+                    }else{
+                        tp.setType(TurnPoint.CE);
+                    }
+                    tmp.add(tp);
+                }
+                List<TurnPoint> result=fill(tmp);
+                if(ListUtils.isNotEmpty(result)){
+                    String keyStr = configMap.getOrDefault("显示",TURN_POINT_FIELD);
+                    return result.stream().map(TurnPoint::getDataMap).flatMap(m->{
+                        List<String> list =new ArrayList<>();
+                        for(String key:keyStr.split(",")){
+                            if(StringUtils.isNotEmpty(key)){
+                                key=key.trim();
+                                list.add(StringUtils.handleNull(m.get(key)));
+                            }else{
+                                list.add("");
+                            }
+                        }
+                        return list.stream();
+                    }).collect(Collectors.toList());
+                }
+            }
+        }
+        return Collections.emptyList();
+    }
+     static List<TurnPoint>  fill(List<TurnPoint> turnPointList){
+        if(ListUtils.isNotEmpty(turnPointList)){
+            Random rd = new Random();
+            LevelInfo info = turnPointList.get(0).getLevelInfo();
+            List<TurnPoint> result = new ArrayList<>();
+            for (TurnPoint tp : turnPointList) {
+                try {
+                    /*先判断是不是转点*/
+                    if (tp.getType().equals(TurnPoint.ZD)) {
+                        if (tp.getQ() == null && tp.getH() == null && tp.getBmd() != null) {
+                            double dh = Math.abs(tp.getLevelInfo().getSightHeight() - tp.getBmd0L());
+                            double big = BigDecimal.valueOf(rd.nextDouble() * (info.getStep() - dh) + dh).setScale(info.getScale(), ROUND_HALF_UP).doubleValue();
+                            double small = big - dh;
+                            if (tp.isHigher()) {
+                                tp.setH(big);
+                                tp.setQ(small);
+                            } else {
+                                tp.setH(small);
+                                tp.setQ(big);
+                            }
+                            tp.setSc(info.getSightHeight() - tp.getQ0L());
+                            /* 更新仪器高*/
+                            info.setSightHeight(tp.getBmd0L());
+                        } else if (tp.getQ() == null && tp.getH() != null && tp.getBmd() != null) {
+                            tp.setQ(info.getSightHeight() + tp.getH0L() - tp.getBmd0L());
+                            info.setSightHeight(tp.getBmd0L());
+                        } else if (tp.getQ() != null && tp.getH() == null && tp.getBmd() != null) {
+                            tp.setH(info.getSightHeight() - tp.getQ0L() - tp.getBmd0L());
+                            info.setSightHeight(tp.getBmd0L());
+                        } else if (tp.getQ() != null && tp.getH() != null && tp.getBmd() == null) {
+                            tp.setBmd(info.getSightHeight() + tp.getH0L() - tp.getQ0L());
+                            info.setSightHeight(tp.getBmd0L());
+                        } else if(tp.getQ() != null && tp.getH() != null && tp.getBmd() != null){
+                            info.setSightHeight(tp.getBmd0L());
+                        }else {
+                            return Collections.emptyList();
+                        }
+                        /*可能存在自动插入转点情况，所以每个转点的序号需要实时计算*/
+                        tp.setName("ZD"+info.getCloseZd().size());
+                        tp.getLevelInfo().getCloseZd().add(tp.clone());
+                    } else if (tp.getType().equals(TurnPoint.CLOSE)) {
+                        /*闭合转点*/
+                        tp.setQ(info.getSightHeight() - tp.getSc0L());
+                        if (tp.needClose()) {
+                            result.addAll(tp.close());
+                        }
+                    } else if (tp.getType().equals(TurnPoint.CE)) {
+                        if (StringUtils.isNotEmpty(tp.getSc())) {
+                            if (StringUtils.isNotEmpty(tp.getSj())) {
+                                tp.setDx(tp.getSc0L() - tp.getSj0L());
+                            }
+                            tp.setQ(info.getSightHeight() - tp.getSc0L());
+                        } else if (StringUtils.isNotEmpty(tp.getSj())) {
+                            String dx = rangeList(1, 0, info.getDx(), 0.001, 3, 1).get(0).toString();
+                            tp.setDx(dx);
+                            tp.setSc(tp.getSj0L() + tp.getDx0L());
+                            tp.setQ(info.getSightHeight() - tp.getSc0L());
+                        } else if (StringUtils.isNotEmpty(tp.getQ())) {
+                            tp.setSc(info.getSightHeight() - tp.getQ0L());
+                            if (tp.getSj() != null) {
+                                tp.setDx(tp.getSj0L() - tp.getSj0L());
+                            }
+                        }
+                        if (!tp.isVisible()) {
+                            result.addAll(tp.limit());
+                        }
+                    }else if(tp.getType().equals(TurnPoint.BMD)){
+                        TurnPoint st =new TurnPoint(tp.getLevelInfo(),new HashMap<>());
+                        st.setBmd(tp.getBmd());
+                        st.setType(TurnPoint.ZD);
+                        tp.getLevelInfo().getCloseZd().add(st);
+                    }
+                    tp.getDataMap().put("测点", tp.getName());
+                    tp.getDataMap().put("仪器高", tp.getBmd());
+                    tp.getDataMap().put("前视", tp.getQ());
+                    tp.getDataMap().put("后视", tp.getH());
+                    tp.getDataMap().put("实测高程", tp.getSc());
+                    tp.getDataMap().put("设计高程", tp.getSj());
+                    tp.getDataMap().put("偏差值", StringUtils.number2StringZero(StringUtils.isNotEmpty(tp.getDx())?tp.getDx0L()*1000:"",0));
+                    result.add(tp);
+                }catch (Exception e){
+                    tp.getDataMap().put("数据异常", tp.getName());
+                    result.add(tp);
+                    return  result;
+                }
+
+            }
+            return result;
+        }
+        return Collections.emptyList();
+    }
 
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/LevelInfo.java

@@ -2,6 +2,7 @@ package org.springblade.manager.formula;
 
 import lombok.Data;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -9,32 +10,124 @@ import java.util.List;
  * @Date 2022/9/6 10:04
  * @description TODO
  */
-@Data
 public class LevelInfo {
+    /**默认值*/
+    public static  final String  DX="-5,+5";
+    public static  final Double  STEP=4.8D;
+    public static  final Double  MIN=0.5D;
+    public static  final Integer  SCALE=3;
+    public static  final  Boolean ZERO=Boolean.FALSE;
+
+
+    private String bmdName;
+    private Double bmdSj;
     /**
      * 前后视最小值*/
-    public final Double min=0.5D;
+    private Double min;
     /**
      * 保留小数位*/
-    public final Integer scale=3;
-    /**
-     * 水准点名称*/
-    private String bm;
-    /**水准点高程
-     * */
-    private Double bmh;
+    private Integer scale;
     /**
      * 当前仪器视线高程*/
     private Double sightHeight;
     /**
-     * 转点信息*/
-    private List<NextPoint> nextPointList;
-    /**
+     /**
      *偏差范围
      */
-    private String dx="-5,+5";
+    private  String dx;
     /**
      * 前后视最大值
      */
-    private Double step=4.8D;
+    private Double step;
+    /**是否移除末尾的零*/
+    private Boolean zero;
+    /**闭合信息*/
+    private List<TurnPoint> closeZd=new ArrayList<>();
+
+    public Double getBmdSj() {
+        return bmdSj;
+    }
+
+    public void setBmdSj(Double bmdSj) {
+        this.bmdSj = bmdSj;
+    }
+
+    public Double getMin() {
+        if(min==null){
+            return MIN;
+        }
+        return min;
+    }
+
+    public String getBmdName() {
+        return bmdName;
+    }
+
+    public void setBmdName(String bmdName) {
+        this.bmdName = bmdName;
+    }
+
+    public void setMin(Double min) {
+        this.min = min;
+    }
+
+    public Integer getScale() {
+        if(scale==null){
+            return SCALE;
+        }
+        return scale;
+    }
+
+    public void setScale(Integer scale) {
+        this.scale = scale;
+    }
+
+    public Double getSightHeight() {
+        return sightHeight;
+    }
+
+    public void setSightHeight(Double sightHeight) {
+        this.sightHeight = sightHeight;
+    }
+
+    public String getDx() {
+        if(dx==null){
+            return DX;
+        }
+        return dx;
+    }
+
+    public void setDx(String dx) {
+        this.dx = dx;
+    }
+
+    public Double getStep() {
+        if(step==null){
+            return STEP;
+        }
+        return step;
+    }
+
+    public void setStep(Double step) {
+        this.step = step;
+    }
+
+    public Boolean getZero() {
+        if(zero==null){
+            return ZERO;
+        }
+        return zero;
+    }
+
+    public void setZero(Boolean zero) {
+        this.zero = zero;
+    }
+
+    public List<TurnPoint> getCloseZd() {
+        return closeZd;
+    }
+
+    public void setCloseZd(List<TurnPoint> closeZd) {
+        this.closeZd = closeZd;
+    }
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/NextPoint.java

@@ -1,100 +0,0 @@
-package org.springblade.manager.formula;
-
-/**
- * @author yangyj
- * @Date 2022/1/24 13:44
- * @description 水准尺测量对象
- */
-public class NextPoint {
-    /**
-     * 前视*/
-    private String q;
-    /*后视*/
-    private String h;
-    /**
-     * 仪高或者视高*/
-    private String bmd;
-    /**
-     * 实测值*/
-    private String sc;
-    /**
-     * 设计值*/
-    private String sj;
-    /**
-     * 偏差值*/
-    private String dx;
-    /**
-     * 是否转点*/
-    private Boolean  isZd;
-
-    public NextPoint() {
-    }
-    public NextPoint(String q, String h, String bmd) {
-        this.q = q;
-        this.h = h;
-        this.bmd = bmd;
-        this.isZd=true;
-    }
-
-    public NextPoint(String q, String sc) {
-        this.q = q;
-        this.sc = sc;
-        this.isZd=false;
-    }
-
-    public String getQ() {
-        return q;
-    }
-
-    public void setQ(String q) {
-        this.q = q;
-    }
-
-    public String getH() {
-        return h;
-    }
-
-    public void setH(String h) {
-        this.h = h;
-    }
-
-    public String getBmd() {
-        return bmd;
-    }
-
-    public void setBmd(String bmd) {
-        this.bmd = bmd;
-    }
-
-    public String getSc() {
-        return sc;
-    }
-
-    public void setSc(String sc) {
-        this.sc = sc;
-    }
-
-    public String getSj() {
-        return sj;
-    }
-
-    public void setSj(String sj) {
-        this.sj = sj;
-    }
-
-    public String getDx() {
-        return dx;
-    }
-
-    public void setDx(String dx) {
-        this.dx = dx;
-    }
-
-    public Boolean getZd() {
-        return isZd;
-    }
-
-    public void setZd(Boolean zd) {
-        isZd = zd;
-    }
-}

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/TurnPoint.java

@@ -0,0 +1,319 @@
+package org.springblade.manager.formula;
+
+import com.mixsmart.utils.StringUtils;
+import org.springframework.beans.BeanUtils;
+
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static java.math.BigDecimal.ROUND_HALF_UP;
+
+/**
+ * @author yangyj
+ * @Date 2022/11/18 11:52
+ * @description TODO
+ */
+public class TurnPoint {
+    /**起始点，水准点*/
+    public static final Integer BMD = 0;
+    /**普通测点*/
+    public static final Integer CE = 1;
+    /**转点*/
+    public static final Integer ZD = 2;
+    /**闭合点*/
+    public static final Integer CLOSE = 10;
+    public static final Double  FA=0.618;
+    public  static  Random RD= new Random();
+
+    private String name;
+    private String q;
+    /**
+     * 后视
+     */
+    private String h;
+    /**
+     * 仪高或者视高
+     */
+    private String bmd;
+    /**
+     * 实测值
+     */
+    private String sc;
+    /**
+     * 设计值
+     */
+    private String sj;
+    /**
+     * 偏差值
+     */
+    private String dx;
+    /**
+     * 类型，起始点0，普通1，转点2，闭合点10
+     */
+    private Integer type;
+    /**当前计算参数信息*/
+    private LevelInfo levelInfo;
+
+    private Map<String,Object> dataMap;
+
+
+    public TurnPoint(LevelInfo levelInfo, Map<String, Object> dataMap) {
+        this.levelInfo = levelInfo;
+        this.dataMap = dataMap;
+    }
+
+    public TurnPoint() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getQ() {
+        return q;
+    }
+
+    public Double  getQ0L() {
+        return Double.parseDouble(q);
+    }
+
+    public void setQ(String q) {
+        this.q = q;
+    }
+
+    public void setQ(Double q) {
+        this.q = StringUtils.number2StringZero(q,levelInfo.getScale());
+    }
+
+    public String getH() {
+        return h;
+    }
+    public Double getH0L() {
+        return Double.parseDouble(h);
+    }
+
+    public void setH(String h) {
+        this.h = h;
+    }
+    public void setH(Double h) {
+        this.h = StringUtils.number2StringZero(h,levelInfo.getScale());
+    }
+    public String getBmd() {
+        return bmd;
+    }
+    public Double getBmd0L() {
+        return Double.parseDouble(bmd);
+    }
+    public void setBmd(String bmd) {
+        this.bmd = bmd;
+    }
+    public void setBmd(Double bmd) {
+        this.bmd = StringUtils.number2StringZero(bmd,levelInfo.getScale());
+    }
+    public String getSc() {
+        return sc;
+    }
+    public Double getSc0L() {
+        return Double.parseDouble(sc);
+    }
+    public void setSc(String sc) {
+        this.sc = sc;
+    }
+    public void setSc(Double sc) {
+        this.sc = StringUtils.number2StringZero(sc,levelInfo.getScale());
+    }
+    public String getSj() {
+        return sj;
+    }
+    public Double getSj0L() {
+        return Double.parseDouble(sj);
+    }
+    public void setSj(String sj) {
+        this.sj = sj;
+    }
+    public void setSj(Double sj) {
+        this.sj = StringUtils.number2StringZero(sj,levelInfo.getScale());
+    }
+    public String getDx() {
+        return dx;
+    }
+
+    public Double getDx0L() {
+        return Double.parseDouble(dx);
+    }
+    public void setDx(String dx) {
+        this.dx = dx;
+    }
+    public void setDx(Double dx) {
+        this.dx = StringUtils.number2StringZero(dx,levelInfo.getScale());
+    }
+    public Integer getType() {
+        return type;
+    }
+
+    public void setType(Integer type) {
+        this.type = type;
+    }
+
+    public LevelInfo getLevelInfo() {
+        return levelInfo;
+    }
+
+    public void setLevelInfo(LevelInfo levelInfo) {
+        this.levelInfo = levelInfo;
+    }
+
+    public Map<String, Object> getDataMap() {
+        return dataMap;
+    }
+
+    public void setDataMap(Map<String, Object> dataMap) {
+        this.dataMap = dataMap;
+    }
+
+    public Boolean isHigher(){
+        return levelInfo.getSightHeight()>= getBmd0L();
+    }
+    public Boolean isVisible(){
+        /*只有测点落在0.5到step之间才有效*/
+        double d =getQ0L();
+        return d>=levelInfo.getMin()&&d<=levelInfo.getStep();
+    }
+    public Boolean needClose(){
+      return   this.levelInfo.getCloseZd().size()>1;
+    }
+
+    public static void main(String[] args) {
+        for(int i=0;i<100;i++){
+            LevelInfo info = new LevelInfo();
+            info.setSightHeight(144.228);
+            TurnPoint tp = new TurnPoint(info,new HashMap<>());
+            tp.setSc(138.981);
+            System.out.println("第"+(i+1)+"次");
+            System.out.println(tp.limit().stream().map(TurnPoint::getBmd0L).collect(Collectors.toList()));
+        }
+
+    }
+    public static Random r = new Random();
+    public  List<TurnPoint> limit(){
+        List<TurnPoint> result = new ArrayList<>();
+        double step = levelInfo.getStep();
+        double q=(double)(r.nextInt(30)+5)/10;
+        setQ(q);
+        double target=q+getSc0L();
+        double hd=Math.abs(target-levelInfo.getSightHeight());
+        boolean higher=target>levelInfo.getSightHeight();
+        int loop=0;
+        do{
+            TurnPoint tmp;
+            if(hd>step){
+                double x=hdx(higher);
+                tmp =createZd(x,higher,"ZD"+(levelInfo.getCloseZd().size()));
+                hd-=x;
+            }else{
+                 tmp =createZd(hd,higher,"ZD"+(levelInfo.getCloseZd().size()));
+                 hd=0;
+            }
+            result.add(tmp);
+            levelInfo.getCloseZd().add(tmp.clone());
+            loop++;
+        }while (hd>0&&loop<20);
+        return result;
+    }
+
+    public  double hdx( boolean higher){
+        double step = levelInfo.getStep();
+        double x;
+        double loop=0;
+        do{
+             x=r.nextGaussian()+(step-1.5);
+             if(x>(step*FA)&&x<(step-levelInfo.getMin())){
+                 loop=100;
+             }
+        }while (loop<100);
+        return x;
+    }
+
+    public  List<TurnPoint> close(){
+        List<TurnPoint> result = this.levelInfo.getCloseZd();
+        Collections.reverse(result);
+        int n = result.size();
+        result.remove(0);
+        result=result.stream().peek(TurnPoint::jitter).collect(Collectors.toList());
+        for(TurnPoint np:result){
+            double dx = this.levelInfo.getSightHeight()-np.getBmd0L();
+            double x=Math.abs(dx);
+            double small = BigDecimal.valueOf(r.nextDouble() * (levelInfo.getStep()-levelInfo.getMin()-x)+levelInfo.getMin()).setScale(levelInfo.getScale(), ROUND_HALF_UP).doubleValue();
+            double big = small + x;
+            np.setName("ZD"+(n++));
+            if(dx<0){
+                /*后大前小,取高*/
+                np.setQ(small);
+                np.setH(big);
+            }else{
+                /*前大后小，趋低*/
+                np.setQ(big);
+                np.setH(small);
+            }
+            this.levelInfo.setSightHeight(np.getBmd0L());
+            np.getDataMap().put("测点", np.getName());
+            np.getDataMap().put("仪器高",np.getBmd());
+            np.getDataMap().put("前视", np.getQ());
+            np.getDataMap().put("后视", np.getH());
+            this.setQ(this.levelInfo.getSightHeight()-this.getSc0L());
+        }
+        return  result;
+    }
+    public static void jitter(TurnPoint tp){
+        if(tp!=null&&StringUtils.isNotEmpty(tp.getBmd())){
+            double dx = Math.random()*0.07*(RD.nextBoolean()?-1:1);
+            tp.setBmd(StringUtils.number2StringZero(Double.parseDouble(tp.getBmd())+dx,3));
+        }
+    }
+    @Override
+    public TurnPoint clone(){
+        TurnPoint t = new TurnPoint();
+        t.setName("ZD"+(this.levelInfo.getCloseZd().size()+1));
+        BeanUtils.copyProperties(this,t);
+        t.setDataMap(new HashMap<>(20));
+        return t;
+    }
+
+    public TurnPoint createZd(Double x,boolean higher,String name){
+        TurnPoint zd = new TurnPoint(levelInfo,new HashMap<>());
+        zd.setName(name);
+        if(higher){
+            zd.setBmd(levelInfo.getSightHeight()+x);
+        }else{
+            zd.setBmd(levelInfo.getSightHeight()-x);
+        }
+        double small = 0;
+        double big = 0;
+        int loop =0;
+        while ((small<this.levelInfo.getMin()||big>this.levelInfo.getStep())&&loop++<10){
+             small = BigDecimal.valueOf(r.nextDouble() * (levelInfo.getStep()-levelInfo.getMin()-x)+levelInfo.getMin()).setScale(levelInfo.getScale(), ROUND_HALF_UP).doubleValue();
+             big = small + x;
+        }
+        if(higher){
+            zd.setH(big);
+            zd.setQ(small);
+        }else{
+            zd.setH(small);
+            zd.setQ(big);
+        }
+        levelInfo.setSightHeight(zd.getBmd0L());
+        zd.getDataMap().put("测点", name);
+        zd.getDataMap().put("仪器高",zd.getBmd());
+        zd.getDataMap().put("前视", zd.getQ());
+        zd.getDataMap().put("后视", zd.getH());
+        return zd;
+    }
+
+
+
+}

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/impl/CompositeDataAccess.java

@@ -125,7 +125,11 @@ public class CompositeDataAccess  {
         return get(cursor);
     }
 
+    public LinkedHashMap<String, FormData> getFds() {
+        return fds;
+    }
 
-
-
+    public void setFds(LinkedHashMap<String, FormData> fds) {
+        this.fds = fds;
+    }
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/impl/FormulaTurnPoint.java

@@ -2,16 +2,16 @@ package org.springblade.manager.formula.impl;
 
 import com.mixsmart.utils.StringUtils;
 import lombok.Data;
-import org.springblade.core.tool.utils.BeanUtil;
 import org.springblade.core.tool.utils.Func;
 import org.springblade.manager.dto.ElementData;
 import org.springblade.manager.dto.FormData;
-import org.springblade.manager.entity.ContractInfo;
 import org.springblade.manager.formula.FormulaStrategy;
+import org.springblade.manager.formula.ITurnPointCalculator;
 import org.springblade.manager.formula.LevelInfo;
-import org.springblade.manager.formula.NextPoint;
 import org.springframework.stereotype.Component;
 import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 
 /**
  * @author yangyj
@@ -25,7 +25,7 @@ public class FormulaTurnPoint implements FormulaStrategy {
     static   final List<String>  KEYS;
     private List<String> args;
     static {
-        KEYS=new ArrayList<>(Arrays.asList("测点","后视","前视","仪器高","实际标高","设计标高","高程偏差","备注"));
+        KEYS=new ArrayList<>(Arrays.asList("测点","后视","前视","仪器高","实测高程","设计高程","偏差值","备注"));
     }
     @Override
     public void execute(List<FormData> fds, Map<String, Object> constantMap) {
@@ -44,46 +44,43 @@ public class FormulaTurnPoint implements FormulaStrategy {
             }
             CompositeDataAccess cda = new CompositeDataAccess(dataSourceMap);
             cda.cursorReset();
+            List<Map<String,Object>> tableData = new ArrayList<>();
+            Map<String,String> configMap = new HashMap<>();
+            configMap.put("测点","cd");
+            configMap.put("后视","hs");
+            configMap.put("前视","qs");
+            configMap.put("仪器高","yg");
+            configMap.put("实测高程","sc");
+            configMap.put("设计高程","sj");
+            configMap.put("偏差值","pc");
+            configMap.put("备注","bz");
             while (cda.hasNext()) {
                 LinkedHashMap<String, ElementData> map = cda.next();
-                LevelInfo levelInfo = new LevelInfo();
-                ElementData sjgc = map.get(c("设计标高"));
                 ElementData cd = map.get(c("测点"));
-                if (cda.isFirst()) {
-                     ElementData hs = map.get(c("后视"));
-                     if(hs!=null&&sjgc!=null){
-                          double bmd =hs.doubleValue()+ sjgc.doubleValue();
-                          map.put(c("仪器高"),hs.clone(bmd));
-                          levelInfo.setSightHeight(bmd);
-                          levelInfo.setBm(cd.stringValue());
-                     }else{
-                          cda.close();
-                     }
-                }else{
-                    NextPoint np =  new NextPoint();
-                    ElementData gc = map.get(c("实际标高"));
-                    if(Func.isNotEmpty(gc)){
-                       np.setSc(gc.stringValue());
-                    }
-                    ElementData qs = map.get(c("前视"));
-                    if(Func.isNotEmpty(qs)){
-                        np.setQ(qs.stringValue());
-                    }
-                    ElementData sj = map.get(c("设计标高"));
-                    if(Func.isNotEmpty(sj)){
-                        np.setH(sj.stringValue());
-                    }
-                    ElementData hs = map.get(c("后视"));
-                    ElementData yg = map.get(c("仪器高"));
-                    if(Func.isNotEmpty(hs)&&Func.isNotEmpty(yg)&&Func.isNotBlank(hs.stringValue())&&Func.isNotBlank(yg.stringValue())){
-                        np.setZd(Boolean.TRUE);
-                        np.setBmd(yg.stringValue());
-                    }
-                    tpc.vacancy(levelInfo,np);
-                    /* 插入过程没有确定前先不生成转点
-                    List<NextPoint> nextPointList= tpc.turnPoint(levelInfo,nextPoint);
-                     */
-                }
+                ElementData hs = map.get(c("后视"));
+                ElementData qs = map.get(c("前视"));
+                ElementData yg = map.get(c("仪器高"));
+                ElementData sc = map.get(c("实测高程"));
+                ElementData sj = map.get(c("设计高程"));
+                ElementData pc = map.get(c("偏差值"));
+                ElementData bz = map.get(c("备注"));
+                Map<String,Object> tmp = new HashMap<>(16);
+                tmp.put("cd",cd.getValue());
+                tableData.add(tmp);
+            }
+           List<Object> data= ITurnPointCalculator.create(tableData,configMap);
+            AtomicInteger ai = new AtomicInteger();
+            Map<Integer,List<Object>> dataMap = data.stream().collect(Collectors.groupingBy(e->ai.getAndAdd(1)%configMap.size()));
+            LinkedHashMap<String, FormData> fdsOrder =cda.getFds();
+            int i=0;
+            for(FormData formData:fdsOrder.values()){
+                List<Object> dl =dataMap.get(i++);
+               List<ElementData> list = formData.getValues();
+               for(int k=0;k<list.size();k++){
+                   ElementData ed = list.get(k);
+                   /*dl的数量肯定是大于等于list,否则存在问题*/
+                   ed.setValue(dl.get(k));
+               }
             }
         }
     }

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/impl/TurnPointCalculator.java

@@ -5,7 +5,6 @@ import com.mixsmart.utils.ListUtils;
 import com.mixsmart.utils.StringUtils;
 import org.springblade.manager.formula.ITurnPointCalculator;
 import org.springblade.manager.formula.LevelInfo;
-import org.springblade.manager.formula.NextPoint;
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
@@ -22,228 +21,5 @@ import static java.math.BigDecimal.ROUND_HALF_UP;
  * @description TODO
  */
 public class TurnPointCalculator implements ITurnPointCalculator {
-    public static Double FACTOR =0.46D;
-
-    @Override
-    public List<NextPoint> turnPoint(LevelInfo levelInfo, NextPoint nextPoint) {
-        double min=levelInfo.getMin();
-        List<NextPoint> list = new ArrayList<>();
-        double cD =levelInfo.getStep();
-        double bD= levelInfo.getBmh();
-        double npD=Double.parseDouble(nextPoint.getSc());
-        boolean existQ=StringUtils.isNumber(nextPoint.getQ());
-        double qD=existQ?Double.parseDouble(StringUtils.number2String(nextPoint.getQ(),3)):0;
-        /*默认保留三位小数*/
-        int scaleI = levelInfo.getScale();
-        /*前视后视的高差计算参数，趋高的时候前视小后视大，趋低的时候前视大后视小*/
-        double cut = BigDecimal.valueOf(cD*FACTOR).setScale(scaleI,ROUND_HALF_UP).doubleValue();
-        Random rd = new Random();
-        /*累计循环次数，循环上限是300*/
-        int count=0;
-        if(existQ){
-            if(npD+qD==bD){
-                /*已经得到正确的测量结果*/
-                list.add(new NextPoint(StringUtils.number2String(bD-npD,scaleI),StringUtils.number2String(npD,scaleI)));
-            }else{
-                /**
-                 * target是当前测点的前一个转点仪器高*/
-                double target=npD+qD;
-                boolean higher=target>bD;
-                boolean loop=true;
-                do{
-                    double big,small;
-                    /*视高和目标视高的差值落在前后视最大差值内*/
-                    /*bD可能从上下两个方向不断逼近target*/
-                    if(Math.abs(bD-target)<cD-min){
-                        loop=false;
-                        double hd=Math.abs(bD-target);
-                        big=BigDecimal.valueOf(rd.nextDouble()*(cD-cut)+cut).setScale(scaleI,ROUND_HALF_UP).doubleValue();
-                        small=big-hd;
-                        NextPoint lastZd =new NextPoint();
-                        lastZd.setBmd(StringUtils.number2String(target,3));
-                        if(higher){
-                            /*前小后大*/
-                            lastZd.setQ(StringUtils.number2String(small,3));
-                            lastZd.setH(StringUtils.number2String(big,3));
-                        }else{
-                            /*前大后小*/
-                            lastZd.setQ(StringUtils.number2String(big,3));
-                            lastZd.setH(StringUtils.number2String(small,3));
-                        }
-                        lastZd.setZd(true);
-                        list.add(lastZd);
-                        list.add(new NextPoint(StringUtils.number2String(qD,3),StringUtils.number2String(npD,3)));
-                    }else{
-                        big=BigDecimal.valueOf(rd.nextDouble()*(cD-cut)+cut).setScale(scaleI,ROUND_HALF_UP).doubleValue();
-                        small=BigDecimal.valueOf(rd.nextDouble()*(cut-0.6)+0.5).setScale(scaleI,ROUND_HALF_UP).doubleValue();
-                        NextPoint p =createNextPoint(higher,big,small,bD,null,scaleI);
-                        bD=Double.parseDouble(p.getBmd());
-                        list.add(p);
-                    }
-                    count++;
-                }while (loop&&count<300);
-            }
-        }else {
-            boolean loop=true;
-            do{
-                double big,small;
-                boolean higher=npD+min>bD;
-                NextPoint p;
-                if(bD-npD>min&&bD-npD<cD){
-                    /*测点已经在仪器测量范围0.5<x<step*/
-                    loop=false;
-                    p=new NextPoint();
-                    zd(bD-npD,0d,bD,npD,scaleI,p);
-                }else{
-                    big=BigDecimal.valueOf(rd.nextDouble()*(cD-cut)+cut).setScale(scaleI,ROUND_HALF_UP).doubleValue();
-                    small=BigDecimal.valueOf(rd.nextDouble()*(cut-0.6)+0.5).setScale(scaleI,ROUND_HALF_UP).doubleValue();
-                    p =createNextPoint(higher,big,small,bD,npD,scaleI);
-                }
-                /*更新视高*/
-                if(StringUtils.isNotEmpty(p.getBmd())){
-                    bD=Double.parseDouble(p.getBmd());
-                }
-                list.add(p);
-                count++;
-            }while (loop&&count<300);
-        }
-        if(list.size()>1){
-            levelInfo.setSightHeight(Double.parseDouble(list.get(list.size()-1).getBmd()));
-            levelInfo.getNextPointList().addAll(list.stream().limit(list.size()-1).collect(Collectors.toList()));
-        }
-        return list;
-    }
-    public  NextPoint createNextPoint(Boolean higher,Double big,Double small ,Double bD,Double sc,Integer scaleI){
-        NextPoint p = new NextPoint();
-        if(higher){
-            /*测点大于仪器高0.5米*/
-            /*前视小后视大*/
-            zd(small, big, bD, sc, scaleI, p);
-        }else{
-            /*前视大后视小*/
-            zd(big, small, bD, sc, scaleI, p);
-        }
-        return  p;
-    }
-    private  void zd(Double q, Double h, Double bD, Double sc, Integer scaleI, NextPoint p) {
-        p.setQ(StringUtils.number2String(q,scaleI));
-        if(h!=0) {
-            p.setBmd(StringUtils.number2String(bD+h-q,scaleI));
-            p.setH(StringUtils.number2String(h, scaleI));
-            p.setZd(true);
-        }else{
-            p.setSc(StringUtils.number2String(sc,scaleI));
-        }
-    }
-    public  static  Random RD= new Random();
-    public static void jitter(NextPoint np){
-        if(np!=null&&StringUtils.isNotEmpty(np.getBmd())){
-            double dx = Math.random()*0.07*(RD.nextBoolean()?-1:1);
-            np.setBmd(StringUtils.number2String(Double.parseDouble(np.getBmd())+dx,3));
-        }
-    }
-
-    @Override
-    public List<NextPoint> closePoint(List<NextPoint> forward, LevelInfo levelInfo) {
-        List<NextPoint> result = new ArrayList<>();
-        Random rd = new Random();
-        /*默认保留三位小数*/
-        int scaleI=levelInfo.getScale();
-        /*当前实测点*/
-        Double[] DL=new Double[]{0.001,0.002,0.003,-0.001,-0.002,-0.003};
-        double ldx=DL[(int)Math.round(Math.random()*5)];
-        double scD= levelInfo.getBmh()+ldx;
-        /*当前仪器视线高*/
-        double bD=levelInfo.getSightHeight();
-        if(ListUtils.isNotEmpty(forward)){
-            /*每一个转点仪器视高之间最大高差*/
-            double cD =levelInfo.getStep();
-            /*必须保证转点视高最小高程大于0.5*/
-            String target=StringUtils.number2String(scD+0.5+rd.nextDouble()*(cD-0.5),scaleI);
-            List<NextPoint> backward = new ArrayList<>(forward);
-            /*反转转点得到闭合转点走势*/
-            Collections.reverse(backward);
-            backward=backward.stream().peek(TurnPointCalculator::jitter).collect(Collectors.toList());
-            backward.add(new NextPoint("0","0",target));
-            if(backward.size()>1){
-                /*去头*/
-                backward.remove(0);
-            }
-            for(NextPoint np:backward){
-                double dx = bD-Double.parseDouble(np.getBmd());
-                double dxx=Math.abs(dx);
-                double big=BigDecimal.valueOf(rd.nextDouble()*(cD-dxx-0.5)+dxx+0.5).setScale(scaleI,ROUND_HALF_UP).doubleValue();
-                double small=big-dxx;
-                if(dx<0){
-                    /*后大前小,取高*/
-                    np.setQ(StringUtils.number2String(small,3));
-                    np.setH(StringUtils.number2String(big,3));
-
-                }else{
-                    /*前大后小，趋低*/
-                    np.setQ(StringUtils.number2String(big,3));
-                    np.setH(StringUtils.number2String(small,3));
-                }
-                bD=Double.parseDouble(np.getBmd());
-                result.add(np);
-            }
-            result.add(new NextPoint(StringUtils.number2String(Double.parseDouble(target)-scD,scaleI),StringUtils.number2String(scD,scaleI)));
-        }else{
-            /*闭合点*/
-            result.add(new NextPoint(StringUtils.number2String(bD-scD,scaleI),StringUtils.number2String(scD,scaleI)));
-        }
-        return result;
-    }
-
-    public void vacancy(LevelInfo levelInfo,NextPoint np){
-        if(StringUtils.isNotEmpty(levelInfo.getDx())){
-            levelInfo.setDx(levelInfo.getDx().replaceAll("[\\[\\]]",""));
-        }else{
-            levelInfo.setDx("-6,6");
-        }
-        String dx;
-        double min=0.5d;
-        do{
-            dx= CustomFunction.rangeList(1,0,levelInfo.getDx(),1,0,1).get(0).toString();
-        }while (StringUtils.isEquals(0,dx));
-        double hd;
-        boolean hasNp=true;
-        if(StringUtils.isNotEmpty(levelInfo.getSightHeight(),np.getSc())){
-            hd=levelInfo.getSightHeight()-Double.parseDouble(np.getSc());
-            if(hd>min&&hd<levelInfo.getStep()){
-                hasNp=false;
-            }
-        }
-        if(StringUtils.isNotEmpty(np.getSc())&&StringUtils.isEmpty(np.getQ(),np.getSj())){
-            /*010*/
-            if(!hasNp){
-                np.setQ(CustomFunction.calculate(levelInfo.getSightHeight(),np.getSc(),3,2).toString());
-            }
-        }else if(StringUtils.isNotEmpty(np.getSc(),np.getSj())&&StringUtils.isEmpty(np.getQ())){
-            /*011*/
-            if(!hasNp){
-                np.setQ(CustomFunction.calculate(levelInfo.getSightHeight(),np.getSc(),3,2).toString());
-            }
-        }else if(StringUtils.isNotEmpty(np.getSc(),np.getQ())&&StringUtils.isEmpty(np.getSj())){
-            /*110*/
-        }else if(StringUtils.isNotEmpty(np.getSj())&&StringUtils.isEmpty(np.getSc(),np.getQ())){
-            /*001*/
-            np.setSc(StringUtils.number2String(Double.parseDouble(np.getSj())+Double.parseDouble(dx)/1000,3));
-            hd=levelInfo.getSightHeight()-Double.parseDouble(np.getSc());
-            if(hd>min&&hd<levelInfo.getStep()){
-                hasNp=false;
-            }
-            if(!hasNp){
-                np.setQ(CustomFunction.calculate(levelInfo.getSightHeight(),np.getSc(),3,2).toString());
-            }
-        }else if(StringUtils.isNotEmpty(np.getQ(),levelInfo.getSightHeight())&&StringUtils.isEmpty(np.getSc(),np.getSj())){
-            /*100*/
-            np.setSc(StringUtils.number2String(levelInfo.getSightHeight()-Double.parseDouble(np.getQ()),3));
-        }else if(StringUtils.isNotEmpty(np.getQ(),np.getSj())&&StringUtils.isEmpty(np.getSc())){
-            /*101*/
-            np.setSc(StringUtils.number2String(Double.parseDouble(np.getSj())+Double.parseDouble(dx)/1000,3));
-        }else if(StringUtils.isNotEmpty(np.getQ(),np.getSc(),np.getSj())){
-        }
-    }
 
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/FormulaServiceImpl.java

@@ -564,6 +564,7 @@ public class FormulaServiceImpl extends BaseServiceImpl<FormulaMapper, Formula>
                             }else{
                                 fd.getFormula().setFormula(StringPool.EMPTY);
                             }
+                            relyParse(fd.getFormula());
                         }else if(f.contains(".ladder(")){
                             String tf=f.replace(CustomFunction.CLASS_CALL+"ladder","").replaceAll("[()]","");
                             String[] tfa=tf.split(",");
@@ -580,6 +581,7 @@ public class FormulaServiceImpl extends BaseServiceImpl<FormulaMapper, Formula>
                             }else{
                                 fd.getFormula().setFormula(StringPool.EMPTY);
                             }
+                            relyParse(fd.getFormula());
                         }
                         System.out.println("聚合处理");
                     }