/*
|
* Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
* Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
* Neither the name of the dreamlu.net developer nor the names of its
|
* contributors may be used to endorse or promote products derived from
|
* this software without specific prior written permission.
|
* Author: Chill 庄骞 (smallchill@163.com)
|
*/
|
package cn.gistack.sm.skPanorama.controller;
|
|
|
|
import cn.gistack.resource.entity.FormateTuEntity;
|
import cn.gistack.resource.entity.QieTuEntity;
|
import cn.gistack.resource.feign.IOssClient;
|
import cn.gistack.sm.skPanorama.entity.ParamEntity;
|
import cn.gistack.sm.skPanorama.entity.SkPicCountEntity;
|
import cn.gistack.sm.skPanorama.utils.Img4JavaUtil;
|
import cn.gistack.sm.skPanorama.utils.PanoramaUtilDict;
|
import cn.gistack.sm.skPanoramaState.entity.SkPanoramaStateEntity;
|
import cn.gistack.sm.skPanoramaState.service.ISkPanoramaStateService;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import io.swagger.annotations.ApiParam;
|
import lombok.AllArgsConstructor;
|
import javax.validation.Valid;
|
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.io.FileUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.im4java.core.IM4JavaException;
|
import org.im4java.core.InfoException;
|
import org.springblade.core.secure.BladeUser;
|
import org.springblade.core.mp.support.Condition;
|
import org.springblade.core.mp.support.Query;
|
import org.springblade.core.tool.api.R;
|
import org.springblade.core.tool.utils.Func;
|
import org.springblade.core.tool.utils.StringUtil;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
import org.springframework.web.bind.annotation.*;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import cn.gistack.sm.skPanorama.entity.SkPanoramaEntity;
|
import cn.gistack.sm.skPanorama.vo.SkPanoramaVO;
|
import cn.gistack.sm.skPanorama.wrapper.SkPanoramaWrapper;
|
import cn.gistack.sm.skPanorama.service.ISkPanoramaService;
|
import org.springblade.core.boot.ctrl.BladeController;
|
|
import java.io.*;
|
import java.lang.reflect.Field;
|
import java.net.URL;
|
import java.net.URLConnection;
|
import java.nio.file.Path;
|
import java.nio.file.Paths;
|
import java.util.*;
|
|
/**
|
* 水库全景图 控制器
|
*
|
* @author BladeX
|
* @since 2024-03-29
|
*/
|
//@RestController
|
//@AllArgsConstructor
|
//@RequestMapping("/skPanorama")
|
//@Api(value = "水库全景图", tags = "水库全景图接口")
|
|
@Slf4j
|
@Api(tags="全景")
|
@RestController
|
@RequestMapping("/skPanorama")
|
@AllArgsConstructor
|
public class SkPanoramaController extends BladeController {
|
|
private final ISkPanoramaService skPanoramaService;
|
|
private final ISkPanoramaStateService skPanoramaStateService;
|
/**
|
* 对象存储构建类
|
*/
|
@Autowired
|
private final IOssClient iOssClient;
|
|
|
/**
|
* 水库全景图 详情
|
*/
|
@GetMapping("/detail")
|
@ApiOperation(value = "详情", notes = "传入skPanorama")
|
public R<SkPanoramaVO> detail(SkPanoramaEntity skPanorama) {
|
SkPanoramaEntity detail = skPanoramaService.getOne(Condition.getQueryWrapper(skPanorama));
|
return R.data(SkPanoramaWrapper.build().entityVO(detail));
|
}
|
/**
|
* 水库全景图 分页
|
*/
|
@GetMapping("/list")
|
@ApiOperation(value = "分页", notes = "传入skPanorama")
|
public R<IPage<SkPanoramaVO>> list(SkPanoramaEntity skPanorama, Query query) {
|
QueryWrapper<SkPanoramaEntity> queryWrapper = Condition.getQueryWrapper(skPanorama);
|
queryWrapper.orderBy(true,false,"res_guid","sort" );
|
IPage<SkPanoramaEntity> pages = skPanoramaService.page(Condition.getPage(query), queryWrapper);
|
return R.data(SkPanoramaWrapper.build().pageVO(pages));
|
}
|
|
/**
|
* 水库全景图 自定义分页
|
*/
|
@GetMapping("/page")
|
@ApiOperation(value = "分页", notes = "传入skPanorama")
|
public R<IPage<SkPicCountEntity>> page(SkPicCountEntity skPanorama, Query query) {
|
Integer current = query.getCurrent();
|
Integer size = query.getSize();
|
IPage<SkPicCountEntity> page = Condition.getPage(query);
|
|
// System.err.println("current:"+current);
|
// System.err.println("size:"+size);
|
Integer startIndex = (current -1) * size;
|
Integer endIndex = current * size;
|
|
IPage<SkPicCountEntity> pages = skPanoramaService.selectPageR( page,startIndex, endIndex, skPanorama);
|
return R.data(pages);
|
}
|
|
// @GetMapping("/page")
|
// @ApiOperation(value = "分页", notes = "传入skPanorama")
|
// public R<IPage<SkPanoramaVO>> page2(SkPanoramaVO skPanorama, Query query) {
|
// IPage<SkPanoramaVO> pages = skPanoramaService.selectSkPanoramaPage(Condition.getPage(query), skPanorama);
|
// return R.data(pages);
|
// }
|
|
/**
|
* 水库全景图 新增
|
*/
|
@PostMapping("/save")
|
@ApiOperation(value = "新增", notes = "传入skPanorama")
|
public R save(@Valid @RequestBody SkPanoramaEntity skPanorama) {
|
return R.status(skPanoramaService.save(skPanorama));
|
}
|
|
|
/**
|
* 保存全景图的测站数据
|
* @param
|
* @return
|
*/
|
@PostMapping("/saveList")
|
@ApiOperation(value = "新增", notes = "传入skPanoramaState")
|
public R saveList(@Valid @RequestBody SkPanoramaEntity skPanorama) {
|
List<SkPanoramaStateEntity> stateLsit = skPanorama.getStateLsit();
|
List<SkPanoramaStateEntity> updateList = new ArrayList<>();
|
List<SkPanoramaStateEntity> addList = new ArrayList<>();
|
if (stateLsit != null && stateLsit.size()>0) {
|
|
boolean b =skPanoramaStateService.saveOrUpdateBatch(stateLsit);
|
|
return R.status(b);
|
}
|
return R.status(false);
|
}
|
|
|
/**
|
* 水库全景图 修改
|
*/
|
@PostMapping("/update")
|
@ApiOperation(value = "修改", notes = "传入skPanorama")
|
public R update(@Valid @RequestBody SkPanoramaEntity skPanorama) {
|
return R.status(skPanoramaService.updateById(skPanorama));
|
}
|
|
/**
|
* 水库全景图 新增或修改
|
*/
|
@PostMapping("/submit")
|
@ApiOperation(value = "新增或修改", notes = "传入skPanorama")
|
public R submit(@Valid @RequestBody SkPanoramaEntity skPanorama) {
|
if (skPanorama.getId() == null ) { // 新增
|
if (StringUtils.isBlank(skPanorama.getPicUrl())) {
|
skPanorama.setStatus(PanoramaUtilDict.panorama_status_0);
|
}
|
picIfFormate(skPanorama);
|
} else { // 修改
|
picIfFormate(skPanorama);
|
}
|
return R.status(skPanoramaService.saveOrUpdate(skPanorama));
|
}
|
|
private SkPanoramaEntity picIfFormate(SkPanoramaEntity skPanorama) {
|
Integer picwidth = skPanorama.getPicwidth();
|
Integer picheight = skPanorama.getPicheight();
|
if (picwidth == picheight * 2) {
|
skPanorama.setStatus(PanoramaUtilDict.panorama_status_2);
|
}
|
return skPanorama;
|
}
|
|
/**
|
* 水库全景图 删除
|
*/
|
@PostMapping("/remove")
|
@ApiOperation(value = "逻辑删除", notes = "传入ids")
|
public R remove(@ApiParam(value = "主键集合", required = true) @RequestParam String ids) {
|
return R.status(skPanoramaService.deleteLogic(Func.toLongList(ids)));
|
}
|
|
|
/**
|
* 根据水库id获取水库全景图片级水库测站
|
*/
|
@GetMapping("/getskAllInfo")
|
public R getSkPanoramaAllInfo(@RequestParam("resGuid")String resGuid) {
|
SkPanoramaEntity skPanoramaEntity = new SkPanoramaEntity();
|
skPanoramaEntity.setResGuid(resGuid);
|
List<SkPanoramaEntity> list = skPanoramaService.findList(skPanoramaEntity);
|
return R.data(list);
|
}
|
|
/**
|
* 全景图切图
|
* 等比例切图
|
* 长col：8
|
* 宽row：4
|
|
@GetMapping("/cutPicture")
|
public void cutPicture(SkPanoramaEntity skPanorama) throws IOException {
|
// 临时文件路径
|
String linShiBaseUrl = "/data/panorama/qietu/";
|
|
int col = 8;
|
int row = 4;
|
|
|
SkPanoramaEntity entity = skPanoramaService.getOne(Condition.getQueryWrapper(skPanorama));
|
String picUrl = entity.getPicUrl();
|
String picName = entity.getPicName();
|
String resGuid = entity.getResGuid();
|
String[] split = picName.split("\\.");
|
String picHeadName = split[0];
|
String picLastName = split[1];
|
|
|
HashMap<String, Integer> imgInfoRT = Img4JavaUtil.getImgInfoRT(picUrl);
|
|
Integer width = imgInfoRT.get("width");
|
Integer height = imgInfoRT.get("height");
|
// 计算切成小图的长和宽
|
Integer biliWidth = width/col;
|
Integer biliHeight = height/row;
|
|
for (int i=0 ; i < col ; i++) {
|
// 计算图片的横坐标（长边）
|
int x = i * biliWidth;
|
for (int j=0 ; j<row ; j++){
|
// 计算图片的纵坐标（宽边）
|
int y = j * biliHeight;
|
// 图片名
|
String outpicName = picHeadName + "_" + i + "_" +j + "." + picLastName;
|
// Img4JavaUtil.cropImg(picUrl,"C:/Users/kelu/Desktop/qietuTest/"+outpicName,biliWidth,biliHeight,x,y);
|
}
|
}
|
}
|
*/
|
|
/**
|
* 批量切图
|
* @param ids
|
* @return
|
* @throws IOException
|
* @throws InterruptedException
|
* @throws IM4JavaException
|
* @throws IllegalAccessException
|
*/
|
@PostMapping("/cutPicBatch")
|
public R cutPicBatch(@RequestParam String ids) throws IOException, InterruptedException, IM4JavaException, IllegalAccessException {
|
List<Long> idlist = Func.toLongList(ids);
|
if (idlist!= null && idlist.size()>0) {
|
for (Long id : idlist ) {
|
SkPanoramaEntity entity = skPanoramaService.getById(id);
|
Integer status = entity.getStatus();
|
String resGuname = entity.getResGuname();
|
String name = entity.getName();
|
if (PanoramaUtilDict.panorama_status_3 == status) continue;
|
R r = cutPicture2(entity);
|
boolean success = r.isSuccess();
|
if (!success) {
|
return R.fail(resGuname+"-"+name+" 切图失败！");
|
}
|
|
}
|
}
|
return R.status(true);
|
}
|
|
|
private static final String linShiBaseUrl = "/data/panorama/qietu/";
|
@GetMapping("/cutPicture2")
|
public R cutPicture2(SkPanoramaEntity skPanorama)
|
throws IOException, InterruptedException, IM4JavaException, IllegalAccessException {
|
|
SkPanoramaEntity entity = skPanoramaService.getById(skPanorama.getId());
|
String picUrl = entity.getPicUrl();
|
String picName = entity.getPicName();
|
String resGuid = entity.getResGuid();
|
|
// 获取文件名
|
String dirPath = linShiBaseUrl + resGuid + "/"; //临时文件夹路径
|
String lingshiPic = linShiBaseUrl + resGuid + "/" + picName; //临时文件
|
|
File lingshiqjfile = getquanjingFile(dirPath,lingshiPic,entity.getId());
|
|
/**
|
* 这里开始切图
|
*/
|
HashMap<String,String> qietuHashMap = new HashMap<String,String>();
|
int col = 4;
|
int row = 4;
|
String[] split = picName.split("\\.");
|
String picHeadName = split[0];
|
String picLastName = split[1];
|
|
// 获取原始全景图图片信息
|
HashMap<String, Integer> imgInfoRT = Img4JavaUtil.getImgInfoRT(lingshiqjfile);
|
Integer width = imgInfoRT.get("width");
|
Integer height = imgInfoRT.get("height");
|
// 计算切成小图的长和宽
|
Integer biliWidth = width/col;
|
Integer biliHeight = height/row;
|
|
for (int i=0 ; i < col ; i++) {
|
// 计算图片的横坐标（长边）
|
int x = i * biliWidth;
|
for (int j=0 ; j<row ; j++){
|
// 计算图片的纵坐标（宽边）
|
int y = j * biliHeight;
|
// 切图名称
|
String outpicName = picHeadName + "_" + i + "_" +j + "." + picLastName;
|
// 切图后临时图片的的路径
|
String lastiUrl = dirPath + outpicName;
|
Img4JavaUtil.cropImg(picUrl ,lastiUrl ,biliWidth,biliHeight,x,y);// 切图存放进临时图片中
|
qietuHashMap.put(outpicName,lastiUrl);
|
|
// System.err.println(lastiUrl);
|
}
|
}
|
|
// 切图完成后删除原始全景图
|
if (lingshiqjfile.exists()) {
|
// 删除指定文件，不存在报异常
|
FileUtils.forceDelete(lingshiqjfile);
|
}
|
|
/************************************切图结束********************************************/
|
|
// 上传切片全景图
|
|
QieTuEntity qieTuEntity = new QieTuEntity();
|
qieTuEntity.setQietuHashMap(qietuHashMap);
|
qieTuEntity.setResGuid(resGuid);
|
R r = iOssClient.uploadQietu(qieTuEntity);
|
|
Object data = r.getData();
|
QieTuEntity result = JSONObject.parseObject(JSONObject.toJSONString(data),QieTuEntity.class);
|
HashMap<String, String> resultMap = result.getQietuHashMap();
|
|
|
String qturlList = resultMap.get("qturlList");
|
String urlHead = resultMap.get("urlHead");
|
|
|
entity.setQietuurllist(qturlList);
|
entity.setUrlhead(urlHead);
|
entity.setQierow(row);
|
entity.setQiecol(col);
|
// entity.setPicwidth(width);
|
// entity.setPicheight(height);
|
entity.setStatus(PanoramaUtilDict.panorama_status_3);
|
boolean b = skPanoramaService.updateById(entity);
|
|
|
return R.status(b);
|
}
|
|
private File getquanjingFile (String dirPath ,String linshiUrl , Long id) throws IOException {
|
|
// SkPanoramaEntity entity = skPanoramaService.getOne(Condition.getQueryWrapper(skPanorama));
|
SkPanoramaEntity entity = skPanoramaService.getById(id);
|
String picUrl = entity.getPicUrl();
|
String picName = entity.getPicName();
|
String resGuid = entity.getResGuid();
|
|
File dir = new File(dirPath);
|
if (dir.isDirectory()) {
|
// 清除该目录下的文件及子目录文件而不删除该目录文件夹。该目录不存在会报错
|
// FileUtils.cleanDirectory(dir);
|
} else {
|
dir.mkdirs();
|
}
|
// 线上全景图路径,下载到临时路径
|
URL url = new URL(picUrl);
|
InputStream inputStream = url.openStream();
|
OutputStream outputStream = new FileOutputStream(linshiUrl);
|
byte[] buffer = new byte[4096];
|
int bytesRead;
|
while ((bytesRead = inputStream.read(buffer)) != -1) {
|
outputStream.write(buffer, 0, bytesRead);
|
}
|
inputStream.close();
|
outputStream.close();
|
|
Path lingshiqjPath = Paths.get(linshiUrl);
|
File lingshiqjfile = lingshiqjPath.toFile(); // 获取临时全景文件
|
return lingshiqjfile;
|
}
|
|
|
/**
|
* 图片格式化
|
* 将图片转化为长宽比为2:1的比例
|
*/
|
private static final String linShiformateBaseUrl = "/data/panorama/formate/";
|
@PostMapping("/formatePic")
|
public R formatePic(@RequestParam String ids) throws IOException, InterruptedException, IM4JavaException {
|
System.err.println(ids);
|
|
List<Long> idlist = Func.toLongList(ids);
|
|
|
ArrayList<SkPanoramaEntity> panoramalist = new ArrayList<SkPanoramaEntity>();
|
|
// 已上传的全景图已符合比例，仅用改变数据状态
|
ArrayList<SkPanoramaEntity> justUpdateStatusList = new ArrayList<SkPanoramaEntity>();
|
|
ArrayList<FormateTuEntity> list = new ArrayList<FormateTuEntity>();
|
|
|
if (idlist!= null && idlist.size()>0) {
|
for (Long id : idlist ) {
|
FormateTuEntity formateTuEntity = new FormateTuEntity();
|
|
|
SkPanoramaEntity entity = skPanoramaService.getById(id);
|
Integer status = entity.getStatus();
|
if (PanoramaUtilDict.panorama_status_2 == status) continue;
|
String picUrl = entity.getPicUrl();
|
String picName = entity.getPicName();
|
String resGuid = entity.getResGuid();
|
|
// 获取文件名
|
String dirPath = linShiformateBaseUrl + resGuid + "/"; //临时文件夹路径
|
String lingshiPic = linShiformateBaseUrl + resGuid + "/" + picName; //临时文件
|
|
String lingshigeshibilipath = linShiformateBaseUrl + resGuid + "/geshibili/" ;
|
String lingshigeshibiliPic = lingshigeshibilipath + picName; //格式化后的临时文件
|
|
File lingshiqjfile = getquanjingFile(dirPath,lingshiPic,id);
|
|
// 创建文件夹
|
File lingshigeshibilidir = new File(lingshigeshibilipath);
|
if (lingshigeshibilidir.isDirectory()) {
|
// 清除该目录下的文件及子目录文件而不删除该目录文件夹。该目录不存在会报错
|
// FileUtils.cleanDirectory(lingshigeshibilidir);
|
// 批量操作不能清空文件夹下的全部文件
|
} else {
|
lingshigeshibilidir.mkdirs();
|
}
|
|
/**************进行格式化******************/
|
// 获取原始全景图图片信息
|
HashMap<String, Integer> imgInfoRT = Img4JavaUtil.getImgInfoRT(lingshiqjfile);
|
Integer width = imgInfoRT.get("width");
|
Integer height = imgInfoRT.get("height");
|
System.err.println(id);
|
System.err.println("图片分辨率："+ width +" * " + height);
|
if (width == height * 2) {
|
System.err.println("符合标准");
|
// 已经符合格式化标准
|
SkPanoramaEntity upEntity = new SkPanoramaEntity();
|
upEntity.setId(id);
|
upEntity.setPicheight(height);
|
upEntity.setPicwidth(width);
|
upEntity.setStatus(PanoramaUtilDict.panorama_status_2);
|
justUpdateStatusList.add(upEntity);
|
|
// 完成格式化后删除原始临时图片
|
Path qietuPath = Paths.get(lingshiPic);
|
File yuanspic = qietuPath.toFile();
|
if (yuanspic.exists()) {
|
// 删除指定文件，不存在报异常
|
FileUtils.forceDelete(yuanspic);
|
}
|
// boolean b = skPanoramaService.updateById(upEntity);
|
// return R.status( b);
|
} else {
|
Integer newWidth = height * 2;
|
// 图片格式化
|
Img4JavaUtil.sampleImg(lingshiPic,lingshigeshibiliPic, newWidth , height,null);
|
|
Path lingshiformPath = Paths.get(lingshigeshibiliPic);
|
File lingshiformFile = lingshiformPath.toFile(); // 获取临时全景文件
|
if(lingshiformFile.exists()) {
|
formateTuEntity.setPicName(picName);
|
formateTuEntity.setId(Long.toString(id));
|
formateTuEntity.setResGuid(resGuid);
|
formateTuEntity.setLinshiUrl(lingshigeshibiliPic);
|
formateTuEntity.setPicheight(height);
|
formateTuEntity.setPicwidth(newWidth);
|
list.add(formateTuEntity);
|
}
|
// 完成格式化后删除原始临时图片
|
Path qietuPath = Paths.get(lingshiPic);
|
File yuanspic = qietuPath.toFile();
|
if (yuanspic.exists()) {
|
// 删除指定文件，不存在报异常
|
FileUtils.forceDelete(yuanspic);
|
}
|
|
}
|
|
} // for循环结束
|
QieTuEntity qieTuEntity = new QieTuEntity();
|
qieTuEntity.setList(list);
|
|
R r = iOssClient.uploadFormate(qieTuEntity);
|
Object data = r.getData();
|
QieTuEntity result = JSONObject.parseObject(JSONObject.toJSONString(data),QieTuEntity.class);
|
ArrayList<FormateTuEntity> newList = result.getList();
|
|
if (newList != null && newList.size()>0) {
|
for (FormateTuEntity item : newList) {
|
SkPanoramaEntity skPanoramaEntity = new SkPanoramaEntity();
|
String id = item.getId();
|
String linshiUrl = item.getLinshiUrl();// 格式化后图片路径
|
Integer picheight = item.getPicheight();
|
Integer picwidth = item.getPicwidth();
|
skPanoramaEntity.setId(Long.valueOf(id));
|
skPanoramaEntity.setPicUrl(linshiUrl);
|
skPanoramaEntity.setPicheight(picheight);
|
skPanoramaEntity.setPicwidth(picwidth);
|
skPanoramaEntity.setStatus(PanoramaUtilDict.panorama_status_2);
|
panoramalist.add(skPanoramaEntity);
|
}
|
}
|
}
|
|
|
System.err.println("panoramalist:"+panoramalist.size());
|
boolean b = false;
|
if (panoramalist != null && panoramalist.size()>0) {
|
b = skPanoramaService.updateBatchById(panoramalist);
|
} else {
|
b = true;
|
}
|
System.err.println("justUpdateStatusList:"+justUpdateStatusList.size());
|
boolean formatB = false;
|
// 已上传的全景图已符合比例，仅用改变数据状态
|
if (justUpdateStatusList != null && justUpdateStatusList.size()>0) {
|
formatB = skPanoramaService.updateBatchById(justUpdateStatusList);
|
} else {
|
formatB = true;
|
}
|
|
|
return R.status((formatB && b));
|
}
|
|
|
|
}
|
