公式相关：G8测量数据可导推测；测量数据自动修复方法优化

blade-common/src/main/java/org/springblade/common/utils/BaseUtils.java

@@ -88,17 +88,19 @@ public class BaseUtils {
      * @Author yangyj
      * @Date 2023.01.17 13:48
      **/
+    static final String NUM_REG = "^[+-]?\\d+(\\.\\d+)?$";
     public static boolean isNumber(Object value) {
-        if ((value == null) || value.toString().trim().length() == 0) {
+        if ((value == null) ) {
+            return false;
+        }
+        String stringValue = value.toString().trim();
+        if (stringValue.isEmpty()) {
             return false;
         }
         if (value instanceof Number) {
             return true;
         }
-        String pattern = "^[+-]?\\d+(\\.\\d+)?$";
-        Pattern r = Pattern.compile(pattern);
-        Matcher m = r.matcher(String.valueOf(value));
-        return m.matches();
+      return Pattern.matches(NUM_REG,stringValue);
     }
 
     /**

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

@@ -1,15 +1,13 @@
 package org.springblade.manager.formula;
 
-import com.mixsmart.utils.CustomFunction;
 import com.mixsmart.utils.ListUtils;
 import com.mixsmart.utils.StringUtils;
+import org.springblade.common.utils.BaseUtils;
 import org.springblade.core.tool.utils.Func;
-import org.springblade.manager.formula.impl.TableElementConverter;
 
 import java.math.BigDecimal;
 import java.util.*;
 import java.util.concurrent.ThreadLocalRandom;
-import java.util.stream.Collectors;
 
 import static com.mixsmart.utils.CustomFunction.rangeList;
 import static java.math.BigDecimal.ROUND_HALF_UP;
@@ -22,9 +20,9 @@ public interface ITurnPointCalculator {
 
      String ZD_REG="(?i)zd\\d+";
     static List<TurnPoint> create(List<Map<String, Object>> data, LinkedHashMap<String, String> configMap,String g8pcfw) {
-        /*1.验证数据的合理性，如果已经合理则不需要计算，直接返回
+        /*1.验证数据的合理性，如果已经合理则不需要计算
         * 2.尝试补充数据，如果不合理则重新生成转点，并用正尺方式生成
-        * 3.合理性定义（测点前视不存在或者非负数则视线高-测点实测高程在【0.5~4.8】范围，如果前视为负数则视线高-实际高程在【-0.5~-4.8】范围）*/
+        * 3.合理性定义:（测点前视不存在或者非负数则视线高-测点实测高程在【0.5~4.8】范围，如果前视为负数则视线高-实际高程在【-0.5~-4.8】范围）*/
         if (Func.isNotEmpty(data) && configMap != null) {
             LevelInfo levelInfo = new LevelInfo();
             levelInfo.setDx(g8pcfw);
@@ -45,63 +43,24 @@ public interface ITurnPointCalculator {
                     /*检验水准点数据合法性&节点定性&补充缺失闭合点*/
                     ckecked = identifying(levelInfo, tmp, tp, isHead, isTail);
                     if(!ckecked){
-                        /*ckecked失败需要主动加入tmp,后续不执行identifying直接add*/
+                        /*checked失败需要主动加入tmp,后续不执行identifying直接add*/
                         tmp.add(tp);
                     }
                 }else{
                     tmp.add(tp);
                 }
-/*                if (i == 0) {
-                    if (tp.checkBmd()) {
-                        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());
-                        *//*闭合点的偏差范围是±3mm*//*
-                        double ldx=Arrays.asList(-0.003,-0.002,-0.001,0.001,0.002,0.003).get(ThreadLocalRandom.current().nextInt(6));
-                        close.setSc(close.getSj0L() + ldx);
-                        close.setDx(ldx);
-                        close.setType(TurnPoint.CLOSE);
-                        close.getDataMap().put(CD, close.getName());
-                        close.getDataMap().put(YG, close.getBmd());
-                        close.getDataMap().put(QS, close.getQ());
-                        close.getDataMap().put(HS, close.getH());
-                        tmp.add(close);
-                        break;
-                    }
-                } else {
-                    tp.setType(TurnPoint.CE);
-                }*/
             }
             if(!ckecked){
+                /*直接写入输出缓存，不作任何计算*/
                 tmp.forEach(ITurnPointCalculator::putCache);
                 return tmp;
             }
-            /*根据黄飞扬反馈情况，暂时去掉手填转点的可能性，每次重新生成20230803*/
-            //tmp.removeIf(e-> ZD.equals(e.getType()));
+            /*判断是否可推导*/
+            levelInfo.setPersist(persist(tmp));
+            if(levelInfo.isNotPersist()) {
+                /*不可推导的情况移除转点，fill阶段自动生成*/
+                tmp.removeIf(e-> ZD.equals(e.getType()));
+            }
             List<TurnPoint> result = fill(tmp);
             if (ListUtils.isNotEmpty(result)) {
                 return  result;
@@ -110,6 +69,69 @@ public interface ITurnPointCalculator {
         return Collections.emptyList();
     }
 
+
+    static boolean persist(List<TurnPoint> list){
+        /*在补充计算之前进行完整性校验，如果成功怎不会再生成任何新转点*/
+        if(list.stream().anyMatch(e->ZD.equals(e.getType()))){
+              LevelInfo tmp = new LevelInfo();
+              LevelInfo info = list.get(0).getLevelInfo();
+              tmp.setSightHeight(info.getSightHeight());
+              for(TurnPoint tp:list){
+                  if(CE.equals(tp.getType())||CLOSE.equals(tp.getType())){
+                     boolean pass=Func.isNotBlank(tp.getSc())&&Func.isNotBlank(tp.getQ());
+                     if(BaseUtils.isNumber(tp.getSc())&&BaseUtils.isNumber(tp.getQ())){
+                         pass=tmp.getSightHeight()-tp.getQ0L()==tp.getSc0L();
+                     }else {
+                         /*是否是负前视*/
+                         boolean nagetive =false;
+                         if(BaseUtils.isNumber(tp.getSc())){
+                             tp.setQ(tmp.getSightHeight()-tp.getSc0L());
+                         }else if(BaseUtils.isNumber(tp.getQ())){
+                               nagetive=tp.getQ0L()<0;
+                         }else if(BaseUtils.isNumber(tp.getSj())&&BaseUtils.isNumber(tp.getDx())){
+                             tp.setSc(tp.getSj0L()+tp.getDx0L());
+                             tp.setQ(tmp.getSightHeight()-tp.getSc0L());
+                         }
+                         double q=tp.getQ0L();
+                         if(nagetive){
+                             /*负前视是倒尺计算，要取绝对值比较*/
+                             q=Math.abs(q);
+                         }
+                         /*判断前视是否在合理范围*/
+                         pass= q>=info.getMin()&&q<=info.getStep();
+                     }
+                     if(!pass){
+                         return false;
+                     }
+                  }else if(ZD.equals(tp.getType())){
+                      boolean pass;
+                      if(BaseUtils.isNumber(tp.getBmd())&&BaseUtils.isNumber(tp.getQ())&&BaseUtils.isNumber(tp.getH())){
+                          /*视线高、前后视都存在*/
+                          pass=tp.isWithinRangeValueZd(tp.getQ())&&tp.isWithinRangeValueZd(tp.getH())&&tmp.getSightHeight()-tp.getQ0L()==tp.getBmd0L();
+                      } else{
+                          if(!BaseUtils.isNumber(tp.getBmd())&&BaseUtils.isNumber(tp.getQ())&&BaseUtils.isNumber(tp.getH())){
+                              /*视线高不存在、前后视都存在*/
+                              tp.setBmd(tmp.getSightHeight()+tp.getH0L()-tp.getQ0L());
+                          }else if(BaseUtils.isNumber(tp.getSc())&&!BaseUtils.isNumber(tp.getQ())&&BaseUtils.isNumber(tp.getH())){
+                              /*前视不存在、视线高后视都存在*/
+                              tp.setQ(tmp.getSightHeight()+tp.getH0L()-tp.getBmd0L());
+                          }else if(BaseUtils.isNumber(tp.getSc())&&BaseUtils.isNumber(tp.getQ())&&!BaseUtils.isNumber(tp.getH())){
+                              /*前视不存在、视线高后视都存在*/
+                              tp.setH(tmp.getSightHeight()-tp.getQ0L()-tp.getBmd0L());
+                          }
+                          pass=tp.isWithinRangeValueZd(tp.getQ())&&tp.isWithinRangeValueZd(tp.getH());
+                      }
+                      if(!pass){
+                          return false;
+                      }
+                      tmp.setSightHeight(tp.getBmd0L());
+                  }
+
+              }
+        }
+        return true;
+    }
+
     static boolean identifying(LevelInfo levelInfo, List<TurnPoint> tmp,TurnPoint tp,boolean isHead,boolean isTail ){
         if (isHead) {
             if (tp.checkBmd()) {
@@ -206,91 +228,20 @@ public interface ITurnPointCalculator {
                         /*已经是最后一个测点*/
                         tp.getLevelInfo().setHasCe(Boolean.FALSE);
                     }
-                    if(checked) {
-                        /*先判断是不是转点*/
-                        if (tp.getType().equals(TurnPoint.ZD)) {
-                       /* if (Func.isBlank(tp.getQ()) && Func.isBlank(tp.getH()) && Func.isNotBlank(tp.getBmd())) {
-                            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);
-                            }
-                            *//* 更新仪器高*//*
-                            info.setSightHeight(tp.getBmd0L());
-                        } else if (Func.isBlank(tp.getQ()) && Func.isNotBlank(tp.getH()) && Func.isNotBlank(tp.getBmd())) {
-                            tp.setQ(info.getSightHeight() + tp.getH0L() - tp.getBmd0L());
-                            info.setSightHeight(tp.getBmd0L());
-                        } else if (Func.isNotBlank(tp.getQ()) && Func.isBlank(tp.getH()) && Func.isNotBlank(tp.getBmd())) {
-                            tp.setH(info.getSightHeight() - tp.getQ0L() - tp.getBmd0L());
-                            info.setSightHeight(tp.getBmd0L());
-                        } else if (Func.isNotBlank(tp.getQ()) && Func.isNotBlank(tp.getH()) && Func.isBlank(tp.getBmd())) {
-                            tp.setBmd(info.getSightHeight() + tp.getH0L() - tp.getQ0L());
-                            info.setSightHeight(tp.getBmd0L());
-                        } else if (Func.isNotBlank(tp.getQ()) && Func.isNotBlank(tp.getH()) && Func.isNotBlank(tp.getBmd())) {
-                            info.setSightHeight(tp.getBmd0L());
-                        } else {
-                            return Collections.emptyList();
-                        }
-                        *//*可能存在自动插入转点情况，所以每个转点的序号需要实时计算*//*
-                        if (tp.getLevelInfo().getHasCe()) {
-                            tp.setName("ZD" + info.getCloseZd().size());
-                            tp.getLevelInfo().getCloseZd().add(tp.clone());
-                        } else {
-                            tp.getLevelInfo().getCloseZd().remove(tp.getLevelInfo().getCloseZd().size() - 1);
-                        }*/
-                            /*转点处理，失败则直接返回空集合*/
-                            checked = tpHandlerZd(info, tp);
-                        } else if (tp.getType().equals(TurnPoint.CLOSE)) {
-                            /*闭合转点*/
-                       /* tp.setQ(info.getSightHeight() - tp.getSc0L());
-                        if (tp.needClose()) {
-                            result.addAll(tp.close());
-                        }*/
-                            /*闭合点处理*/
-                            tpHandlerClose(result, info, tp);
-                        } 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(), 1, 0, 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());
-                        }*/
-                            /*测点处理*/
-                            tpHandlerCe(result, info, tp);
-                        } 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);*/
-                            /*水准点处理*/
-                            tpHandlerBmd(tp);
-                        }
+                    /*先判断是不是转点*/
+                    if (tp.getType().equals(TurnPoint.ZD)) {
+                        /*转点处理，失败则直接返回空集合*/
+                         tpHandlerZd(info, tp);
+                    } else if (tp.getType().equals(TurnPoint.CLOSE)) {
+                        /*闭合点处理*/
+                        tpHandlerClose(result, info, tp);
+                    } else if (tp.getType().equals(TurnPoint.CE)) {
+                        /*测点处理*/
+                        tpHandlerCe(result, info, tp);
+                    } else if (tp.getType().equals(TurnPoint.BMD)) {
+                        /*水准点处理*/
+                        tpHandlerBmd(tp);
                     }
-                   /* tp.getDataMap().put(CD, tp.getName());
-                    tp.getDataMap().put(YG, tp.getBmd());
-                    tp.getDataMap().put(QS, tp.getQ());
-                    tp.getDataMap().put(HS, tp.getH());
-                    tp.getDataMap().put(SC, tp.getSc());
-                    tp.getDataMap().put(SJ, tp.getSj());
-                    tp.getDataMap().put(GC, StringUtils.number2StringZero(StringUtils.isNotEmpty(tp.getDx()) ? tp.getDx0L() * 1000 : "", 0));*/
                     /*把数据放到输出缓存*/
                     putCache(tp);
                     result.add(tp);
@@ -314,7 +265,7 @@ public interface ITurnPointCalculator {
         st.setType(TurnPoint.ZD);
         tp.getLevelInfo().getCloseZd().add(st);
     }
-    static boolean tpHandlerZd(LevelInfo info ,TurnPoint tp){
+    static void tpHandlerZd(LevelInfo info ,TurnPoint tp){
         if(!finalizeZd(tp)) {
             if (Func.isBlank(tp.getQ()) && Func.isBlank(tp.getH()) && Func.isNotBlank(tp.getBmd())) {
                 double dh = Math.abs(tp.getLevelInfo().getSightHeight() - tp.getBmd0L());
@@ -328,18 +279,12 @@ public interface ITurnPointCalculator {
                     tp.setQ(big);
                 }
                 /* 更新仪器高*/
-                /*info.setSightHeight(tp.getBmd0L());*/
             } else if (Func.isBlank(tp.getQ()) && Func.isNotBlank(tp.getH()) && Func.isNotBlank(tp.getBmd())) {
                 tp.setQ(info.getSightHeight() + tp.getH0L() - tp.getBmd0L());
-                /*info.setSightHeight(tp.getBmd0L());*/
             } else if (Func.isNotBlank(tp.getQ()) && Func.isBlank(tp.getH()) && Func.isNotBlank(tp.getBmd())) {
                 tp.setH(info.getSightHeight() - tp.getQ0L() - tp.getBmd0L());
-               /* info.setSightHeight(tp.getBmd0L());*/
             } else if (Func.isNotBlank(tp.getQ()) && Func.isNotBlank(tp.getH()) && Func.isBlank(tp.getBmd())) {
                 tp.setBmd(info.getSightHeight() + tp.getH0L() - tp.getQ0L());
-                /*info.setSightHeight(tp.getBmd0L());*/
-            }  else {
-                return false;
             }
         }
         /*更新当前视线高*/
@@ -351,7 +296,6 @@ public interface ITurnPointCalculator {
         } else {
             tp.getLevelInfo().getCloseZd().remove(tp.getLevelInfo().getCloseZd().size() - 1);
         }
-        return true;
     }
     static void tpHandlerCe(List<TurnPoint> result,LevelInfo info ,TurnPoint tp){
         if(!finalizeCe(tp)) {

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

@@ -1,16 +1,14 @@
 package org.springblade.manager.formula;
 
-import lombok.Data;
-
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * @author yangyj
  * @Date 2022/9/6 10:04
- * @description TODO
+ * @description 当前测量状态
  */
-public class LevelInfo {
+public class LevelInfo implements  Cloneable {
     /**
      * 默认值
      */
@@ -55,6 +53,9 @@ public class LevelInfo {
      */
     private List<TurnPoint> closeZd = new ArrayList<>();
 
+    /**测量数据是否可推导*/
+    private boolean persist=false;
+
     public Double getBmdSj() {
         return bmdSj;
     }
@@ -149,4 +150,13 @@ public class LevelInfo {
     public void setHasCe(Boolean hasCe) {
         this.hasCe = hasCe;
     }
+
+    public boolean isNotPersist() {
+        return !persist;
+    }
+
+    public void setPersist(boolean persist) {
+        this.persist = persist;
+    }
+
 }

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

@@ -1,8 +1,8 @@
 package org.springblade.manager.formula;
 
-import com.alibaba.fastjson.JSON;
 import com.mixsmart.utils.CustomFunction;
 import com.mixsmart.utils.StringUtils;
+import org.springblade.common.utils.BaseUtils;
 import org.springframework.beans.BeanUtils;
 
 import java.math.BigDecimal;
@@ -83,6 +83,9 @@ public class TurnPoint {
      */
     private Boolean vertical;
 
+    /**是否有效*/
+    private int isDeleted=0;
+
 
     public TurnPoint(LevelInfo levelInfo, Map<String, Object> dataMap) {
         this.levelInfo = levelInfo;
@@ -240,9 +243,17 @@ public class TurnPoint {
         }
         return d >= levelInfo.getMin() && d <= levelInfo.getStep()&&levelInfo.getSightHeight()-getQ0L()==getSc0L();
     }
+    /**判断转点前后视是否在范围*/
+    public boolean isWithinRangeValueZd(String any){
+           if(BaseUtils.isNumber(any)){
+               double d=Double.parseDouble(any);
+               return d >= levelInfo.getMin() && d <= levelInfo.getStep();
+           }
+           return false;
+    }
 
     public Boolean needClose() {
-        return this.levelInfo.getCloseZd().size() > 1;
+        return this.levelInfo.getCloseZd().size() > 1&& levelInfo.isNotPersist();
     }
 
     public static void test() {
@@ -409,4 +420,12 @@ public class TurnPoint {
     public void setVertical(Boolean vertical) {
         this.vertical = vertical;
     }
+
+    public int getIsDeleted() {
+        return isDeleted;
+    }
+
+    public void setIsDeleted(int isDeleted) {
+        this.isDeleted = isDeleted;
+    }
 }