Merge branch 'feature-v4-20220801' into feature-v4-gh

# Conflicts:
#	4dkankan-utils-redis/src/main/java/com/fdkankan/redis/util/RedisBloomUtils.java

4dkankan-utils-model/src/main/java/com/fdkankan/model/bean/PointBean.java

@@ -18,4 +18,6 @@ public class PointBean implements Serializable {
 	private float x;
 	private float y;
 	private Map<String, String> parent;
+
+	private String geoType;
 }

4dkankan-utils-model/src/main/java/com/fdkankan/model/bean/WallBean.java

@@ -28,4 +28,8 @@ public class WallBean implements Serializable {
     private String[] children;
     private Double width;
 
+    private String geoType;
+    private boolean important;
+    private boolean out;
+
 }

4dkankan-utils-model/src/main/java/com/fdkankan/model/utils/CreateObjUtil.java

@@ -12,6 +12,7 @@ import lombok.extern.slf4j.Slf4j;
 
 import java.io.*;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 
@@ -689,8 +690,7 @@ public class CreateObjUtil {
 	}
 
 	public static void main(String[] args) throws Exception {
-		CreateObjUtil.convertTxtToVisionmodeldata("D:\\test\\test\\vision.txt", "D:\\test\\test\\vision.modeldata");
-
+		CreateObjUtil.convertTxtToVisionmodeldata("D:\\test\\vision(5).txt", "D:\\test\\vision.modeldata");
 
 	}
 

4dkankan-utils-model/src/main/java/com/fdkankan/model/utils/FloorPlanUserUtil.java

@@ -0,0 +1,186 @@
+package com.fdkankan.model.utils;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.fdkankan.common.util.FileUtils;
+import com.fdkankan.model.bean.PointBean;
+import com.fdkankan.model.bean.SegmentBean;
+import com.fdkankan.model.bean.VertexBean;
+import com.fdkankan.model.bean.WallBean;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+public class FloorPlanUserUtil {
+
+	public static void main(String[] args) {
+		JSONObject floorPlanUserJson = FloorPlanUserUtil.createFloorPlanUserJson("D:\\test\\新建文件夹\\floorplan_cad.json");
+		FileUtil.writeUtf8String(floorPlanUserJson.toJSONString(), "D:\\test\\新建文件夹\\floorplan.json");
+
+	}
+
+	/**
+	 * 根据floorplan_cad.json文件生成houseType.json
+	 * @param filePath
+	 * @return
+	 */
+	public static JSONObject createFloorPlanUserJson(String filePath) {
+
+		JSONArray floors = readFloorJson(filePath);
+		if(CollUtil.isEmpty(floors)){
+			return null;
+		}
+
+		JSONObject house = new JSONObject();
+		house.put("unit", "m");
+		house.put("angle", 0);
+		house.put("type", "cad");
+		house.put("version", "v4.0");
+
+		JSONArray targetFloors = new JSONArray();
+		house.put("floors", targetFloors);
+
+		int currentId = 0;
+
+		for(int i = 0; i < floors.size(); i++){
+			JSONObject floor = (JSONObject)floors.get(i);
+			Map<String, Object> result = createFloorHandler(floor, currentId);
+			JSONArray points = (JSONArray)result.get("pointArr");
+			JSONArray walls = (JSONArray)result.get("wallArr");
+			currentId = (int)result.get("currentId");
+			JSONObject targetFloor = new JSONObject();
+			targetFloor.put("points", convertArrToMap(points));
+			targetFloor.put("walls", convertArrToMap(walls));
+			targetFloor.put("id", floor.getInteger("id"));
+			targetFloor.put("name",floor.getString("name"));
+			targetFloor.put("subgroup", floor.getInteger("subgroup"));
+			targetFloors.add(targetFloor);
+		}
+
+		house.put("currentId", currentId);
+
+		return house;
+	}
+
+	private static Map<String, JSONObject> convertArrToMap(JSONArray arr){
+		Map<String, JSONObject> result = new HashMap<>();
+		if(CollUtil.isEmpty(arr)){
+			return result;
+		}
+
+		arr.stream().forEach(item->{
+			JSONObject object = (JSONObject)item;
+			String vectorId = object.getString("vectorId");
+			result.put(vectorId, object);
+		});
+
+		return result;
+	}
+
+	private static Map<String, Object> createFloorHandler(JSONObject floor, int currentId){
+
+		Map<String, Object> result = new HashMap<>();
+		//处理点
+		Map<Integer, VertexBean> vertexMap = new HashMap<>();
+		Map<String, PointBean> pointMap = new HashMap<>();
+		Map<Integer, String> vpMap = new HashMap<>();
+		JSONArray vertexArr = floor.getJSONArray("vertex-xy");
+		for(int i = 0; i < vertexArr.size(); i++){
+			Object o = vertexArr.get(i);
+
+			VertexBean vertexBean = JSON.parseObject(JSON.toJSONString(o), VertexBean.class);
+			Integer vertexId = vertexBean.getId();
+			vertexMap.put(vertexId, vertexBean);
+
+			String pointId = "Point" + currentId;
+			pointMap.put(pointId, PointBean.builder().geoType("Point").vectorId(pointId).x(vertexBean.getX()).y(vertexBean.getY()).build());
+			++currentId;
+
+			vpMap.put(vertexId, pointId);
+		}
+
+		//处理墙
+		Map<Integer, SegmentBean> segmentMap = new HashMap<>();
+		Map<String, WallBean> wallMap = new HashMap<>();
+		Map<Integer, String> swMap = new HashMap<>();
+		JSONArray segmentArr = floor.getJSONArray("segment");
+		Map<String, String> startMap = new HashMap<>();
+		Map<String, String> endMap = new HashMap<>();
+		for(int i = 0; i < segmentArr.size(); i++){
+			Object o = segmentArr.get(i);
+
+			SegmentBean segmentBean = JSON.parseObject(JSON.toJSONString(o), SegmentBean.class);
+			String startPointId = vpMap.get(segmentBean.getA());
+			String endPointId = vpMap.get(segmentBean.getB());
+			segmentBean.setStartPointId(startPointId);
+			segmentBean.setEndPointId(endPointId);
+
+			Integer segmentId = segmentBean.getId();
+			segmentMap.put(segmentId, segmentBean);
+
+			String wallId = "Wall" + currentId;
+			WallBean wallBean = WallBean.builder()
+				.geoType("Wall")
+				.vectorId(wallId)
+				.start(segmentBean.getStartPointId())
+				.end(segmentBean.getEndPointId())
+				.children(new String[]{})
+				.width(0.2d)
+				.build();
+			wallMap.put(wallId, wallBean);
+			++currentId;
+
+			startMap.put(wallBean.getStart(), wallBean.getVectorId());
+			endMap.put(wallBean.getEnd(), wallBean.getVectorId());
+
+			swMap.put(segmentId, wallId);
+		}
+
+		Collection<PointBean> pointBeans = pointMap.values();
+		for (PointBean pointBean : pointBeans) {
+			Map<String, String> parent = new HashMap<>();
+			String startParent = startMap.get(pointBean.getVectorId());
+			String endParent = endMap.get(pointBean.getVectorId());
+			parent.put(startParent, "start");
+			parent.put(endParent, "end");
+			pointBean.setParent(parent);
+		}
+		JSONArray pointArr = JSON.parseArray(JSON.toJSONString(pointBeans));
+		result.put("pointArr", pointArr);
+
+		Collection<WallBean> wallBeans = wallMap.values();
+		JSONArray wallArr = JSON.parseArray(JSON.toJSONString(wallBeans));
+		result.put("wallArr", wallArr);
+
+		result.put("currentId", currentId);
+
+		return result;
+
+	}
+	
+	private static JSONArray readFloorJson(String filePath) {
+		try {
+			JSONObject floorplan = FileUtils.readJson(filePath);
+			JSONArray floors = floorplan.getJSONArray("floors");
+			return floors;
+		} catch (IOException e) {
+
+			return null;
+		}
+	}
+	
+}
+
+
+
+
+
+
+
+

