4dkankan-center-modeling-control/src/main/java/com/fdkankan/contro/mq/service/impl/BuildObjServiceImpl.java

package com.fdkankan.contro.mq.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fdkankan.common.constant.CommonStatus;
import com.fdkankan.common.constant.ModelKind;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.contro.entity.ScenePlus;
import com.fdkankan.contro.entity.ScenePro;
import com.fdkankan.contro.entity.SceneProEdit;
import com.fdkankan.contro.mq.service.IBuildSceneService;
import com.fdkankan.contro.service.*;
import com.fdkankan.contro.service.impl.FdkkV4Service;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.model.constants.ConstantFileName;
import com.fdkankan.model.constants.ConstantFilePath;
import com.fdkankan.model.constants.UploadFilePath;
import com.fdkankan.model.utils.CreateObjUtil;
import com.fdkankan.rabbitmq.bean.BuildSceneCallMessage;
import com.fdkankan.rabbitmq.bean.BuildSceneResultMqMessage;
import com.fdkankan.rabbitmq.util.RabbitMqProducer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.io.File;
import java.util.List;
import java.util.Objects;

/**
 * <p>
 * TODO
 * </p>
 *
 * @author dengsixing
 * @since 2022/3/1
 **/
@Slf4j
@Service
public class BuildObjServiceImpl implements IBuildSceneService {

    @Value("${queue.modeling.modeling-call}")
    private String queueModelingCall;

    @Value("${queue.modeling.obj.modeling-post}")
    private String queueObjModelingPost;

    @Value("${model.modelKind:3dtiles}")
    private String modelKind;

    @Autowired
    private RabbitMqProducer mqProducer;

    @Autowired
    private FYunFileServiceInterface fYunFileService;

    @Autowired
    private ISceneProService sceneProService;

    @Autowired
    private IFdkkLaserService fdkkLaserService;

    @Autowired
    private FdkkV4Service fdkkV4Service;

    @Autowired
    private IBuildSceneDTService buildSceneDTService;

    @Autowired
    private ISceneProEditService sceneProEditService;


    @Autowired
    private IScenePlusService scenePlusService;

    @Override
    public void buildScenePre(BuildSceneCallMessage message) {
        boolean success = false;
        try {
            String path = message.getPath();
            //根据相机类型，组装资源路径
            String laserObjFilePath = path + "_laser_obj";
            log.info("开始准备生成OBJ场景资源,路径：{}", laserObjFilePath);

            FileUtils.delAllFile(laserObjFilePath);

            //获取解压后的资源的data.fdage中的数据
            File folderPath = new File(path);
            fYunFileService.downloadFile(ConstantFilePath.OSS_PREFIX + path.replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "") + "/data.fdage", path + "/capture/data.fdage");
            JSONObject jsonObject = FileUtils.readJson(folderPath.getAbsolutePath() + File.separator + "capture" + File.separator + "data.fdage");
            if(ObjectUtils.isEmpty(jsonObject)){
                log.error("data.fdage文件不存在");
                return ;
            }
            if (!jsonObject.containsKey("exportMeshObj") || jsonObject.getIntValue("exportMeshObj") != 1) {
                // 写入data.fdage 防止重算
                jsonObject.put("exportMeshObj", 1);
                FileUtils.writeFile(folderPath.getAbsolutePath() + File.separator + "capture" + File.separator + "data.fdage", jsonObject.toJSONString());
                fYunFileService.uploadFile(folderPath.getAbsolutePath() + File.separator + "capture" + File.separator + "data.fdage",
                        ConstantFilePath.OSS_PREFIX + path.replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "") + "/data.fdage");
            }
            // 重新构造datafdage文件,添加生成obt文件选项
            jsonObject.put("OnlyExportMeshObj",true);
            FileUtils.writeFile(laserObjFilePath + File.separator + "capture" + File.separator + "data.fdage", jsonObject.toJSONString());

            message.getBuildContext().put("previousPath",path);
            message.setCameraType("14");
            message.setResolution(jsonObject.getString("resolution"));
            message.setPath(laserObjFilePath);
            message.setResultReceiverMqName(queueObjModelingPost);

            //下载资源到本地
            this.downLoadSource(message, laserObjFilePath);

            //发送mq，就进行计算
            mqProducer.sendByWorkQueue(queueModelingCall, message);

            success = true;

