From c9ad330b7c17f3fdccb9fa0eb52d3afdce611004 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?LAPTOP-S9HJSOEB=5C=E6=98=8A=E5=A4=A9?= Date: Sat, 14 Sep 2024 10:30:45 +0800 Subject: [PATCH] =?UTF-8?q?1.=E8=AE=BE=E7=BD=AEhttp=E8=BF=9E=E6=8E=A5?= =?UTF-8?q?=E6=97=B6=E9=97=B4=202=E3=80=81=E8=AF=86=E5=88=AB3d=E6=8E=A5?= =?UTF-8?q?=E5=8F=A3=203=E3=80=81=E5=9B=BE=E7=89=87=E4=BD=8D=E7=BD=AE?= =?UTF-8?q?=E8=B0=83=E6=95=B4=204=E3=80=81=E4=BF=AE=E6=94=B9=E5=93=81?= =?UTF-8?q?=E8=A7=84=E5=90=8D=E7=A7=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../web/config/FusionDesignApplication.java | 4 +- .../IndustrialCameraController.java | 50 ++++++++- .../com/zhehekeji/web/lib/CameraConnMap.java | 7 +- .../lib/hik/HikCameraControlModuleImpl.java | 2 + .../web/pojo/IndustrialCameraVO.java | 2 + .../zhehekeji/web/service/InitService.java | 3 + .../com/zhehekeji/web/service/PlcService.java | 105 ++++++++---------- .../zhehekeji/web/service/StockService.java | 41 +++++-- .../service/algorithm/InventoryService.java | 81 +++++++++----- .../algorithm/PointCloudProcessor.java | 4 +- .../service/client/GetPhotoDelayExecutor.java | 3 +- .../web/service/ksec/KsecDataInfo.java | 2 + .../web/service/ksec/KsecDecoder.java | 3 + 13 files changed, 202 insertions(+), 105 deletions(-) diff --git a/web/src/main/java/com/zhehekeji/web/config/FusionDesignApplication.java b/web/src/main/java/com/zhehekeji/web/config/FusionDesignApplication.java index bb65011..075a8ed 100644 --- a/web/src/main/java/com/zhehekeji/web/config/FusionDesignApplication.java +++ b/web/src/main/java/com/zhehekeji/web/config/FusionDesignApplication.java @@ -24,8 +24,8 @@ public class FusionDesignApplication { // 使用RestTemplateBuilder来实例化RestTemplate对象，spring默认已经注入了RestTemplateBuilder实例 @Bean public RestTemplate restTemplate() { - return builder.setConnectTimeout(Duration.ofSeconds(10)) // 设置连接超时时间，单位毫秒 - .setReadTimeout(Duration.ofSeconds(10)) // 设置读取超时时间，单位毫秒 + return builder.setConnectTimeout(Duration.ofSeconds(20)) // 设置连接超时时间，单位毫秒 + .setReadTimeout(Duration.ofSeconds(20)) // 设置读取超时时间，单位毫秒 .build(); } } diff --git a/web/src/main/java/com/zhehekeji/web/controller/IndustrialCameraController.java b/web/src/main/java/com/zhehekeji/web/controller/IndustrialCameraController.java index 0c14d02..2249590 100644 --- a/web/src/main/java/com/zhehekeji/web/controller/IndustrialCameraController.java +++ b/web/src/main/java/com/zhehekeji/web/controller/IndustrialCameraController.java @@ -13,9 +13,12 @@ import com.zhehekeji.web.service.IndustrialCamera.LxPointCloudSaveImage; import com.zhehekeji.web.service.StreetService; import com.zhehekeji.web.service.algorithm.FeatureMatchingExample; import com.zhehekeji.web.service.algorithm.InventoryService; +import com.zhehekeji.web.service.algorithm.PcdPojo; +import com.zhehekeji.web.service.algorithm.PointCloudProcessor; import com.zhehekeji.web.service.client.TransmissionPojo; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation; +import lombok.extern.slf4j.Slf4j; import org.opencv.core.Mat; import org.opencv.imgcodecs.Imgcodecs; import org.springframework.web.bind.annotation.*; @@ -24,10 +27,13 @@ import javax.annotation.Resource; import java.io.IOException; import java.nio.file.*; import java.nio.file.attribute.BasicFileAttributes; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; import java.util.UUID; import static com.zhehekeji.web.service.algorithm.FeatureMatchingExample.base642Mat; +@Slf4j @Api(tags = "工业相机") @RequestMapping("/industrialCamera") @RestController @@ -76,7 +82,48 @@ public class IndustrialCameraController { @ApiOperation("识别3D") @PostMapping("Macth3D") public Result Macth3D(@RequestBody IndustrialCameraVO industrialCameraVo){ - return null; + Street street = streetService.getStreetByPlcId(industrialCameraVo.getStreetId()); + + LocalDate currentDate = LocalDate.now(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + //盘点地址 + String pcdPath1 =configProperties.getSavePath().getMediaPath() + street.getLeft3D()+ "/"+currentDate.format(formatter)+"/"+industrialCameraVo.getPcdPath()+".pcd"; + String pcdPath2 =configProperties.getSavePath().getMediaPath() + street.getRight3D()+ "/"+ currentDate.format(formatter)+"/"+industrialCameraVo.getPcdPath()+".pcd"; + //随行地址 + String pcdPath3 =configProperties.getSavePath().getMediaPath() + street.getLeft3D()+"/000/" + +"/"+industrialCameraVo.getPcdPath()+"-L"+".pcd"; + + String pcdPath4 =configProperties.getSavePath().getMediaPath() + street.getRight3D()+"/000/" + +"/"+industrialCameraVo.getPcdPath()+"-R"+".pcd"; + //拍照 + log.info("3D拍照 左侧pcd： "+street.getLeft3D()+" 右侧pcd：: "+pcdPath1); + + LxPointCloudSaveImage.saveImage(street.getLeft3D(), pcdPath1,1); + + LxPointCloudSaveImage.saveImage(street.getRight3D(), pcdPath2,2); + //左侧比较 + PcdPojo pojo = new PcdPojo(); + pojo.setPcd1(pcdPath1); + pojo.setPcd2(pcdPath3); + pojo.setConfigPath("D://config//3DConfig/"+street.getLeft3D()+".json"); + + double leftScore = PointCloudProcessor.similarity(pojo,10); + log.info("3D leftScore："+leftScore); + + //右侧比较 + pojo.setPcd1(pcdPath2); + pojo.setPcd2(pcdPath4); + pojo.setConfigPath("D://config//3DConfig/"+street.getRight3D()+".json"); + + double rightScore = PointCloudProcessor.similarity( pojo,10); + + log.info("3D rightScore："+rightScore); + if(leftScore<0.9||rightScore<0.9){ + + } + + return Result.success(leftScore +" "+ rightScore); + } @Resource @@ -106,7 +153,6 @@ public class IndustrialCameraController { +transmissionPojo.getRow()+"-"+transmissionPojo.getColumn()+"-"+transmissionPojo.getDirection()+"-R"+".pcd"; //拍照 System.out.println(street.getLeft3D()+" 111211 "+ pcdPath1); - System.out.println((System.getProperty("user.dir"))+"\\libs\\plc\\cameraapi"); LxPointCloudSaveImage lxPointCloudSaveImage = new LxPointCloudSaveImage(); lxPointCloudSaveImage.saveImage(street.getLeft3D(), pcdPath1,1); diff --git a/web/src/main/java/com/zhehekeji/web/lib/CameraConnMap.java b/web/src/main/java/com/zhehekeji/web/lib/CameraConnMap.java index 0700b29..c6b6e58 100644 --- a/web/src/main/java/com/zhehekeji/web/lib/CameraConnMap.java +++ b/web/src/main/java/com/zhehekeji/web/lib/CameraConnMap.java @@ -1,9 +1,11 @@ package com.zhehekeji.web.lib; +import com.zhehekeji.web.entity.Camera; import com.zhehekeji.web.lib.joyware.NetSDKLib; import java.util.HashMap; import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; /** * camera login handler @@ -14,13 +16,14 @@ public class CameraConnMap { * key :cameraId * value: loginId */ - public static Map cameraMap = new HashMap<>(); + public static Map cameraMap = new ConcurrentHashMap<>(); + public static Map cameraInfoMap = new ConcurrentHashMap<>(); /** * key:loginId * value: cameraId */ - public static Map loginMap = new HashMap<>(); + public static Map loginMap = new ConcurrentHashMap<>(); public static void conn(Integer cameraId,NetSDKLib.LLong handlerId){ synchronized (cameraId.toString().intern()){ diff --git a/web/src/main/java/com/zhehekeji/web/lib/hik/HikCameraControlModuleImpl.java b/web/src/main/java/com/zhehekeji/web/lib/hik/HikCameraControlModuleImpl.java index 260bec0..89959bb 100644 --- a/web/src/main/java/com/zhehekeji/web/lib/hik/HikCameraControlModuleImpl.java +++ b/web/src/main/java/com/zhehekeji/web/lib/hik/HikCameraControlModuleImpl.java @@ -20,6 +20,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Timer; +import static com.zhehekeji.web.lib.CameraConnMap.cameraInfoMap; import static com.zhehekeji.web.lib.hik.HCNetSDK.NET_DVR_GET_PTZPOS; /** @@ -42,6 +43,7 @@ public class HikCameraControlModuleImpl implements CameraControlModule { public boolean ptzControlUpStart(Integer cameraId, int nChannelID, int dwPTZCommand,int dwStop) { int lUserId = CameraConnMap.getConnId(cameraId).intValue(); + return HikLoginModuleImpl.hcNetsdk.NET_DVR_PTZControl_Other(lUserId, 1, HCNetSDK.TILT_UP, 0); } diff --git a/web/src/main/java/com/zhehekeji/web/pojo/IndustrialCameraVO.java b/web/src/main/java/com/zhehekeji/web/pojo/IndustrialCameraVO.java index 59fd036..50e6e29 100644 --- a/web/src/main/java/com/zhehekeji/web/pojo/IndustrialCameraVO.java +++ b/web/src/main/java/com/zhehekeji/web/pojo/IndustrialCameraVO.java @@ -10,6 +10,8 @@ public class IndustrialCameraVO { private String picImg; private String typeMacth; private List fileList; + private String pcdPath; + private String streetId; } diff --git a/web/src/main/java/com/zhehekeji/web/service/InitService.java b/web/src/main/java/com/zhehekeji/web/service/InitService.java index 6f2142e..dcf99fa 100644 --- a/web/src/main/java/com/zhehekeji/web/service/InitService.java +++ b/web/src/main/java/com/zhehekeji/web/service/InitService.java @@ -28,6 +28,8 @@ import javax.annotation.Resource; import java.util.HashMap; import java.util.List; +import static com.zhehekeji.web.lib.CameraConnMap.cameraInfoMap; + /** * 服务初始化 * 上位机、 plc、球机 连接 @@ -139,6 +141,7 @@ public class InitService implements ApplicationRunner { @Override public void run() { cameraService.cameraLogin(camera); + cameraInfoMap.put(camera.getId(),camera); } } diff --git a/web/src/main/java/com/zhehekeji/web/service/PlcService.java b/web/src/main/java/com/zhehekeji/web/service/PlcService.java index defddaa..55171b1 100644 --- a/web/src/main/java/com/zhehekeji/web/service/PlcService.java +++ b/web/src/main/java/com/zhehekeji/web/service/PlcService.java @@ -36,7 +36,9 @@ import javax.annotation.PostConstruct; import javax.annotation.Resource; import java.io.IOException; import java.time.Duration; +import java.time.LocalDate; import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; import java.util.HashSet; import java.util.List; import java.util.Set; @@ -342,11 +344,14 @@ public class PlcService { } catch (Exception e) { log.error("cameraId error:{}", cameraId); } + Boolean delay = true; + Integer row = 0; + Integer column = 0; + Integer sep = 0; + + long delayTime = 0; if (needCapture) { - Boolean delay = true; - Integer row = 0; - Integer column = 0; - Integer sep = 0; + if (times <= 2) { row = plcCmdInfo.getRow1(); column = plcCmdInfo.getColumn1(); @@ -356,7 +361,6 @@ public class PlcService { column = plcCmdInfo.getColumn2(); sep = plcCmdInfo.getSeparation2(); } - long delayTime = 0; if (code.startsWith("C1")) { @@ -367,26 +371,7 @@ public class PlcService { } else { delayTime = configProperties.getCameraConfig().getC2OutDelayCaptureTime(); } - try { - HttpHeaders headers = new HttpHeaders(); - headers.set("Content-Type", "application/json"); - headers.set("User-Agent", "Mozilla/5.0"); - - - TransmissionPojo scTransmission = new TransmissionPojo(street, plcCmdInfo.getRow2(), plcCmdInfo.getColumn2(), plcCmdInfo.getLeftRight2(), plcCmdInfo.getTaskId()); - // 创建 HttpEntity 对象 - HttpEntity entity = new HttpEntity<>(scTransmission, headers); - - // 发送 POST 请求 - ResponseEntity response = restTemplate.exchange( - "http://" + street.getPlcIp() + ":8099" + "/api/industrialCamera/actionType", - HttpMethod.POST, - entity, - Boolean.class - ); - } catch (Exception e) { - log.error("3D get pcd error", e); - } + } else if (code.startsWith("C3")) { delayTime = configProperties.getCameraConfig().getC3DelayCaptureTime(); @@ -415,6 +400,32 @@ public class PlcService { gyrateCameraByCodeTimeLater(street.getCamera1Id(), "C5", configProperties.getCameraConfig().getC2OutDelayCaptureTime() + 500); } } + if (code.startsWith("C2")) { + //延迟后拍照 + + try { + Thread.sleep(delayTime); + HttpHeaders headers = new HttpHeaders(); + headers.set("Content-Type", "application/json"); + headers.set("User-Agent", "Mozilla/5.0"); + + + TransmissionPojo scTransmission = new TransmissionPojo(street, plcCmdInfo.getRow2(), plcCmdInfo.getColumn2(), plcCmdInfo.getLeftRight2(), plcCmdInfo.getTaskId()); + // 创建 HttpEntity 对象 + HttpEntity entity = new HttpEntity<>(scTransmission, headers); + + // 发送 POST 请求 + ResponseEntity response = restTemplate.exchange( + "http://" + street.getPlcIp() + ":8099" + "/api/industrialCamera/actionType", + HttpMethod.POST, + entity, + Boolean.class + ); + } catch (Exception e) { + log.error("3D get pcd error", e); + } + + } } public void gyrateCamera(PlcCmdInfo plcCmdInfo, String code) { @@ -773,19 +784,19 @@ public class PlcService { } catch (ExecutionException e) { throw new RuntimeException(e); } - String path2D = "http://" + street.getPlcIp() + ":8099/api/" + + LocalDate currentDate = LocalDate.now(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + String path2D = "http://" + street.getPlcIp() + ":9007/api/pic/" + "industrialCamera/" + street.getPlcId() + "/" - + checkLog.getLotnum() + "/" - + checkLog.getId() + "/" - + checkLog.getRow() + "/" - + checkLog.getColumn() + "/" + + currentDate.format(formatter) + "/" + + checkLog.getRow() + "-" + + checkLog.getColumn() + "-" + checkLog.getDirection().toString() + "/"; //结果 String filePath = path2D + street.getIndustrialCamera() + ".jpeg"; OrderInfo orderInfo = new OrderInfo(street, plcCmdInfo, 1, cmdCode); - - Stock stock = stockMapper.getByStreetAndDirectionAndSideAndRowColumn(orderInfo.getStreetId(), plcCmdInfo.getLeftRight1(), orderInfo.getSeparation(), orderInfo.getRow(), orderInfo.getColumn()); String scanCode = null; //货物使用球机扫码 @@ -799,6 +810,8 @@ public class PlcService { } checkLog.setStatus(status); + Stock stock = stockMapper.getByStreetAndDirectionAndSideAndRowColumn(orderInfo.getStreetId(), plcCmdInfo.getLeftRight1(), orderInfo.getSeparation(), orderInfo.getRow(), orderInfo.getColumn()); + checkLogMapper.updateById(checkLog); if (stock == null) { stock = Stock.builder() @@ -816,9 +829,7 @@ public class PlcService { .status(status) .checkPic(path) .preoperationPic(filePath) - .statusVision(checkLog.getStatusVision()) - .count(checkLog.getCount()) - .category(checkLog.getCategory()) + .exportTime(LocalDateTime.now()).build(); stockMapper.insert(stock); } else { @@ -827,9 +838,6 @@ public class PlcService { stock.setExportTime(LocalDateTime.now()); stock.setCheckPic(path); - stock.setStatusVision(checkLog.getStatusVision()); - stock.setCount(checkLog.getCount()); - stock.setCategory(checkLog.getCategory()); stock.setCheckNum(plcCmdInfo.getOrderNum()); stock.setTrayCode(checkLog.getTrayCode()); stock.setWmsTrayCode(wmsTrayCode); @@ -927,27 +935,8 @@ public class PlcService { } } else if (type == 4) { TransmissionPojo transmissionPojo = new TransmissionPojo(checkLog, street); - if (ClientChanel.get(plcCmdInfo.getPlcId()) != null) { - ClientChanel.get(plcCmdInfo.getPlcId()).writeAndFlush(transmissionPojo.toString(TransmissionType.ST)); - } else { - log.error("未找到对应plc" + transmissionPojo.toString()); - } //取货完成进行拍照 - try { - Thread.sleep(50L); - //不为其他状态进入队列 - if (lock.tryLock()) { - - // - getPhotoDelayExecutor.communicationFactory(street.getPlcId(), transmissionPojo.toString(TransmissionType.GPS), configProperties.getQueueSpanTime(), transmissionPojo, checkLog); - } - - } catch (InterruptedException e) { - log.error("取图命令 error", e); - } finally { - lock.unlock(); - log.info("盘点完成"); - } + getPhotoDelayExecutor.communicationFactory(street.getPlcId(), transmissionPojo.toString(TransmissionType.GPS), configProperties.getQueueSpanTime(), transmissionPojo, checkLog); } if (checkLog.getTrayCode() != null && !"".equals(checkLog.getTrayCode())) { diff --git a/web/src/main/java/com/zhehekeji/web/service/StockService.java b/web/src/main/java/com/zhehekeji/web/service/StockService.java index a2e4d05..2e0ee85 100644 --- a/web/src/main/java/com/zhehekeji/web/service/StockService.java +++ b/web/src/main/java/com/zhehekeji/web/service/StockService.java @@ -26,7 +26,9 @@ import org.springframework.util.StringUtils; import org.springframework.web.multipart.MultipartFile; import javax.annotation.Resource; +import java.time.LocalDate; import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; import java.util.*; import java.util.stream.Collectors; @@ -408,21 +410,30 @@ public class StockService { Street street = streetMapper.selectById(stock.getStreetId()); stock.setStreetName(street.getName()); - List stockLogs = stockLogMapper.selectList(new QueryWrapper().eq("`row`", stockCheck.getRow()).eq("`column`", stockCheck.getColumn()).eq("street_id", stockCheck.getStreetId()).eq("direction", stockCheck.getDirection()).eq("side", stockCheck.getSide()).orderByDesc("create_time").last(" limit 2")); + LocalDate currentDate = LocalDate.now(); + + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + List stockLogs = stockLogMapper.selectList(new QueryWrapper() + .eq("`row`", stockCheck.getRow()) + .eq("`column`", stockCheck.getColumn()) + .eq("street_id", stockCheck.getStreetId()) + .eq("direction", stockCheck.getDirection()) + .eq("side", stockCheck.getSide()) + .orderByDesc("create_time") + .last(" limit 1")); if (stockLogs.size() == 1) { stock.setOveroperationPic(stockLogs.get(0).getPic()); - } else if (stockLogs.size() == 2) { - stock.setOveroperationPic(stockLogs.get(0).getPic()); } - String path2D = "http://" + street.getPlcIp() + ":8099/api/" + + currentDate =stock.getExportTime().toLocalDate(); + String path2D = "http://" + street.getPlcIp() + ":9007/api/pic/" + "industrialCamera/" + street.getPlcId() + "/" - + stock.getLotnum() + "/" - + stock.getId() + "/" - + stock.getRow() + "/" - + stock.getColumn() + "/" - + stock.getDirection().toString() + "/"; + + currentDate.format(formatter) + "/" + + stock.getRow() + "-" + + stock.getColumn() + "-" + + stock.getDirection().toString() + "-"; //结果 String filePath = path2D + street.getIndustrialCamera() + ".jpeg"; stock.setPreoperationPic(filePath); @@ -437,6 +448,18 @@ public class StockService { return stock; } + public static void main(String[] args) { + ; + + String currentDate = "2024-09-11 12:38:53"; + + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + // 解析字符串为 LocalDateTime + LocalDateTime dateTime = LocalDateTime.parse(currentDate, formatter); + System.out.println( dateTime.format(formatter1)); + } + public Stock nextOne(Long id) { QueryWrapper stockQueryWrapper = new QueryWrapper<>(); diff --git a/web/src/main/java/com/zhehekeji/web/service/algorithm/InventoryService.java b/web/src/main/java/com/zhehekeji/web/service/algorithm/InventoryService.java index 97444cc..382a257 100644 --- a/web/src/main/java/com/zhehekeji/web/service/algorithm/InventoryService.java +++ b/web/src/main/java/com/zhehekeji/web/service/algorithm/InventoryService.java @@ -4,8 +4,13 @@ import com.sun.jna.Library; import com.sun.jna.Native; import com.sun.jna.Platform; import com.zhehekeji.web.config.ConfigProperties; +import com.zhehekeji.web.entity.CheckLog; +import com.zhehekeji.web.entity.Stock; import com.zhehekeji.web.entity.Street; +import com.zhehekeji.web.mapper.CheckLogMapper; +import com.zhehekeji.web.mapper.StockMapper; import com.zhehekeji.web.pojo.InventoryInfo; +import com.zhehekeji.web.service.CheckLogService; import com.zhehekeji.web.service.IndustrialCamera.CameraSaveUtil; import com.zhehekeji.web.service.IndustrialCamera.LxPointCloudSaveImage; import com.zhehekeji.web.service.PlcService; @@ -29,6 +34,7 @@ import java.lang.reflect.Field; import java.nio.file.Files; import java.nio.file.Paths; import java.time.LocalDate; +import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.util.ArrayList; import java.util.List; @@ -48,22 +54,29 @@ public class InventoryService { @Resource ConfigProperties configProperties; + @Resource + CheckLogMapper checkLogMapper; + + @Resource + StockMapper stockMapper; @Resource PlcService plcService; public boolean matchFeatures(TransmissionPojo transmissionPojo){ Street street = streetService.getStreetByPlcId(transmissionPojo.getStreetNumber()); + + LocalDate currentDate = LocalDate.now(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); //路径 String path = configProperties.getSavePath().getMediaPath() +"industrialCamera/" +transmissionPojo.getStreetNumber()+"/" - +transmissionPojo.getTaskId()+"/" - +transmissionPojo.getCheckId()+"/" - +transmissionPojo.getRow()+"/" - +transmissionPojo.getColumn()+"/" - +transmissionPojo.getDirection()+"/"; + +currentDate.format(formatter)+"/" + +transmissionPojo.getRow()+"-" + +transmissionPojo.getColumn()+"-" + +transmissionPojo.getDirection()+"-"; //结果 transmissionPojo.setResult(1); //2d拍照并识别 @@ -83,21 +96,20 @@ public class InventoryService { log.info("未识别到任何模板"); } } - - LocalDate currentDate = LocalDate.now(); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); //3d拍照盘点 //盘点地址 String pcdPath1 =configProperties.getSavePath().getMediaPath() + street.getLeft3D()+ "/"+currentDate.format(formatter)+"/"+transmissionPojo.getCheckId()+".pcd"; String pcdPath2 =configProperties.getSavePath().getMediaPath() + street.getRight3D()+ "/"+ currentDate.format(formatter)+"/"+transmissionPojo.getCheckId()+".pcd"; //随行地址 - String pcdPath3 =configProperties.getSavePath().getMediaPath() + street.getLeft3D()+"/000/" - +"/"+transmissionPojo.getRow()+"-"+transmissionPojo.getColumn()+"-"+transmissionPojo.getDirection()+"-L"+".pcd"; + //随行地址 + String pcdPath3 =configProperties.getSavePath().getMediaPath() + street.getLeft3D()+"\\000\\" + +transmissionPojo.getRow()+"-"+transmissionPojo.getColumn()+"-"+transmissionPojo.getDirection()+"-L"+".pcd"; + + String pcdPath4 =configProperties.getSavePath().getMediaPath() + street.getRight3D()+"\\000\\" + +transmissionPojo.getRow()+"-"+transmissionPojo.getColumn()+"-"+transmissionPojo.getDirection()+"-R"+".pcd"; - String pcdPath4 =configProperties.getSavePath().getMediaPath() + street.getRight3D()+"/000/" - +"/"+transmissionPojo.getRow()+"-"+transmissionPojo.getColumn()+"-"+transmissionPojo.getDirection()+"-R"+".pcd"; //拍照 - log.info("3D拍照 左侧pcd： "+street.getLeft3D()+" 右侧pcd：: "+pcdPath1); + log.info("3D拍照 左侧pcd： "+pcdPath1+" 右侧pcd：: "+pcdPath2); LxPointCloudSaveImage.saveImage(street.getLeft3D(), pcdPath1,1); @@ -107,6 +119,7 @@ public class InventoryService { pojo.setPcd1(pcdPath1); pojo.setPcd2(pcdPath3); pojo.setConfigPath("D://config//3DConfig/"+street.getLeft3D()+".json"); + log.info("对比左侧："+pojo.toString()); double leftScore = PointCloudProcessor.similarity(pojo,10); log.info("3D leftScore："+leftScore); @@ -115,14 +128,39 @@ public class InventoryService { pojo.setPcd1(pcdPath2); pojo.setPcd2(pcdPath4); pojo.setConfigPath("D://config//3DConfig/"+street.getRight3D()+".json"); + log.info("对比右侧："+pojo.toString()); double rightScore = PointCloudProcessor.similarity( pojo,10); log.info("3D rightScore："+rightScore); - if(leftScore<0.9||rightScore<0.9){ + if(leftScore<0.87||rightScore<0.87){ transmissionPojo.setResult(0); } log.info("最终结果："+transmissionPojo.getResult()); + CheckLog checkLog = checkLogMapper.selectById(transmissionPojo.getCheckId()); + plcService.visualCalculationResults(transmissionPojo,checkLog); + + Stock stock = stockMapper.getByStreetAndDirectionAndSideAndRowColumn(street.getId(), transmissionPojo.getDirection(),1, transmissionPojo.getRow(), transmissionPojo.getColumn()); + + checkLogMapper.updateById(checkLog); + if (stock == null) { + stock = Stock.builder() + .streetId(street.getId()) + .row(transmissionPojo.getRow()) + .column(transmissionPojo.getColumn()) + .direction(transmissionPojo.getDirection()) + .side(1) + .statusVision(checkLog.getStatusVision()) + .count(checkLog.getCount()) + .category(checkLog.getCategory()) + .exportTime(LocalDateTime.now()).build(); + stockMapper.insert(stock); + } else { + stock.setStatusVision(checkLog.getStatusVision()); + stock.setCount(checkLog.getCount()); + stock.setCategory(checkLog.getCategory()); + stockMapper.updateById(stock); + } return !(transmissionPojo.getResult()==0); }; @@ -131,7 +169,6 @@ public class InventoryService { - /** * 获取文件类型 * @param folderPath @@ -161,21 +198,7 @@ public class InventoryService { } public static void main(String[] args) { - Mat template = null; - try { - template = base642Mat("data:image/png;base64,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".replace("data:image/jpeg;base64,","").replace("data:image/png;base64,","")); - - //Imgcodecs.imwrite("D:\\WeChet\\WeChat Files\\wxid_ttkf0xgmyihv22\\FileStorage\\File\\2024-09\\aa20c30.jpeg", template); - } catch (IOException e) { - throw new RuntimeException(e); - } - if(FeatureMatchingExample.matchTemplate( template, Imgcodecs.imread("D:\\WeChet\\WeChat Files\\wxid_ttkf0xgmyihv22\\FileStorage\\File\\2024-09\\aa20c309-7412-4392-88cd-aef08153f7c8 (2).jpeg"), "D:\\WeChet\\WeChat Files\\wxid_ttkf0xgmyihv22\\FileStorage\\File\\2024-09\\1.jpg")){ - //识别成功后之后识别根据结果图识别 - - - } - System.out.println("1111"); } } diff --git a/web/src/main/java/com/zhehekeji/web/service/algorithm/PointCloudProcessor.java b/web/src/main/java/com/zhehekeji/web/service/algorithm/PointCloudProcessor.java index 69c4330..e44c9e1 100644 --- a/web/src/main/java/com/zhehekeji/web/service/algorithm/PointCloudProcessor.java +++ b/web/src/main/java/com/zhehekeji/web/service/algorithm/PointCloudProcessor.java @@ -16,8 +16,8 @@ public class PointCloudProcessor { public static void main(String[] args) { PcdPojo pojo = new PcdPojo(); - pojo.setPcd1("E:\\127.pcd"); - pojo.setPcd2("E:\\1-8-2-R.pcd"); + pojo.setPcd1("D:\\WeChet\\WeChat Files\\wxid_ttkf0xgmyihv22\\FileStorage\\File\\2024-09\\8-6-2-L.pcd"); + pojo.setPcd2("D:\\WeChet\\WeChat Files\\wxid_ttkf0xgmyihv22\\FileStorage\\File\\2024-09\\369.pcd"); pojo.setConfigPath("E:\\D91FCF1FAB3568DB.json"); double i = similarity(pojo,10); System.out.println("111 "+i); diff --git a/web/src/main/java/com/zhehekeji/web/service/client/GetPhotoDelayExecutor.java b/web/src/main/java/com/zhehekeji/web/service/client/GetPhotoDelayExecutor.java index fecb3ff..999611f 100644 --- a/web/src/main/java/com/zhehekeji/web/service/client/GetPhotoDelayExecutor.java +++ b/web/src/main/java/com/zhehekeji/web/service/client/GetPhotoDelayExecutor.java @@ -41,8 +41,9 @@ public class GetPhotoDelayExecutor { //GetPhotoDelayExecutor.addCameraDelayTask( plcId, getPhotoCommand, time, transmissionPojo); //视觉 //保存数据 + log.info("视觉请求："+transmissionPojo.toString()); transmissionPojo = plcService.visualInventoryHttp(transmissionPojo); - plcService.visualCalculationResults(transmissionPojo,checkLog); + //plcService.visualCalculationResults(transmissionPojo,checkLog); //发送给上位机 KsecInfo ksecInfo = plcService.getKsecDataInfo(transmissionPojo,"E"); ksecInfo.getData().setTypeNum(transmissionPojo.getCategory()); diff --git a/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDataInfo.java b/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDataInfo.java index 0737b83..0b1a04d 100644 --- a/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDataInfo.java +++ b/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDataInfo.java @@ -42,6 +42,8 @@ public class KsecDataInfo { private String typeNum; + private String matid; + private Integer quantity; private Integer checkRlt; diff --git a/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDecoder.java b/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDecoder.java index 89cee46..09346a9 100644 --- a/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDecoder.java +++ b/web/src/main/java/com/zhehekeji/web/service/ksec/KsecDecoder.java @@ -100,6 +100,9 @@ public class KsecDecoder extends DelimiterBasedFrameDecoder { if(dataInfo.getToDirection()!=null){ dataInfo.setToDirection(dataInfo.getToDirection()==1?2:1); } + if(dataInfo.getMatid() != null){ + dataInfo.setTypeNum(dataInfo.getMatid()); + } LotnumConvert lotnumConvert = new LotnumConvert(dataInfo.getLotnum()); String lotnum = lotnumConvert.getLotnum(); dataInfo.setLotnum(lotnum);