4dkankan-utils-model/src/main/java/com/fdkankan/model/utils/SceneUtil.java

@@ -56,5 +56,20 @@ public class SceneUtil {
         return imageList;
     }
 
+    /**
+     * 根据dataSource获取原始资源目录
+     * @param dataSource
+     * @return
+     */
+    public static String getHomePath(String dataSource) {
+        String homePath = ConstantFilePath.OSS_PREFIX
+                + dataSource.replace(ConstantFilePath.BUILD_MODEL_PATH, "")
+                .replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "");
+        if (!homePath.endsWith("/")) {
+            homePath = homePath.concat("/");
+        }
+        return homePath;
+    }
+
 
 }

4dkankan-utils-redis/src/main/java/com/fdkankan/redis/config/RedissonConfig.java

@@ -0,0 +1,45 @@
+package com.fdkankan.redis.config;
+
+
+import org.apache.commons.lang3.StringUtils;
+import org.redisson.Redisson;
+import org.redisson.api.RedissonClient;
+import org.redisson.config.Config;
+import org.redisson.config.SingleServerConfig;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@AutoConfigureAfter(RedisAutoConfiguration.class)
+@ConditionalOnProperty(name = "spring.redis.bloom", havingValue = "true")
+public class RedissonConfig {
+
+    @Value("${spring.redis.host}")
+    private String host;
+
+    @Value("${spring.redis.port}")
+    private String port;
+
+    @Value("${spring.redis.database:0}")
+    private int database;
+
+    @Value("${spring.redis.password:#{null}}")
+    private String password;
+
+    @Bean
+    public RedissonClient redissonClient() {
+        Config config = new Config();
+        SingleServerConfig singleServerConfig = config.useSingleServer();
+        singleServerConfig.setAddress("redis://".concat(host).concat(":").concat(port));
+        if (StringUtils.isNotEmpty(password)) {
+            singleServerConfig.setPassword(password);
+        }
+        singleServerConfig.setDatabase(database);
+        return Redisson.create(config);
+
+    }
+}

4dkankan-utils-redis/src/main/java/com/fdkankan/redis/util/RedisBloomUtils.java

@@ -0,0 +1,35 @@
+package com.fdkankan.redis.util;
+
+import org.redisson.api.RBloomFilter;
+import org.redisson.api.RedissonClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConditionalOnProperty(name = "spring.redis.bloom", havingValue = "true")
+public class RedisBloomUtils {
+
+    @Autowired
+    private RedissonClient redissonClient;
+
+    public void add(String key,String value){
+        RBloomFilter<Object> bloomFilter = redissonClient.getBloomFilter(key);
+        bloomFilter.tryInit(500000,0.01);
+        bloomFilter.add(value);
+    }
+
+    public boolean contains(String key,String value){
+        RBloomFilter<Object> bloomFilter = redissonClient.getBloomFilter(key);
+        bloomFilter.tryInit(500000,0.01);
+        return bloomFilter.contains(value);
+    }
+
+    public void delete(String key){
+        RBloomFilter<Object> bloomFilter = redissonClient.getBloomFilter(key);
+        bloomFilter.tryInit(500000,0.01);
+        bloomFilter.delete();
+    }
+
+
+}