            log.info("场景计算资源准备结束，场景码：{}", message.getSceneNum());

        }catch (Exception e){
            log.error("场景计算前置处理出错", e);
        }finally {
            //如果前置处理失败，发送钉钉消息
            if(!success){
                buildSceneDTService.handBaseFail("生成OBJ场景资源准备异常", message.getPath(), message.getSceneNum(), "计算控制服务器");
            }

        }
    }

    @Override
    public void downLoadSource(BuildSceneCallMessage message,String path) throws Exception{

        String prevoisPath = message.getBuildContext().get("previousPath").toString();
        FileUtils.copyFile(prevoisPath + "/caches/reconstruction/final.bin", path + "/caches/reconstruction/final.bin", true);
        FileUtils.copyFile(prevoisPath + "/caches/reconstruction/chunk.json", path + "/caches/reconstruction/chunk.json", true);
        FileUtils.copyFile(prevoisPath + "/caches/floor_group_fix.json", path + "/caches/floor_group_fix.json", true);
        FileUtils.copyDirectiory(prevoisPath + "/caches/images", path + "/caches/images");

        FileUtils.copyDirectiory(prevoisPath + "/caches/depthmap_csc", path + "/caches/depthmap_csc");
        FileUtils.copyDirectiory(prevoisPath + "/caches/depthmap_vis", path + "/caches/depthmap_vis");
        FileUtils.copyDirectiory(prevoisPath + "/caches/depthmap", path + "/caches/depthmap");
        FileUtils.copyFile(prevoisPath + "/caches/panorama.json", path + "/caches/panorama.json", true);
        FileUtils.copyFile(prevoisPath + "/results/laserData/laser.ply", path + "/results/laserData/laser.ply", true);
    }

    @Override
    public void buildScenePost(BuildSceneResultMqMessage message) throws Exception {

        if (!message.getBuildSuccess()) {
            log.error("生成OBJ场景计算失败！");
            // 发送钉钉消息，计算失败
            buildSceneDTService.handModelFail("生成OBJ场景计算失败！", message.getPath(), message.getBuildContext().get("sceneNum").toString(), message.getHostName());
            return;
        }

        String path = message.getPath();
        String laserObjFilePath = path;
        String projectNum = message.getBuildContext().get("sceneNum").toString();
        ScenePro scenePro = sceneProService.getByNum(projectNum);
        String version = "v4";
        String ossImagePath = String.format(UploadFilePath.IMG_VIEW_PATH,  projectNum);
        //如果是微服务上线之前的存量场景且未生成过obj（未升级过），需要上传到v3的目录，在函数最后调用升级接口进行文件拷贝
        if(Objects.nonNull(scenePro) && scenePro.getIsUpgrade() != CommonStatus.YES.code().intValue()){
            ossImagePath = String.format(ConstantFilePath.IMAGE_PATH_FORMAT, projectNum);
            version = "v3";
        }
        //上传obj
        String resultsPath = path + File.separator + "results" + File.separator;
        if(this.modelKind.equals(ModelKind.DAM.code())){
            CreateObjUtil.convertTxtToDam(path + File.separator + "results" + File.separator + "tex" + File.separator + "modeldata.txt", path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam");
            CreateObjUtil.convertDamToLzma(path + File.separator + "results/");
            CreateObjUtil.convertTxtToDam(path + File.separator + "results" + File.separator + "tex" + File.separator + "modeldata.txt", path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam");
            File file = new File(path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam.lzma");
            while (!file.exists()) {
                Thread.sleep(60000);
            }
            fYunFileService.uploadFile(path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam.lzma", ossImagePath + ConstantFileName.modelUUID + "_50k.dam.lzma");
            fYunFileService.uploadFile(path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam", ossImagePath + ConstantFileName.modelUUID + "_50k.dam");
        }
        if(this.modelKind.equals(ModelKind.THREE_D_TILE.code())){
            String threedtilesPath = resultsPath + ModelKind.THREE_D_TILE.code();
            String oss3dtilesPath = ossImagePath + ModelKind.THREE_D_TILE.code();
            List<String> list = FileUtils.list(new File(threedtilesPath));
            if(CollUtil.isEmpty(list)){
                log.error("3dtiles目录异常，3dtiles地址：{}", new File(path + File.separator + "results" + File.separator + ModelKind.THREE_D_TILE.code()));
                throw new Exception("3dtiles目录异常");
            }
            //上传3dtiles文件
            fYunFileService.uploadFileByCommand(threedtilesPath, oss3dtilesPath);
        }

        String texPath = laserObjFilePath + File.separator + "results" + File.separator + "tex";

        File texFile = new File(texPath);
        if(texFile.exists()){
            for (File textureFile : texFile.listFiles()) {
                if(textureFile.getName().endsWith(".jpg")){
                    fYunFileService.uploadFile(textureFile.getAbsolutePath(),
                        ossImagePath + ConstantFileName.modelUUID + "_50k_texture_jpg_high1/"+textureFile.getName());
                }
            }
        }

        fYunFileService.uploadFile(laserObjFilePath + File.separator + "results" + File.separator + "tex/texture1.jpg",
                ossImagePath + ConstantFileName.modelUUID + "_50k_texture_jpg_high1/texture1.jpg");

        // 拷贝结果
        log.info("开始拷贝obj文件");
        FileUtils.copyFolderAllFiles(laserObjFilePath + "/results/mesh", laserObjFilePath + "/laserData/mesh/", true);

        //上传mesh文件
        fYunFileService.uploadFileByCommand(laserObjFilePath + "/results/mesh", String.format(UploadFilePath.DATA_VIEW_PATH,  projectNum) + "mesh");

        fdkkLaserService.pushBuildStatusToLaserSystem(projectNum, laserObjFilePath + "/laserData/mesh");


        if(!ObjectUtils.isEmpty(scenePro)){
            LambdaUpdateWrapper<ScenePro> updateWrapper = new LambdaUpdateWrapper<ScenePro>()
                    .set(ScenePro::getStatus, -2).eq(ScenePro::getNum, projectNum);
            sceneProService.update(updateWrapper);
            sceneProEditService.update(new LambdaUpdateWrapper<SceneProEdit>().set(SceneProEdit::getMapVisi,0)
                    .eq(SceneProEdit::getProId,scenePro.getId()));
        }

        ScenePlus scenePlus = scenePlusService.getScenePlusByNum(projectNum);
        if(!ObjectUtils.isEmpty(scenePlus)){
            LambdaUpdateWrapper<ScenePlus> plusUpdateWrapper = new LambdaUpdateWrapper<ScenePlus>()
                    .set(ScenePlus::getSceneStatus, -2).eq(ScenePlus::getNum, projectNum);
            scenePlusService.update(plusUpdateWrapper);
        }

        // 如果未升级V4,则升级V4
        if("v3".equals(version)){
            fdkkV4Service.upgradeToV4(projectNum);
        }
    }

}