G8有条件触发转点计算

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

@@ -4,6 +4,7 @@ package com.mixsmart.utils;
 import cn.hutool.json.JSONObject;
 import cn.hutool.log.StaticLog;
 import com.jfireel.expression.Expression;
+import org.apache.commons.lang.math.NumberUtils;
 import org.apache.http.*;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
@@ -739,6 +740,8 @@ public class FormulaUtils {
 
     }
 
+
+
     /**字符串sha256映射*/
     public static String sha256(String input) {
         try {

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

@@ -5,6 +5,7 @@ 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.springframework.beans.BeanUtils;
 
 import java.math.BigDecimal;
 import java.util.*;
@@ -59,12 +60,16 @@ public interface ITurnPointCalculator {
                     return tmp;
                 }
                 /*判断是否可推导*/
-                /*levelInfo.setPersist(persist(tmp));问题多多，暂时关闭*/
+                levelInfo.setPersist(persist(tmp));
+                List<TurnPoint> result;
                 if (levelInfo.isNotPersist()) {
                     /*不可推导的情况移除转点，fill阶段自动生成*/
                     tmp.removeIf(e -> ZD.equals(e.getType()));
+                    result=  fill(tmp);
+                }else{
+                    tmp.forEach(ITurnPointCalculator::putCache);
+                    result=tmp;
                 }
-                List<TurnPoint> result = fill(tmp);
                 if (ListUtils.isNotEmpty(result)) {
                     return result;
                 }
@@ -76,77 +81,36 @@ public interface ITurnPointCalculator {
     }
 
     /**判断是否保留原来的转点*/
-    static boolean persist(List<TurnPoint> list){
-        /*在补充计算之前进行完整性校验，如果成功则不会再生成任何新转点*/
-        if(Func.isNotEmpty(list)){
+    static boolean persist(List<TurnPoint> sourceList){
+        /*在补充计算之前对副本进行完整性校验(只校验不改数据)，如果成功则不会执行转点计算*/
+        if(Func.isNotEmpty(sourceList)){
               LevelInfo tmp = new LevelInfo();
-              LevelInfo info = list.get(0).getLevelInfo();
-              tmp.setSightHeight(info.getSightHeight());
-              for(TurnPoint tp:list){
+              LevelInfo info = sourceList.get(0).getLevelInfo();
+              BeanUtils.copyProperties(info,tmp);
+              List<TurnPoint> list =BaseUtils.copyList(sourceList);
+            assert list != null;
+            list.forEach(tp->tp.setLevelInfo(tmp));
+            boolean pass=false;
+            for(TurnPoint tp:list){
                   if(CE.equals(tp.getType())||CLOSE.equals(tp.getType())){
-                     boolean pass=false;
-                     if(BaseUtils.isNumber(tp.getSc())&&BaseUtils.isNumber(tp.getQ())){
-                         pass=tmp.getSightHeight()-tp.getQ0L()==tp.getSc0L();
-                     }else {
-                         /*是否是负前视*/
-                         boolean negative =false;
-                         if(BaseUtils.isNumber(tp.getSc())){
-                             tp.setQ(tmp.getSightHeight()-tp.getSc0L());
-                         }else if(BaseUtils.isNumber(tp.getQ())){
-                             negative=tp.getQ0L()<0;
-                         }else if(BaseUtils.isNumber(tp.getSj())){
-                             if(BaseUtils.isNumber(tp.getDx())){
-                                 tp.setSc(tp.getSj0L()+tp.getDx0L());
-                             }else{
-                                 tp.setSc(tp.getSj0L()+Double.parseDouble(rangeList(1, 0, info.getDx(), 0.001, 3, 1).get(0).toString()));
-                             }
-                             double q=tmp.getSightHeight()-tp.getSc0L();
-                             if(q>info.getMin()) {
-                                 tp.setQ(q);
-                             }
-                         }
-                         if(BaseUtils.isNumber(tp.getQ())) {
-                             double q = tp.getQ0L();
-                             if (negative) {
-                                 /*负前视是倒尺计算，要取绝对值比较*/
-                                 q = Math.abs(q);
-                             }
-                             /*判断前视是否在合理范围*/
-                             pass = q >= info.getMin() && q <= info.getStep();
-                         }
-                     }
-                     if(!pass){
-                         return false;
-                     }
+                     pass=tp.isCompletedCe()&&tp.isRealScMatch();
                   }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;
+                      pass=tp.isCompletedZd()&&tp.isWithinRangeValueZd(tp.getQ())&&tp.isWithinRangeValueZd(tp.getH())&&tp.isRealZdMatch();
+                      if(pass) {
+                          tmp.setSightHeight(tp.getBmd0L());
                       }
-                      tmp.setSightHeight(tp.getBmd0L());
+                  }else if(BMD.equals(tp.getType())){
+                       pass= tp.isCompletedBm()&&tp.isRealBmMatch();
+                  }
+                  if(!pass){
+                      return false;
                   }
-
               }
         }
         return true;
     }
 
+
     static boolean identifying(LevelInfo levelInfo, List<TurnPoint> tmp,TurnPoint tp,boolean isHead,boolean isTail ){
         if (isHead) {
             if (tp.checkBmd()) {
@@ -236,7 +200,7 @@ public interface ITurnPointCalculator {
             List<TurnPoint> result = new ArrayList<>();
             TurnPoint lastCd = turnPointList.stream().filter(TurnPoint::isCe).reduce((a, b) -> b).orElse(null);
             /*checked==false的情况下不再计算个点数据，但需要把已有数据放回输出缓存，否则改组数据会被置空*/
-            boolean checked=true;
+           /* boolean checked=true;*/
             for (TurnPoint tp : turnPointList) {
                 try {
                     if (tp.equals(lastCd)) {
@@ -369,43 +333,6 @@ public interface ITurnPointCalculator {
             int n=tp.tooFar();
             if(n!=0){
                 result.addAll(tp.limitOfRange(n));
-                /*List<TurnPoint>   closeZd=  info.getCloseZd();
-                TurnPoint last = closeZd.get(closeZd.size()-1);
-                List<TurnPoint> list = new ArrayList<>();
-                for(int i=0;i<n;i++){
-                     TurnPoint zd = new TurnPoint(info, new HashMap<>());
-                     zd.setName("ZD"+closeZd.size());
-                     double dx = Math.random() * 0.07 * (RD.nextBoolean() ? -1 : 1);
-                     zd.setBmd(StringUtils.number2StringZero(Double.parseDouble(last.getBmd()) + dx, 3));
-                    double ddx = info.getSightHeight() - zd.getBmd0L();
-                    double xx = Math.abs(ddx);
-                    double small = BigDecimal.valueOf(r.nextDouble() * (info.getStep() - info.getMin() - xx) + info.getMin()).setScale(info.getScale(), ROUND_HALF_UP).doubleValue();
-                    double big = small + xx;
-                    if (ddx < 0) {
-                        *//*后大前小,取高*//*
-                        zd.setQ(small);
-                        zd.setH(big);
-                    } else {
-                        *//*前大后小，趋低*//*
-                        zd.setQ(big);
-                        zd.setH(small);
-                    }
-                    info.setSightHeight(zd.getBmd0L());
-                    zd.getDataMap().put(CD, zd.getName());
-                    zd.getDataMap().put(YG, zd.getBmd());
-                    zd.getDataMap().put(QS, zd.getQ());
-                    zd.getDataMap().put(HS, zd.getH());
-                    if(i==n-1) {
-                        *//*最后一个重新计算前视，因为是微调所以不再判断高差是否在范围*//*
-                        tp.setQ(info.getSightHeight() - tp.getSc0L());
-                    }
-                    closeZd.add(zd.clone());
-                    *//*info.setMilestone(info.getMilestone() + 200*(x/Math.abs(x)));tooFar里已经重置仪器里程，这里专注转点*//*
-                    list.add(zd);
-                }
-                if(list.size()>0){
-                    result.addAll(list);
-                }*/
             }
 
         }

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

@@ -1,5 +1,6 @@
 package org.springblade.manager.formula;
 
+import java.io.Serializable;
 import java.util.*;
 
 /**
@@ -7,7 +8,7 @@ import java.util.*;
  * @Date 2022/9/6 10:04
  * @description 当前测量状态
  */
-public class LevelInfo implements  Cloneable {
+public class LevelInfo implements  Cloneable, Serializable {
     /**
      * 默认值
      */
@@ -210,15 +211,15 @@ public class LevelInfo implements  Cloneable {
 
 
 
-    /*重置仪器里程*/
-    public double resetMilestone(double x){
+    /*重置仪器里程,返回需要转点的数量*/
+    public int resetMilestone(double x){
         /*只要包含里程信息就必须重置等效间距*/
         double d=x-this.milestone;
+        double symbol=d / Math.abs(d);
         /*高差转点每次等效减小200米间距，如果还是小于当前测点与仪器高的间距则返回剩余间距*/
         if(this.heightTurnLength >0) {
             /*负向减少里程，正向则增大里程*/
-            if(this.milestone<Math.abs(d)) {
-                double symbol=d / Math.abs(d);
+            if(this.heightTurnLength<Math.abs(d)) {
                 /*只有当高差转点不能抵消等效间距的时候，更新当前仪器里程信息*/
                 this.setMilestone(this.milestone + this.heightTurnLength * symbol);
                 /*重新计算测点与仪器间距*/
@@ -237,7 +238,13 @@ public class LevelInfo implements  Cloneable {
             /*this.levelInfo.setMilestone(x);*/
             this.milestone=this.milestone+((int)(d/200))*200;
         }
-        return d;
+        if(Math.abs(d)>200.00001){
+            /*间距超过200则返回需要距离转点的数量*/
+            int n= (int)Math.floor(Math.abs(d)/200);
+            this.milestone+=(n*200*symbol);
+            return  n;
+        }
+        return 0;
     }
 
     public Double getHeightTurnLength() {

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

@@ -5,6 +5,7 @@ import com.mixsmart.utils.StringUtils;
 import org.springblade.common.utils.BaseUtils;
 import org.springframework.beans.BeanUtils;
 
+import java.io.Serializable;
 import java.math.BigDecimal;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -17,7 +18,7 @@ import static java.math.BigDecimal.ROUND_HALF_UP;
  * @Date 2022/11/18 11:52
  * @description TODO
  */
-public class TurnPoint {
+public class TurnPoint implements Serializable {
     /**
      * 起始点，水准点
      */
@@ -251,6 +252,25 @@ public class TurnPoint {
         /*由视线高和假定的前视推导的实测高程是否与记录的实测高程相相等*/
         return StringUtils.isEquals(StringUtils.number2StringZero(levelInfo.getSightHeight() - getQ0L(), levelInfo.getScale()), getSc());
     }
+    /*转点验证*/
+    public boolean isRealZdMatch(){
+        return StringUtils.isEquals(StringUtils.number2StringZero(levelInfo.getSightHeight()+getH0L()-getQ0L(), levelInfo.getScale()), getBmd());
+    }
+    /*水准点验证*/
+    public boolean isRealBmMatch(){
+        return StringUtils.isEquals(StringUtils.number2StringZero(getSj0L()+getH0L(), levelInfo.getScale()), getBmd());
+    }
+
+
+    public boolean isCompletedZd(){
+        return BaseUtils.isNumber(this.bmd)&&BaseUtils.isNumber(this.q)&&BaseUtils.isNumber(this.h);
+    }
+    public boolean isCompletedCe(){
+        return BaseUtils.isNumber(this.sc)&&BaseUtils.isNumber(this.q)&&BaseUtils.isNumber(this.dx);
+    }
+    public boolean isCompletedBm(){
+        return BaseUtils.isNumber(this.bmd)&&BaseUtils.isNumber(this.h)&&BaseUtils.isNumber(this.sj);
+    }
     /**判断转点前后视是否在范围*/
     public boolean isWithinRangeValueZd(String any){
            if(BaseUtils.isNumber(any)){
@@ -500,11 +520,7 @@ public class TurnPoint {
         if(this.levelInfo.isDistance()){
             Double mileage= BaseUtils.milestone(this.name);
             if(mileage!=null) {
-              double dx=this.levelInfo.resetMilestone(mileage);
-                if(Math.abs(dx)>200.00001){
-                    /*间距超过200则返回需要距离转点的数量*/
-                    return  (int)Math.floor(Math.abs(dx)/200);
-                }
+               return this.levelInfo.resetMilestone(mileage);
             }
         }
         return 0;