3344 lines
182 KiB
Java
3344 lines
182 KiB
Java
package com.ai.da.python;
|
||
|
||
import cn.hutool.core.collection.CollectionUtil;
|
||
import cn.hutool.core.exceptions.ExceptionUtil;
|
||
import com.ai.da.common.config.FileProperties;
|
||
import com.ai.da.common.config.exception.BusinessException;
|
||
import com.ai.da.common.enums.*;
|
||
import com.ai.da.common.utils.*;
|
||
import com.ai.da.mapper.primary.CollocationMapper;
|
||
import com.ai.da.mapper.primary.DressingMapper;
|
||
import com.ai.da.mapper.primary.entity.*;
|
||
import com.ai.da.mapper.secondary.AttributeRetrievalMapper;
|
||
import com.ai.da.mapper.secondary.entity.AttributeRetrieval;
|
||
import com.ai.da.mapper.secondary.entity.AttributeRecognitionJSON;
|
||
import com.ai.da.model.dto.*;
|
||
import com.ai.da.model.enums.MalePosition;
|
||
import com.ai.da.model.enums.Sex;
|
||
import com.ai.da.model.vo.*;
|
||
import com.ai.da.python.vo.*;
|
||
import com.ai.da.service.DesignHistoryService;
|
||
import com.ai.da.service.PythonTAllInfoService;
|
||
import com.ai.da.service.SysFileService;
|
||
import com.alibaba.fastjson.JSON;
|
||
import com.alibaba.fastjson.JSONArray;
|
||
import com.alibaba.fastjson.JSONException;
|
||
import com.alibaba.fastjson.JSONObject;
|
||
import com.alibaba.fastjson.serializer.SerializerFeature;
|
||
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
||
import com.google.common.collect.Lists;
|
||
import com.google.common.collect.Maps;
|
||
import io.netty.util.internal.StringUtil;
|
||
import lombok.extern.slf4j.Slf4j;
|
||
import okhttp3.*;
|
||
import org.springframework.beans.factory.annotation.Value;
|
||
import org.springframework.stereotype.Service;
|
||
import org.springframework.transaction.annotation.Transactional;
|
||
import org.springframework.util.Assert;
|
||
import org.springframework.util.CollectionUtils;
|
||
import org.springframework.util.StringUtils;
|
||
import org.springframework.web.multipart.MultipartFile;
|
||
|
||
import javax.annotation.Resource;
|
||
import java.io.File;
|
||
import java.io.IOException;
|
||
import java.math.BigDecimal;
|
||
import java.math.RoundingMode;
|
||
import java.net.HttpURLConnection;
|
||
import java.util.*;
|
||
import java.util.concurrent.TimeUnit;
|
||
import java.util.stream.Collectors;
|
||
|
||
@Slf4j
|
||
@Service
|
||
public class PythonService {
|
||
|
||
@Resource
|
||
private FileProperties fileProperties;
|
||
@Resource
|
||
private SysFileService sysFileService;
|
||
@Resource
|
||
private DesignHistoryService designHistoryService;
|
||
@Value("${access.python.ip:''}")
|
||
private String accessPythonIp;
|
||
@Value("${access.python.port:''}")
|
||
private String accessPythonPort;
|
||
@Value("${access.python.address}")
|
||
private String fastApiPythonAddress;
|
||
@Value("${minio.bucketName.gradient}")
|
||
private String gradientBucketName;
|
||
|
||
@Resource
|
||
private PythonTAllInfoService pythonTAllInfoService;
|
||
|
||
@Resource
|
||
private MinioUtil minioUtil;
|
||
|
||
/**
|
||
* 生成打印的图片 二合一 (废弃于2024/01/02)
|
||
*
|
||
* @param printPath
|
||
* @return
|
||
*/
|
||
public String generatePrint(List<String> printPath, Long userId) {
|
||
//限流校验
|
||
// AccessLimitUtils.validate("generatePrint", 2);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
Map<String, String> content = Maps.newHashMap();
|
||
content.put("fusion_content_path", printPath.get(0));
|
||
content.put("fusion_style_path", printPath.get(1));
|
||
content.put("userid", String.valueOf(userId));
|
||
// content.put("fusion_output_path", getPythonOutputPath(
|
||
// printPath.get(0), PythonToJavaApiOperationTypeEnum.GENERATE_PRINT));
|
||
RequestBody body = RequestBody.create(mediaType, JSON.toJSONString(content));
|
||
Request request = new Request.Builder()
|
||
// .url(accessPythonIp + ":9999/aifda/api/v1.0/fusion_test")
|
||
.url(accessPythonIp + ":" + accessPythonPort + "/api/image_fusion")
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response;
|
||
String responseBody;
|
||
try {
|
||
log.info("moodboard与printboard图片合成 入参content###{}", JSON.toJSONString(content));
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService## moodboard与printboard图片合成异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
throw new BusinessException("image.synthesis.failed");
|
||
}
|
||
//去除限流
|
||
// AccessLimitUtils.validateOut("generatePrint");
|
||
JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(response));
|
||
if (jsonObject.getBoolean("successful")) {
|
||
try {
|
||
if (Objects.nonNull(response.body())) {
|
||
responseBody = response.body().string();
|
||
JSONObject responseObj = JSON.parseObject(responseBody);
|
||
log.info("moodboard与printboard图片合成 python返回###{}", responseObj);
|
||
return responseObj.get("data").toString();
|
||
}
|
||
} catch (IOException | JSONException e) {
|
||
log.error("Python moodboard与printboard图片合成异常 ： {}", e.getMessage());
|
||
throw new BusinessException("image.synthesis.failed");
|
||
}
|
||
log.error("moodboard与printboard图片合成异常###{}", jsonObject);
|
||
throw new BusinessException("image.synthesis.failed");
|
||
// return content.get("fusion_output_path");
|
||
}
|
||
log.info("moodboard与printboard图片合成异常###{}", jsonObject);
|
||
//生成失败
|
||
throw new BusinessException("image.synthesis.failed");
|
||
}
|
||
|
||
/**
|
||
* 生成python要保存的文件
|
||
*
|
||
* @param picturePath
|
||
* @return
|
||
*/
|
||
private String getPythonOutputPath(String picturePath, PythonToJavaApiOperationTypeEnum pythonOperationType) {
|
||
String linuxDomain = fileProperties.getLinuxDomain();
|
||
String day = DateUtil.dateToStr(new Date(), DateUtil.YYYYMM);
|
||
//获取图片后缀
|
||
String suffix = picturePath.substring(picturePath.lastIndexOf("."));
|
||
String generateFileName = pythonOperationType.getRealName()
|
||
+ "-" + UUID.randomUUID().toString() + suffix;
|
||
return linuxDomain + day + File.separator + "pythonFile" + File.separator
|
||
+ pythonOperationType.getRealName()
|
||
+ File.separator + generateFileName;
|
||
}
|
||
|
||
/**
|
||
* python生成的文件上传到java服务器统一维护
|
||
*
|
||
* @param file
|
||
* @param operateType
|
||
* @return
|
||
*/
|
||
@Transactional(rollbackFor = Exception.class)
|
||
public String upload(MultipartFile file, String operateType) {
|
||
//用户信息
|
||
PythonToJavaApiOperationTypeEnum operationType = PythonToJavaApiOperationTypeEnum.uploadOf(operateType);
|
||
Assert.notNull(operationType, "unknown operateType " + operateType + "!");
|
||
String path = calculateFileUrl(operationType);
|
||
File generateFile = FileUtil.upload2(file, path);
|
||
|
||
String linuxDomain = fileProperties.getLinuxDomain();
|
||
if (!StringUtils.isEmpty(linuxDomain)) {
|
||
//linux 系统
|
||
String oldPath = fileProperties.getSys().getPath();
|
||
return generateFile.getAbsolutePath().replace(oldPath, linuxDomain);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// @Transactional
|
||
// public List<String> upload(MultipartFile[] files, String operateType) {
|
||
// List<String> paths = new ArrayList<>();
|
||
// //用户信息
|
||
// PythonToJavaApiOperationTypeEnum operationType = PythonToJavaApiOperationTypeEnum.uploadOf(operateType);
|
||
// Assert.notNull(operationType, "unknown operateType " + operateType + "!");
|
||
// String path = calculateFileUrl(operationType);
|
||
// for (MultipartFile file : files) {
|
||
// File generateFile = FileUtil.upload2(file, path);
|
||
// Assert.notNull(generateFile, "An error occurred while processing the file!");
|
||
//
|
||
// String linuxDomain = fileProperties.getLinuxDomain();
|
||
// if (!StringUtils.isEmpty(linuxDomain)) {
|
||
// //linux 系统
|
||
// String oldPath = fileProperties.getSys().getPath();
|
||
// paths.add(generateFile.getAbsolutePath().replace(oldPath, linuxDomain));
|
||
// }
|
||
// }
|
||
// return paths;
|
||
// }
|
||
|
||
|
||
private String calculateFileUrl(PythonToJavaApiOperationTypeEnum operationType) {
|
||
String rootPath = fileProperties.getSys().getPath();
|
||
String day = DateUtil.dateToStr(new Date(), DateUtil.YYYYMM);
|
||
return rootPath + day + File.separator + "pythonFile" + File.separator
|
||
+ operationType.getRealName() + File.separator;
|
||
}
|
||
|
||
|
||
/**
|
||
* 组装和计算design参数
|
||
*
|
||
* @param systemScale
|
||
* @param singleOverall
|
||
* @param switchCategory
|
||
* @param elementVO
|
||
* @param processId
|
||
* @return
|
||
*/
|
||
public DesignPythonObjects covertDesignParam(BigDecimal systemScale, String singleOverall,
|
||
String switchCategory, ValidateElementVO elementVO, String processId) {
|
||
DesignPythonObjects designPythonObjects = new DesignPythonObjects();
|
||
List<DesignPythonObject> objects = new ArrayList<>();
|
||
designPythonObjects.setObjects(objects);
|
||
designPythonObjects.setProcess_id(processId);
|
||
|
||
long pinPrintNum = calculateDesignPinPrintNum(elementVO.getPrintBoardElements());
|
||
long noPinPrintNum = calculateDesignNoPinPrintNum(elementVO.getPrintBoardElements());
|
||
long noPrintNum = 8 - pinPrintNum - noPinPrintNum;
|
||
elementVO.setNoPinPrintNum(noPinPrintNum);
|
||
|
||
int[] sketchNumbers = new int[3];
|
||
|
||
for (int i = 0; i < 8; i++) {
|
||
CurrentDesignPictureTypeEnum designPictureType = calculateCurrentDesignPictureTypeNew(elementVO, sketchNumbers, systemScale);
|
||
if (designPictureType == null) break;
|
||
|
||
CurrentDesignPrintPictureTypeEnum designPrintPictureType = calculateCurrentDesignPintPictureType(pinPrintNum, noPinPrintNum, noPrintNum);
|
||
if (designPrintPictureType == null) break;
|
||
|
||
updateSketchNumbers(designPictureType, sketchNumbers);
|
||
switch (designPrintPictureType) {
|
||
case PIN:
|
||
pinPrintNum--;
|
||
break;
|
||
case NO_PIN:
|
||
noPinPrintNum--;
|
||
break;
|
||
case NO:
|
||
noPrintNum--;
|
||
break;
|
||
}
|
||
// updatePrintNumbers(designPrintPictureType, pinPrintNum, noPinPrintNum, noPrintNum);
|
||
|
||
DesignPythonItemPrint designPythonItemPrint = getRandomPrint(elementVO, designPrintPictureType);
|
||
elementVO.setDesignPythonItemPrint(designPythonItemPrint);
|
||
elementVO.setDesignPrintPictureTypeLayoutList(calculateCurrentDesignPintPictureTypeLayout(elementVO.getModelSex()));
|
||
|
||
DesignPythonObject pythonObject = createDesignPythonObject(elementVO, designPictureType, systemScale, singleOverall, switchCategory);
|
||
objects.add(pythonObject);
|
||
}
|
||
return designPythonObjects;
|
||
}
|
||
|
||
private void updateSketchNumbers(CurrentDesignPictureTypeEnum designPictureType, int[] sketchNumbers) {
|
||
switch (designPictureType) {
|
||
case PIN:
|
||
sketchNumbers[0]++;
|
||
break;
|
||
case NO_PIN:
|
||
sketchNumbers[2]--;
|
||
break;
|
||
case SYS_FILE:
|
||
sketchNumbers[1]--;
|
||
break;
|
||
}
|
||
}
|
||
|
||
private void updatePrintNumbers(CurrentDesignPrintPictureTypeEnum designPrintPictureType, long pinPrintNum, long noPinPrintNum, long noPrintNum) {
|
||
switch (designPrintPictureType) {
|
||
case PIN:
|
||
pinPrintNum--;
|
||
break;
|
||
case NO_PIN:
|
||
noPinPrintNum--;
|
||
break;
|
||
case NO:
|
||
noPrintNum--;
|
||
break;
|
||
}
|
||
}
|
||
|
||
private DesignPythonObject createDesignPythonObject(ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType, BigDecimal systemScale, String singleOverall, String switchCategory) {
|
||
DesignPythonObject pythonObject = new DesignPythonObject();
|
||
pythonObject.setItems(coverToDesignPythonItemNew(elementVO, designPictureType, systemScale));
|
||
pythonObject.setBasic(coverToBasic(pythonObject.getItems().get(0), singleOverall, switchCategory, elementVO.getDesignLibraryModelPoint()));
|
||
return pythonObject;
|
||
}
|
||
|
||
|
||
private CurrentDesignPictureTypeEnum calculateCurrentDesignPictureTypeNew(ValidateElementVO elementVO, int[] sketchNumbers, BigDecimal systemScale) {
|
||
List<CollectionElement> pinData = getPinData(elementVO);
|
||
if (CollectionUtil.isNotEmpty(pinData)) {
|
||
return CurrentDesignPictureTypeEnum.PIN;
|
||
} else {
|
||
if (sketchNumbers[1] == 0 && sketchNumbers[2] == 0) {
|
||
sketchNumbers[1] = systemScale.multiply(BigDecimal.valueOf(8 - sketchNumbers[0])).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
|
||
sketchNumbers[2] = 8 - sketchNumbers[0] - sketchNumbers[1];
|
||
}
|
||
if (sketchNumbers[2] > 0 && sketchNumbers[1] > 0) {
|
||
Long l = RandomsUtil.randomSysFile(0l, 2l);
|
||
if (l == 0l) {
|
||
return CurrentDesignPictureTypeEnum.NO_PIN;
|
||
} else {
|
||
return CurrentDesignPictureTypeEnum.SYS_FILE;
|
||
}
|
||
}
|
||
if (sketchNumbers[2] > 0) {
|
||
return CurrentDesignPictureTypeEnum.NO_PIN;
|
||
}
|
||
return CurrentDesignPictureTypeEnum.SYS_FILE;
|
||
}
|
||
}
|
||
|
||
private int calculateNoPinSketchNum(int pinSketchNum, int sysSketchNum) {
|
||
return 8 - pinSketchNum - sysSketchNum;
|
||
}
|
||
|
||
private int calculateSysSketchNum(BigDecimal sysRatio, int pinSketchNum) {
|
||
// Calculate sysRatio * (8 - pinSketchNum)
|
||
BigDecimal result = sysRatio.multiply(BigDecimal.valueOf(8 - pinSketchNum));
|
||
|
||
// Round the result to the nearest integer using half-up rounding
|
||
|
||
return result.setScale(0, RoundingMode.HALF_UP).intValue();
|
||
}
|
||
|
||
// private int calculatePinSketchNum(List<CollectionElement> sketchBoardElements, List<String> hasUseMd5List) {
|
||
// List<CollectionElement> pinData = getPinData(sketchBoardElements, hasUseMd5List);
|
||
// if (CollectionUtil.isEmpty(pinData)) {
|
||
// return 0;
|
||
// }
|
||
//// long topNum = sketchBoardElements.stream()
|
||
//// .filter(skecth -> skecth.getHasPin() == 1
|
||
//// && DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(skecth.getLevel2Type())).count();
|
||
//// long bottomNum = sketchBoardElements.stream()
|
||
//// .filter(skecth -> skecth.getHasPin() == 1
|
||
//// && DesignPythonItem.SKIRT_TROUSERS.contains(skecth.getLevel2Type())).count();
|
||
//// int num = Arrays.asList(topNum, bottomNum).stream().max(Comparator.comparing(Long::valueOf)).get().intValue();
|
||
// int num = pinData.size();
|
||
// return Math.min(num, 8);
|
||
// }
|
||
|
||
//计算当前的图片类型
|
||
private CurrentDesignPictureTypeEnum calculateCurrentDesignPictureType(int pinSketchNum, int sysSketchNum, int noPinSketchNum) {
|
||
List<Integer> codes = Lists.newArrayList();
|
||
if (pinSketchNum > 0) {
|
||
//pin默认优先选择 不参与计算 后续有调整再说
|
||
// codes.add(pinPictureNum);
|
||
return CurrentDesignPictureTypeEnum.PIN;
|
||
}
|
||
if (sysSketchNum > 0) {
|
||
codes.add(CurrentDesignPictureTypeEnum.SYS_FILE.getCode());
|
||
}
|
||
|
||
if (noPinSketchNum > 0) {
|
||
codes.add(CurrentDesignPictureTypeEnum.NO_PIN.getCode());
|
||
}
|
||
List<CurrentDesignPictureTypeEnum> pictureTypeEnums = CurrentDesignPictureTypeEnum.ofList(codes);
|
||
if (CollectionUtils.isEmpty(pictureTypeEnums)) {
|
||
return null;
|
||
}
|
||
int max = pictureTypeEnums.size();
|
||
int min = 0;
|
||
Long randomIndex = RandomsUtil.randomSysFile((long) min, (long) max);
|
||
return pictureTypeEnums.get(randomIndex.intValue());
|
||
}
|
||
|
||
//计算系统图片张数
|
||
private static int calculateSysPictureNum(BigDecimal sysRatio, int pinPictureNum) {
|
||
if (pinPictureNum > 4) {
|
||
int poolSize = 8 - pinPictureNum;
|
||
if (poolSize == 0) {
|
||
return 0;
|
||
}
|
||
return BigDecimal.valueOf(poolSize).multiply(sysRatio)
|
||
.setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
|
||
} else {
|
||
return BigDecimal.valueOf(4).multiply(sysRatio)
|
||
.setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
|
||
}
|
||
}
|
||
|
||
//计算用户库图片张数
|
||
private static int calculateUserLibraryPictureNum(int sysPictureNum, int pinPictureNum) {
|
||
if (pinPictureNum > 4) {
|
||
return 8 - pinPictureNum - sysPictureNum;
|
||
} else {
|
||
return 4 - sysPictureNum;
|
||
}
|
||
}
|
||
|
||
//计算Pin图片张数
|
||
// private int calculatePinPictureNum(List<CollectionElement> sketchBoardElements, List<String> hasUseMd5List) {
|
||
// List<CollectionElement> pinData = getPinData(sketchBoardElements, hasUseMd5List);
|
||
// if (CollectionUtil.isEmpty(pinData)) {
|
||
// return 0;
|
||
// }
|
||
// long topNum = sketchBoardElements.stream()
|
||
// .filter(skecth -> skecth.getHasPin() == 1
|
||
// && DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(skecth.getLevel2Type())).count();
|
||
// long bottomNum = sketchBoardElements.stream()
|
||
// .filter(skecth -> skecth.getHasPin() == 1
|
||
// && DesignPythonItem.SKIRT_TROUSERS.contains(skecth.getLevel2Type())).count();
|
||
// int num = Arrays.asList(topNum, bottomNum).stream().max(Comparator.comparing(Long::valueOf)).get().intValue();
|
||
// if (num > 8) {
|
||
// return 8;
|
||
// }
|
||
// return num;
|
||
// }
|
||
|
||
//计算当前的Print图片类型
|
||
private CurrentDesignPrintPictureTypeEnum calculateCurrentDesignPintPictureType(long pinPrintNum, long noPinPrintNum, long noPrintNum) {
|
||
List<Integer> codes = Lists.newArrayList();
|
||
if (pinPrintNum > 0) {
|
||
//pin默认优先选择 不参与计算 后续有调整再说
|
||
// codes.add(pinPictureNum);
|
||
return CurrentDesignPrintPictureTypeEnum.PIN;
|
||
}
|
||
if (noPinPrintNum > 0) {
|
||
codes.add(CurrentDesignPrintPictureTypeEnum.NO_PIN.getCode());
|
||
}
|
||
if (noPrintNum > 0) {
|
||
codes.add(CurrentDesignPrintPictureTypeEnum.NO.getCode());
|
||
}
|
||
|
||
List<CurrentDesignPrintPictureTypeEnum> pictureTypeEnums = CurrentDesignPrintPictureTypeEnum.ofList(codes);
|
||
if (CollectionUtils.isEmpty(pictureTypeEnums)) {
|
||
return null;
|
||
}
|
||
int max = pictureTypeEnums.size();
|
||
int min = 0;
|
||
Long randomIndex = RandomsUtil.randomSysFile((long) min, (long) max);
|
||
return pictureTypeEnums.get(randomIndex.intValue());
|
||
}
|
||
|
||
//计算当前的Print图片类型具体分布位置 0. 上衣 1.下衣 2.上衣和下衣都print
|
||
private List<String> calculateCurrentDesignPintPictureTypeLayout(String modelSex) {
|
||
if (modelSex.equals(Sex.FEMALE.getValue())) {
|
||
Long randomIndex = RandomsUtil.randomSysFile(0L, 3L);
|
||
if (randomIndex == 0) {
|
||
return DesignPythonItem.OUTWEAR_DRESS_BLOUSE;
|
||
}
|
||
if (randomIndex == 1) {
|
||
return DesignPythonItem.SKIRT_TROUSERS;
|
||
}
|
||
if (randomIndex == 2) {
|
||
List<String> all = new ArrayList<>(DesignPythonItem.OUTWEAR_DRESS_BLOUSE);
|
||
all.addAll(new ArrayList<>(DesignPythonItem.SKIRT_TROUSERS));
|
||
return all;
|
||
}
|
||
} else if (modelSex.equals(Sex.MALE.getValue())) {
|
||
Long randomIndex = RandomsUtil.randomSysFile(0L, 3L);
|
||
if (randomIndex == 0) {
|
||
return DesignPythonItem.TOPS;
|
||
}
|
||
if (randomIndex == 1) {
|
||
return DesignPythonItem.BOTTOMS;
|
||
}
|
||
if (randomIndex == 2) {
|
||
List<String> all = new ArrayList<>(DesignPythonItem.TOPS);
|
||
all.addAll(new ArrayList<>(DesignPythonItem.BOTTOMS));
|
||
return all;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
//计算print 非Pin图片剩余张数
|
||
private long calculateDesignPinPrintNum(List<CollectionElement> printBoardElements) {
|
||
if (CollectionUtils.isEmpty(printBoardElements)) {
|
||
return 0;
|
||
}
|
||
return printBoardElements.stream().filter(f -> f.getHasPin() == 1).count();
|
||
}
|
||
|
||
//计算print 非Pin图片剩余张数
|
||
private long calculateDesignNoPinPrintNum(List<CollectionElement> printBoardElements) {
|
||
if (CollectionUtils.isEmpty(printBoardElements)) {
|
||
return 0;
|
||
}
|
||
long noPinNum = printBoardElements.stream().filter(f -> f.getHasPin() == 0).count();
|
||
if (noPinNum == 0L) {
|
||
return 0;
|
||
} else {
|
||
long pinNum = printBoardElements.stream().filter(f -> f.getHasPin() == 1).count();
|
||
if (8 - pinNum < 4) {
|
||
return RandomsUtil.randomSysFile(0L, 8 - pinNum + 1);
|
||
} else {
|
||
return RandomsUtil.randomSysFile(0L, 4L + 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
// private List<DesignPythonItem> coverToDesignPythonItem(ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType) {
|
||
// //Pin的数据
|
||
// List<CollectionElement> pinData = getPinData(elementVO.getSketchBoardElements(), elementVO.getHasUseMd5List());
|
||
// //计算填充PythonItemBlouse
|
||
// List<DesignPythonItem> items = Lists.newArrayList();
|
||
// if (elementVO.getModelSex().equals("Female")) {
|
||
// List<DesignPythonItem> blouseList = calculatePythonItemBlouse(pinData, elementVO, designPictureType);
|
||
// if (!CollectionUtils.isEmpty(blouseList)) {
|
||
// items.addAll(blouseList);
|
||
// }
|
||
// //计算填充PythonItemSkirt
|
||
// DesignPythonItem skirt = calculatePythonItemSkirt(pinData, elementVO, designPictureType);
|
||
// if (Objects.nonNull(skirt)) {
|
||
// items.add(skirt);
|
||
// }
|
||
// } else {
|
||
// // 男装逻辑
|
||
// DesignPythonItem top = calculatePythonItemTop(pinData, elementVO, designPictureType);
|
||
// if (Objects.nonNull(top)) {
|
||
// items.add(top);
|
||
// }
|
||
// DesignPythonItem bottom = calculatePythonItemBottom(pinData, elementVO, designPictureType);
|
||
// if (Objects.nonNull(bottom)) {
|
||
// items.add(bottom);
|
||
// }
|
||
// if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall()) && elementVO.getSwitchCategory().equals("Outwear")) {
|
||
// DesignPythonItem outwear = calculatePythonItemOutwear(pinData, elementVO, designPictureType);
|
||
// if (Objects.nonNull(outwear)) {
|
||
// items.add(outwear);
|
||
// }
|
||
// }
|
||
// }
|
||
// //计算填充Hairstyle Earring Shoes Body
|
||
// items.addAll(calculatePythonItemHairstyleShoes(elementVO, elementVO.getDesignLibraryModelPoint()));
|
||
// return items;
|
||
// }
|
||
|
||
private List<DesignPythonItem> coverToDesignPythonItemNew(ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType, BigDecimal systemScale) {
|
||
List<DesignPythonItem> itemList = new ArrayList<>();
|
||
DesignPythonItem designPythonItem = calculatePythonItem(elementVO, designPictureType);
|
||
if (Objects.nonNull(designPythonItem)) {
|
||
itemList.add(designPythonItem);
|
||
if (elementVO.getSingleOverall().equals(SingleOverallEnum.OVERALL.getRealName())) {
|
||
List<String> otherSketchCategoryList = getOtherSketchCategoryList(elementVO.getModelSex(), designPythonItem);
|
||
if (!otherSketchCategoryList.isEmpty()) {
|
||
JSONObject attributeRecognition = getAttributeRecognition(designPythonItem, designPythonItem.getType(), elementVO.getModelSex());
|
||
for (String styleCategory : otherSketchCategoryList) {
|
||
DesignPythonItem otherSketch = processAttributeRecognition(attributeRecognition, elementVO, designPictureType, styleCategory, systemScale);
|
||
itemList.add(otherSketch);
|
||
}
|
||
}
|
||
itemList.addAll(calculatePythonItemHairstyleShoes(elementVO, elementVO.getDesignLibraryModelPoint()));
|
||
}
|
||
}
|
||
return itemList;
|
||
}
|
||
|
||
private DesignPythonItem processAttributeRecognition(JSONObject attributeRecognition, ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType, String styleCategory, BigDecimal systemScale) {
|
||
switch (designPictureType) {
|
||
case PIN:
|
||
return processPinAttributeRecognition(attributeRecognition, elementVO, styleCategory, systemScale);
|
||
case NO_PIN:
|
||
case SYS_FILE:
|
||
return processNoPinOrSysFileAttributeRecognition(attributeRecognition, elementVO, styleCategory, systemScale);
|
||
default:
|
||
throw new BusinessException("unknown designPictureType");
|
||
}
|
||
}
|
||
|
||
private DesignPythonItem processPinAttributeRecognition(JSONObject attributeRecognition, ValidateElementVO elementVO, String styleCategory, BigDecimal systemScale) {
|
||
List<CollectionElement> collectPin = getFilteredCollectionElements(elementVO.getSketchBoardElements(), 1, styleCategory);
|
||
if (CollectionUtil.isNotEmpty(collectPin)) {
|
||
int randomNum = RandomsUtil.randomSysFile(collectPin.size());
|
||
elementVO.getHasUseMd5List().add(collectPin.get(randomNum).getMd5());
|
||
return coverSketchToDesignPythonItem(collectPin.get(randomNum).getId(), collectPin.get(randomNum), elementVO);
|
||
} else {
|
||
List<CollectionElement> collectNoPin = getFilteredCollectionElements(elementVO.getSketchBoardElements(), 0, styleCategory);
|
||
return processNoPinOrSysFileAttributeRecognitionWithPool(collectNoPin, attributeRecognition, elementVO, styleCategory, systemScale);
|
||
}
|
||
}
|
||
|
||
private DesignPythonItem processNoPinOrSysFileAttributeRecognition(JSONObject attributeRecognition, ValidateElementVO elementVO, String styleCategory, BigDecimal systemScale) {
|
||
List<CollectionElement> collectNoPin = getFilteredCollectionElements(elementVO.getSketchBoardElements(), 0, styleCategory);
|
||
return processNoPinOrSysFileAttributeRecognitionWithPool(collectNoPin, attributeRecognition, elementVO, styleCategory, systemScale);
|
||
}
|
||
|
||
private DesignPythonItem processNoPinOrSysFileAttributeRecognitionWithPool(List<CollectionElement> collectionElements, JSONObject attributeRecognition, ValidateElementVO elementVO, String styleCategory, BigDecimal systemScale) {
|
||
int poolNum = 20;
|
||
if (CollectionUtil.isNotEmpty(collectionElements)) {
|
||
int collectionNoPinSize = collectionElements.size();
|
||
if (systemScale.compareTo(BigDecimal.ZERO) == 0) {
|
||
int randomNum = RandomsUtil.randomSysFile(collectionNoPinSize);
|
||
return coverSketchToDesignPythonItem(null, collectionElements.get(randomNum), elementVO);
|
||
} else if (systemScale.compareTo(BigDecimal.ONE) != 0) {
|
||
BigDecimal collectNoPinSize = BigDecimal.valueOf(collectionNoPinSize);
|
||
poolNum = collectNoPinSize.divide(systemScale, 0, RoundingMode.DOWN).intValue();
|
||
List<CollectionElement> list = getSystemSketchPool(attributeRecognition, styleCategory, elementVO.getModelSex(), poolNum);
|
||
collectionElements.addAll(list);
|
||
int randomNum = RandomsUtil.randomSysFile(collectionElements.size());
|
||
if (randomNum < collectionNoPinSize) {
|
||
return coverSketchToDesignPythonItem(collectionElements.get(randomNum).getId(), collectionElements.get(randomNum), elementVO);
|
||
} else {
|
||
return coverSketchToDesignPythonItem(null, collectionElements.get(randomNum), elementVO);
|
||
}
|
||
}
|
||
}
|
||
List<CollectionElement> list = getSystemSketchPool(attributeRecognition, styleCategory, elementVO.getModelSex(), poolNum);
|
||
int randomNum = RandomsUtil.randomSysFile(list.size());
|
||
return coverSketchToDesignPythonItem(null, list.get(randomNum), elementVO);
|
||
}
|
||
|
||
private List<CollectionElement> getFilteredCollectionElements(List<CollectionElement> elements, int hasPin, String styleCategory) {
|
||
return CollectionUtil.isNotEmpty(elements) ? elements.stream().filter(o -> o.getHasPin() == hasPin && o.getLevel2Type().equals(styleCategory)).collect(Collectors.toList()) : null;
|
||
}
|
||
|
||
private DesignPythonItem processAttributeRecognitionBySameCategory(JSONObject attributeRecognition, ValidateElementVO elementVO, String styleCategory) {
|
||
List<CollectionElement> list = getSystemSketchPoolBySameCategory(attributeRecognition, styleCategory, elementVO.getModelSex());
|
||
int randomNum = RandomsUtil.randomSysFile(list.size());
|
||
return coverSketchToDesignPythonItem(null, list.get(randomNum), elementVO);
|
||
}
|
||
|
||
@Resource
|
||
private AttributeRetrievalMapper attributeRetrievalMapper;
|
||
|
||
private List<CollectionElement> getSystemSketchPool(JSONObject attributeRecognition, String styleCategory, String modelSex, int poolNum) {
|
||
/**
|
||
* female trousers->female_pants
|
||
* female blouse->female_top
|
||
* female skirt->female_skirt
|
||
* female outwear->female_outwear
|
||
* female dress->female_dress
|
||
*/
|
||
JSONObject data = attributeRecognition.getJSONObject("data");
|
||
JSONObject attrDict = ((JSONObject) data.getJSONArray("list").get(0)).getJSONObject("attr_dict");
|
||
AttributeRecognitionJSON attrDictJSON = attrDict.toJavaObject(AttributeRecognitionJSON.class);
|
||
AttributeRetrieval attributeRetrievalAttrDict = toAttrDict(attrDictJSON);
|
||
String tableName;
|
||
tableName = getTableName(modelSex, styleCategory);
|
||
List<AttributeRetrieval> attributeRetrievalList = attributeRetrievalMapper.getSystemSketchPool(attributeRetrievalAttrDict, tableName, poolNum);
|
||
if (CollectionUtil.isEmpty(attributeRetrievalList) || attributeRetrievalList.size() < poolNum) {
|
||
attributeRetrievalAttrDict.setDesign(null);
|
||
attributeRetrievalList = attributeRetrievalMapper.getSystemSketchPool(attributeRetrievalAttrDict, tableName, poolNum);
|
||
}
|
||
if (CollectionUtil.isEmpty(attributeRetrievalList) || attributeRetrievalList.size() < poolNum) {
|
||
attributeRetrievalAttrDict.setSilhouette(null);
|
||
attributeRetrievalList = attributeRetrievalMapper.getSystemSketchPool(attributeRetrievalAttrDict, tableName, poolNum);
|
||
}
|
||
return toColoectionElementList(attributeRetrievalList, styleCategory, modelSex);
|
||
}
|
||
|
||
private List<CollectionElement> getSystemSketchPoolBySameCategory(JSONObject attributeRecognition, String styleCategory, String modelSex) {
|
||
/**
|
||
* female trousers->female_pants
|
||
* female blouse->female_top
|
||
* female skirt->female_skirt
|
||
* female outwear->female_outwear
|
||
* female dress->female_dress
|
||
*/
|
||
JSONObject data = attributeRecognition.getJSONObject("data");
|
||
JSONObject attrDict = ((JSONObject) data.getJSONArray("list").get(0)).getJSONObject("attr_dict");
|
||
AttributeRecognitionJSON attrDictJSON = attrDict.toJavaObject(AttributeRecognitionJSON.class);
|
||
AttributeRetrieval attributeRetrievalAttrDict = toAttrDict(attrDictJSON);
|
||
String tableName;
|
||
tableName = getTableName(modelSex, styleCategory);
|
||
|
||
// 存储非空字段的列表
|
||
List<String> nonNullFields = new ArrayList<>();
|
||
if (attributeRetrievalAttrDict.getType() != null) {
|
||
nonNullFields.add("type");
|
||
}
|
||
if (attributeRetrievalAttrDict.getOpeningType() != null) {
|
||
nonNullFields.add("openingType");
|
||
if (tableName.equals("male_outwear") || tableName.equals("male_top") || tableName.equals("male_bottom")) {
|
||
nonNullFields.remove("openingType");
|
||
attributeRetrievalAttrDict.setOpeningType(null);
|
||
}
|
||
}
|
||
if (attributeRetrievalAttrDict.getSubtype() != null) {
|
||
nonNullFields.add("subtype");
|
||
}
|
||
|
||
// 只有当非空字段数量大于等于2时才进行处理
|
||
if (nonNullFields.size() >= 2) {
|
||
// 随机数生成器
|
||
Random random = new Random();
|
||
// 随机选择一个字段保留
|
||
String fieldToKeep = nonNullFields.get(random.nextInt(nonNullFields.size()));
|
||
|
||
// 设置保留的字段为非null，其他字段为null
|
||
for (String field : nonNullFields) {
|
||
if (!field.equals(fieldToKeep)) {
|
||
switch (field) {
|
||
case "type":
|
||
attributeRetrievalAttrDict.setType(null);
|
||
break;
|
||
case "openingType":
|
||
attributeRetrievalAttrDict.setOpeningType(null);
|
||
break;
|
||
case "subtype":
|
||
attributeRetrievalAttrDict.setSubtype(null);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
List<AttributeRetrieval> attributeRetrievalList = attributeRetrievalMapper.getSystemSketchPoolBySameCategory(attributeRetrievalAttrDict, tableName);
|
||
if (CollectionUtil.isEmpty(attributeRetrievalList)) {
|
||
System.out.println(attributeRetrievalAttrDict);
|
||
System.out.println(tableName);
|
||
}
|
||
return toColoectionElementList(attributeRetrievalList, styleCategory, modelSex);
|
||
}
|
||
|
||
private List<CollectionElement> toColoectionElementList(List<AttributeRetrieval> attributeRetrievalList, String styleCategory, String modelSex) {
|
||
List<CollectionElement> systemPool = new ArrayList<>();
|
||
for (AttributeRetrieval attributeRetrieval : attributeRetrievalList) {
|
||
CollectionElement system = toCollectionElement(attributeRetrieval, styleCategory, modelSex);
|
||
systemPool.add(system);
|
||
}
|
||
return systemPool;
|
||
}
|
||
|
||
private CollectionElement toCollectionElement(AttributeRetrieval attributeRetrieval, String styleCategory, String modelSex) {
|
||
CollectionElement element = new CollectionElement();
|
||
element.setLevel2Type(styleCategory);
|
||
element.setUrl("aida-sys-image/images/" + modelSex.toLowerCase() + "/" + attributeRetrieval.getImgName());
|
||
if (element.getUrl().contains("top")) {
|
||
element.setUrl(element.getUrl().replace("top", "tops"));
|
||
}
|
||
if (element.getUrl().contains("bottom")) {
|
||
element.setUrl(element.getUrl().replace("bottom", "bottoms"));
|
||
}
|
||
if (element.getUrl().contains("outer")) {
|
||
element.setUrl(element.getUrl().replace("outer", "outwear"));
|
||
}
|
||
return element;
|
||
}
|
||
|
||
private AttributeRetrieval toAttrDict(AttributeRecognitionJSON attrDictJSON) {
|
||
AttributeRetrieval attributeRetrieval = new AttributeRetrieval();
|
||
// attributeRetrieval.setImgName(attrDictJSON.getImgName().get(0));
|
||
// attributeRetrieval.setLength(attrDictJSON.getLength().get(0));
|
||
// attributeRetrieval.setSleeveLength(attrDictJSON.getSleeveLength().get(0));
|
||
// attributeRetrieval.setSleeveShape(attrDictJSON.getSleeveShape().get(0));
|
||
// attributeRetrieval.setSleeveShoulder(attrDictJSON.getSleeveShoulder().get(0));
|
||
// attributeRetrieval.setNeckline(attrDictJSON.getNeckline().get(0));
|
||
// attributeRetrieval.setCollar(attrDictJSON.getCollar().get(0));
|
||
if (CollectionUtil.isNotEmpty(attrDictJSON.getDesign()) && attrDictJSON.getDesign().get(0) != null) {
|
||
attributeRetrieval.setDesign(attrDictJSON.getDesign().get(0));
|
||
}
|
||
if (CollectionUtil.isNotEmpty(attrDictJSON.getSilhouette()) && attrDictJSON.getSilhouette().get(0) != null) {
|
||
attributeRetrieval.setSilhouette(attrDictJSON.getSilhouette().get(0));
|
||
}
|
||
if (CollectionUtil.isNotEmpty(attrDictJSON.getType()) && attrDictJSON.getType().get(0) != null) {
|
||
attributeRetrieval.setType(attrDictJSON.getType().get(0));
|
||
}
|
||
if (CollectionUtil.isNotEmpty(attrDictJSON.getSubtype()) && attrDictJSON.getSubtype().get(0) != null) {
|
||
attributeRetrieval.setSubtype(attrDictJSON.getSubtype().get(0));
|
||
}
|
||
if (CollectionUtil.isNotEmpty(attrDictJSON.getOpeningType()) && attrDictJSON.getOpeningType().get(0) != null) {
|
||
attributeRetrieval.setOpeningType(attrDictJSON.getOpeningType().get(0));
|
||
}
|
||
return attributeRetrieval;
|
||
}
|
||
|
||
public JSONObject getAttributeRecognition(DesignPythonItem designPythonItem, String styleCategory, String modelSex) {
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.readTimeout(60, TimeUnit.SECONDS)
|
||
.writeTimeout(60, TimeUnit.SECONDS)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
|
||
JSONObject paramJSONObject = new JSONObject();
|
||
paramJSONObject.put("category", styleCategory);
|
||
paramJSONObject.put("colony", modelSex);
|
||
paramJSONObject.put("sketch_img_url", designPythonItem.getPath());
|
||
JSONArray paramArray = new JSONArray();
|
||
paramArray.add(paramJSONObject);
|
||
String param = JSON.toJSONString(paramArray, SerializerFeature.DisableCircularReferenceDetect);
|
||
|
||
log.info("PythonService##design 请求参数:####{}", param);
|
||
RequestBody body = RequestBody.create(mediaType, param);
|
||
Request request = new Request.Builder()
|
||
.url(accessPythonIp + ":" + accessPythonPort + "/api/attribute_recognition")
|
||
// .url(fastApiPythonAddress + "/api/attribute_recognition")
|
||
.method("POST", body)
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
|
||
try (Response response = client.newCall(request).execute()) {
|
||
if (response.isSuccessful()) {
|
||
String responseBody = Objects.requireNonNull(response.body()).string();
|
||
JSONObject responseObject = JSON.parseObject(responseBody);
|
||
log.info("PythonService##responseObject###{}", responseObject);
|
||
return responseObject;
|
||
} else {
|
||
log.error("PythonService##design 请求异常：{}", response);
|
||
throw new BusinessException("attributeRecognition.interface.exception");
|
||
}
|
||
} catch (IOException e) {
|
||
log.error("PythonService##design 请求异常：{}", e.getMessage());
|
||
throw new BusinessException("attributeRecognition.interface.exception");
|
||
}
|
||
}
|
||
|
||
public JSONObject getAttributeRecognitionBySameCategory(CollectionElement element, String modelSex) {
|
||
// todo 限流校验
|
||
// AccessLimitUtils.validate("design",5);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
//关闭FastJson的引用检测 防止出现$ref 现象
|
||
JSONObject paramJSONObject = new JSONObject();
|
||
paramJSONObject.put("category", element.getLevel2Type());
|
||
paramJSONObject.put("colony", modelSex);
|
||
paramJSONObject.put("sketch_img_url", element.getUrl());
|
||
JSONArray paramArray = new JSONArray();
|
||
paramArray.add(paramJSONObject);
|
||
String param = JSON.toJSONString(paramArray, SerializerFeature.DisableCircularReferenceDetect);
|
||
log.info("design请求python 参数:####{}", param);
|
||
RequestBody body = RequestBody.create(mediaType, param);
|
||
Request request = new Request.Builder()
|
||
.url(accessPythonIp + ":" + accessPythonPort + "/api/attribute_recognition")
|
||
// .url(fastApiPythonAddress + "/api/attribute_recognition")
|
||
.method("POST", body)
|
||
// .addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response;
|
||
String responseBody;
|
||
try {
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
AccessLimitUtils.validateOut("design");
|
||
log.error("PythonService##design异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
throw new BusinessException("design.interface.exception");
|
||
}
|
||
//去除限流
|
||
// AccessLimitUtils.validateOut("design");
|
||
if (response.isSuccessful()) {
|
||
try {
|
||
if (Objects.nonNull(response.body())) {
|
||
responseBody = response.body().string();
|
||
JSONObject responseObject = JSON.parseObject(responseBody);
|
||
log.info("PythonService##responseObject###{}", responseObject);
|
||
return responseObject;
|
||
}
|
||
throw new BusinessException("design.interface.exception");
|
||
} catch (IOException | JSONException e) {
|
||
log.error("PythonService##design异常###{}", e.getMessage());
|
||
throw new BusinessException("design.interface.exception");
|
||
}
|
||
}
|
||
log.error("PythonService##design异常response###{}", response);
|
||
//生成失败
|
||
throw new BusinessException("design.interface.exception");
|
||
}
|
||
|
||
@Resource
|
||
private CollocationMapper collocationMapper;
|
||
@Resource
|
||
private DressingMapper dressingMapper;
|
||
|
||
private List<String> getOtherSketchCategoryList(String modelSex, DesignPythonItem designPythonItem) {
|
||
List<Collocation> collocationList = collocationMapper.getCollocationListBySketch(modelSex, designPythonItem.getType());
|
||
if (CollectionUtil.isNotEmpty(collocationList)) {
|
||
Random random = new Random();
|
||
int randomNumber = random.nextInt(collocationList.size());
|
||
List<String> otherSketchCategoryList = dressingMapper.getOtherSketchCategoryNameList(collocationList.get(randomNumber).getId(), designPythonItem.getType().toLowerCase());
|
||
return otherSketchCategoryList;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private DesignPythonItem calculatePythonItem(ValidateElementVO validateElementVO, CurrentDesignPictureTypeEnum currentDesignPictureType) {
|
||
switch (currentDesignPictureType) {
|
||
case PIN:
|
||
return calculatePinPythonItem(validateElementVO);
|
||
case NO_PIN:
|
||
return calculateNoPinPythonItem(validateElementVO);
|
||
case SYS_FILE:
|
||
return calculateSysFilePythonItem(validateElementVO);
|
||
default:
|
||
return null;
|
||
}
|
||
}
|
||
|
||
private DesignPythonItem calculatePinPythonItem(ValidateElementVO validateElementVO) {
|
||
List<CollectionElement> pinCollectionData = getPinData(validateElementVO);
|
||
if (CollectionUtil.isEmpty(pinCollectionData)) {
|
||
throw new BusinessException("pinData is null");
|
||
}
|
||
Random random = new Random();
|
||
int randomNumber = random.nextInt(pinCollectionData.size());
|
||
validateElementVO.getHasUseMd5List().add(pinCollectionData.get(randomNumber).getMd5());
|
||
return coverSketchToDesignPythonItem(pinCollectionData.get(randomNumber).getId(), pinCollectionData.get(randomNumber), validateElementVO);
|
||
}
|
||
|
||
private DesignPythonItem calculateNoPinPythonItem(ValidateElementVO validateElementVO) {
|
||
List<CollectionElement> noPinCollectionData = getNoPinData(validateElementVO);
|
||
if (CollectionUtil.isEmpty(noPinCollectionData)) {
|
||
List<CollectionElement> sketchBoardPins = getPinDataWhole(validateElementVO);
|
||
if (CollectionUtil.isNotEmpty(sketchBoardPins) && validateElementVO.getSingleOverall().equals(SingleOverallEnum.SINGLE.getRealName())) {
|
||
sketchBoardPins = sketchBoardPins.stream().filter(o -> o.getLevel2Type().equals(validateElementVO.getSwitchCategory())).collect(Collectors.toList());
|
||
}
|
||
if (CollectionUtil.isNotEmpty(sketchBoardPins)) {
|
||
Integer randomNum = RandomsUtil.randomSysFile(sketchBoardPins.size());
|
||
CollectionElement element = sketchBoardPins.get(randomNum);
|
||
JSONObject attributeRecognition = getAttributeRecognitionBySameCategory(element, validateElementVO.getModelSex());
|
||
return processAttributeRecognitionBySameCategory(attributeRecognition, validateElementVO, element.getLevel2Type());
|
||
}
|
||
QueryWrapper<Dressing> qw = new QueryWrapper<>();
|
||
qw.lambda().eq(Dressing::getApparel, validateElementVO.getModelSex());
|
||
if (validateElementVO.getSingleOverall().equals(SingleOverallEnum.SINGLE.getRealName())) {
|
||
qw.lambda().eq(Dressing::getStyleCategory, validateElementVO.getSwitchCategory());
|
||
}
|
||
List<Dressing> dressings = dressingMapper.selectList(qw);
|
||
if (CollectionUtil.isEmpty(dressings)) {
|
||
throw new BusinessException("dressings is null");
|
||
}
|
||
Integer randomNum = RandomsUtil.randomSysFile(dressings.size());
|
||
String category = dressings.get(randomNum).getStyleCategory();
|
||
String tableName = getTableName(validateElementVO.getModelSex(), category);
|
||
AttributeRetrieval attributeRetrieval = attributeRetrievalMapper.getSystemRandom(tableName);
|
||
CollectionElement collectionElement = toCollectionElement(attributeRetrieval, category, validateElementVO.getModelSex());
|
||
return coverSketchToDesignPythonItem(null, collectionElement, validateElementVO);
|
||
}
|
||
Random random = new Random();
|
||
int randomNumber = random.nextInt(noPinCollectionData.size());
|
||
return coverSketchToDesignPythonItem(noPinCollectionData.get(randomNumber).getId(), noPinCollectionData.get(randomNumber), validateElementVO);
|
||
}
|
||
|
||
private DesignPythonItem calculateSysFilePythonItem(ValidateElementVO validateElementVO) {
|
||
List<CollectionElement> sketchBoardCollectionElements = validateElementVO.getSketchBoardElements();
|
||
if (!CollectionUtils.isEmpty(sketchBoardCollectionElements)) {
|
||
if (validateElementVO.getModelSex().equals(Sex.MALE.getValue())) {
|
||
sketchBoardCollectionElements = sketchBoardCollectionElements.stream().filter(o -> MALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (validateElementVO.getModelSex().equals(Sex.FEMALE.getValue())) {
|
||
sketchBoardCollectionElements = sketchBoardCollectionElements.stream().filter(o -> FEMALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (CollectionUtil.isNotEmpty(sketchBoardCollectionElements) && validateElementVO.getSingleOverall().equals(SingleOverallEnum.SINGLE.getRealName())) {
|
||
sketchBoardCollectionElements = sketchBoardCollectionElements.stream().filter(o -> o.getLevel2Type().equals(validateElementVO.getSwitchCategory())).collect(Collectors.toList());
|
||
}
|
||
if (CollectionUtil.isNotEmpty(sketchBoardCollectionElements)) {
|
||
Integer randomNum = RandomsUtil.randomSysFile(sketchBoardCollectionElements.size());
|
||
CollectionElement element = sketchBoardCollectionElements.get(randomNum);
|
||
JSONObject attributeRecognition = getAttributeRecognitionBySameCategory(element, validateElementVO.getModelSex());
|
||
return processAttributeRecognitionBySameCategory(attributeRecognition, validateElementVO, element.getLevel2Type());
|
||
}
|
||
}
|
||
QueryWrapper<Dressing> qw = new QueryWrapper<>();
|
||
qw.lambda().eq(Dressing::getApparel, validateElementVO.getModelSex());
|
||
if (validateElementVO.getSingleOverall().equals(SingleOverallEnum.SINGLE.getRealName())) {
|
||
qw.lambda().eq(Dressing::getStyleCategory, validateElementVO.getSwitchCategory());
|
||
}
|
||
List<Dressing> dressings = dressingMapper.selectList(qw);
|
||
if (CollectionUtil.isEmpty(dressings)) {
|
||
throw new BusinessException("dressings is null");
|
||
}
|
||
Integer randomNum = RandomsUtil.randomSysFile(dressings.size());
|
||
String category = dressings.get(randomNum).getStyleCategory();
|
||
String tableName = getTableName(validateElementVO.getModelSex(), category);
|
||
AttributeRetrieval attributeRetrieval = attributeRetrievalMapper.getSystemRandom(tableName);
|
||
CollectionElement collectionElement = toCollectionElement(attributeRetrieval, category, validateElementVO.getModelSex());
|
||
return coverSketchToDesignPythonItem(null, collectionElement, validateElementVO);
|
||
}
|
||
|
||
private String getTableName(String modelSex, String category) {
|
||
switch (modelSex) {
|
||
case "Female": {
|
||
switch (category) {
|
||
case "Blouse": {
|
||
return "female_top";
|
||
}
|
||
case "Trousers": {
|
||
return "female_pants";
|
||
}
|
||
case "Skirt": {
|
||
return "female_skirt";
|
||
}
|
||
case "Outwear": {
|
||
return "female_outwear";
|
||
}
|
||
case "Dress": {
|
||
return "female_dress";
|
||
}
|
||
default: {
|
||
throw new BusinessException("unknown attributeRetrieval dressing");
|
||
}
|
||
}
|
||
}
|
||
case "Male": {
|
||
switch (category) {
|
||
case "Tops": {
|
||
return "male_top";
|
||
}
|
||
case "Bottoms": {
|
||
return "male_bottom";
|
||
}
|
||
case "Outwear": {
|
||
return "male_outwear";
|
||
}
|
||
default: {
|
||
throw new BusinessException("unknown male dressing");
|
||
}
|
||
}
|
||
}
|
||
default: {
|
||
throw new BusinessException("unknown modelSex");
|
||
}
|
||
}
|
||
}
|
||
|
||
private DesignPythonItem calculatePythonItemOutwear(List<CollectionElement> pinData, ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType) {
|
||
DesignPythonItem outwear = null;
|
||
//剩余的的PinData
|
||
List<Long> existPinDataIds = elementVO.getExistPinDataIds();
|
||
List<CollectionElement> residuePinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
if (CollectionUtil.isNotEmpty(residuePinData)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR.contains(elementVO.getSwitchCategory())) {
|
||
//是否包含的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
elementVO.getSwitchCategory().equals(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
//Pin的数据
|
||
pinData = getPinDataByLevel2Type(pinData, elementVO.getSwitchCategory());
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinDataByType = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = CollectionUtils.isEmpty(residueInnerPinDataByType) ? null : residueInnerPinDataByType.get(0);
|
||
if (Objects.nonNull(elementNew)) {
|
||
outwear = coverToDesignPythonItem(elementNew.getId(), elementVO.getSwitchCategory(), elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
//是否包含skirt的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
DesignPythonItem.OUTWEAR.contains(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
for (String type : DesignPythonItem.OUTWEAR) {
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = residueInnerPinData.stream()
|
||
.filter(element -> element.getLevel2Type().equals(type)).findFirst().orElse(null);
|
||
if (Objects.nonNull(elementNew)) {
|
||
outwear = coverToDesignPythonItem(elementNew.getId(), type, elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
if (Objects.nonNull(outwear)) {
|
||
return outwear;
|
||
}
|
||
switch (designPictureType) {
|
||
case PIN:
|
||
if (Objects.isNull(outwear)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
outwear.setBusinessId(sysFileVO.getId());
|
||
return outwear;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
outwear.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return outwear;
|
||
}
|
||
}
|
||
break;
|
||
// case USER_LIBRARY:
|
||
// //single模式
|
||
// if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
// if (DesignPythonItem.OUTWEAR.contains(elementVO.getSwitchCategory())) {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// Arrays.asList(elementVO.getSwitchCategory()), elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// outwear.setBusinessId(sysFileVO.getId());
|
||
// return outwear;
|
||
// }
|
||
// outwear = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// outwear.setBusinessId(libraryVo.getId());
|
||
// }
|
||
// } else {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// DesignPythonItem.OUTWEAR, elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// outwear.setBusinessId(sysFileVO.getId());
|
||
// //添加已使用的md5
|
||
// return outwear;
|
||
// }
|
||
// outwear = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// outwear.setBusinessId(libraryVo.getId());
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// }
|
||
// break;
|
||
case SYS_FILE:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
outwear.setBusinessId(sysFileVO.getId());
|
||
return outwear;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
outwear.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return outwear;
|
||
}
|
||
break;
|
||
case NO_PIN:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR.contains(elementVO.getSwitchCategory())) {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinDataByType =
|
||
getNoPinData(elementVO.getSketchBoardElements(), Collections.singletonList(elementVO.getSwitchCategory()));
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinDataByType, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
outwear.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
outwear = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
} else {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinData = getNoPinData(elementVO.getSketchBoardElements(), DesignPythonItem.OUTWEAR);
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinData, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
outwear = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
outwear.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
outwear = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
}
|
||
return outwear;
|
||
}
|
||
|
||
private DesignPythonItem calculatePythonItemBottom(List<CollectionElement> pinData, ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType) {
|
||
DesignPythonItem bottom = null;
|
||
//剩余的的PinData
|
||
List<Long> existPinDataIds = elementVO.getExistPinDataIds();
|
||
List<CollectionElement> residuePinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
if (CollectionUtil.isNotEmpty(residuePinData)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.BOTTOMS.contains(elementVO.getSwitchCategory())) {
|
||
//是否包含的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
elementVO.getSwitchCategory().equals(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
//Pin的数据
|
||
pinData = getPinDataByLevel2Type(pinData, elementVO.getSwitchCategory());
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinDataByType = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = CollectionUtils.isEmpty(residueInnerPinDataByType) ? null : residueInnerPinDataByType.get(0);
|
||
if (Objects.nonNull(elementNew)) {
|
||
bottom = coverToDesignPythonItem(elementNew.getId(), elementVO.getSwitchCategory(), elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
//是否包含skirt的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
DesignPythonItem.BOTTOMS.contains(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
for (String type : DesignPythonItem.BOTTOMS) {
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = residueInnerPinData.stream()
|
||
.filter(element -> element.getLevel2Type().equals(type)).findFirst().orElse(null);
|
||
if (Objects.nonNull(elementNew)) {
|
||
bottom = coverToDesignPythonItem(elementNew.getId(), type, elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
if (Objects.nonNull(bottom)) {
|
||
return bottom;
|
||
}
|
||
switch (designPictureType) {
|
||
case PIN:
|
||
if (Objects.isNull(bottom)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.BOTTOMS.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
bottom.setBusinessId(sysFileVO.getId());
|
||
return bottom;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
bottom.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return bottom;
|
||
}
|
||
}
|
||
break;
|
||
// case USER_LIBRARY:
|
||
// //single模式
|
||
// if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
// if (DesignPythonItem.BOTTOMS.contains(elementVO.getSwitchCategory())) {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// Arrays.asList(elementVO.getSwitchCategory()), elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// bottom.setBusinessId(sysFileVO.getId());
|
||
// return bottom;
|
||
// }
|
||
// bottom = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// bottom.setBusinessId(libraryVo.getId());
|
||
// }
|
||
// } else {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// DesignPythonItem.BOTTOMS, elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// bottom.setBusinessId(sysFileVO.getId());
|
||
// //添加已使用的md5
|
||
// return bottom;
|
||
// }
|
||
// bottom = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// bottom.setBusinessId(libraryVo.getId());
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// }
|
||
// break;
|
||
case SYS_FILE:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.BOTTOMS.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
bottom.setBusinessId(sysFileVO.getId());
|
||
return bottom;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
bottom.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return bottom;
|
||
}
|
||
break;
|
||
case NO_PIN:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.BOTTOMS.contains(elementVO.getSwitchCategory())) {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinDataByType =
|
||
getNoPinData(elementVO.getSketchBoardElements(), Collections.singletonList(elementVO.getSwitchCategory()));
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinDataByType, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
bottom.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
bottom = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
} else {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinData = getNoPinData(elementVO.getSketchBoardElements(), DesignPythonItem.BOTTOMS);
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinData, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleBottoms(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
bottom = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
bottom.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
bottom = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
}
|
||
return bottom;
|
||
}
|
||
|
||
private DesignPythonItem calculatePythonItemTop(List<CollectionElement> pinData, ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType) {
|
||
DesignPythonItem top = null;
|
||
//剩余的的PinData
|
||
List<Long> existPinDataIds = elementVO.getExistPinDataIds();
|
||
List<CollectionElement> residuePinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
if (CollectionUtil.isNotEmpty(residuePinData)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.TOPS.contains(elementVO.getSwitchCategory())) {
|
||
//是否包含的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
elementVO.getSwitchCategory().equals(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
//Pin的数据
|
||
pinData = getPinDataByLevel2Type(pinData, elementVO.getSwitchCategory());
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinDataByType = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = CollectionUtils.isEmpty(residueInnerPinDataByType) ? null : residueInnerPinDataByType.get(0);
|
||
if (Objects.nonNull(elementNew)) {
|
||
top = coverToDesignPythonItem(elementNew.getId(), elementVO.getSwitchCategory(), elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
//是否包含skirt的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
DesignPythonItem.TOPS.contains(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
for (String type : DesignPythonItem.TOPS) {
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = residueInnerPinData.stream()
|
||
.filter(element -> element.getLevel2Type().equals(type)).findFirst().orElse(null);
|
||
if (Objects.nonNull(elementNew)) {
|
||
top = coverToDesignPythonItem(elementNew.getId(), type, elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
if (Objects.nonNull(top)) {
|
||
return top;
|
||
}
|
||
switch (designPictureType) {
|
||
case PIN:
|
||
if (Objects.isNull(top)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.TOPS.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
top.setBusinessId(sysFileVO.getId());
|
||
return top;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleTops(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
top.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return top;
|
||
}
|
||
}
|
||
break;
|
||
// case USER_LIBRARY:
|
||
// //single模式
|
||
// if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
// if (DesignPythonItem.TOPS.contains(elementVO.getSwitchCategory())) {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// Arrays.asList(elementVO.getSwitchCategory()), elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// top.setBusinessId(sysFileVO.getId());
|
||
// return top;
|
||
// }
|
||
// top = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// top.setBusinessId(libraryVo.getId());
|
||
// }
|
||
// } else {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// DesignPythonItem.TOPS, elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileMaleTops(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// top.setBusinessId(sysFileVO.getId());
|
||
// //添加已使用的md5
|
||
// return top;
|
||
// }
|
||
// top = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// top.setBusinessId(libraryVo.getId());
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// }
|
||
// break;
|
||
case SYS_FILE:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.TOPS.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
top.setBusinessId(sysFileVO.getId());
|
||
return top;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleTops(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
top.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return top;
|
||
}
|
||
break;
|
||
case NO_PIN:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.TOPS.contains(elementVO.getSwitchCategory())) {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinDataByType =
|
||
getNoPinData(elementVO.getSketchBoardElements(), Collections.singletonList(elementVO.getSwitchCategory()));
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinDataByType, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
top.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
top = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
} else {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinData = getNoPinData(elementVO.getSketchBoardElements(), DesignPythonItem.TOPS);
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinData, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileMaleTops(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
top = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
top.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
top = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
}
|
||
return top;
|
||
}
|
||
|
||
private List<DesignPythonItem> calculatePythonItemHairstyleShoes(ValidateElementVO elementVO, DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
List<DesignPythonItem> items = Lists.newArrayList();
|
||
for (String type : DesignPythonItem.SYS_HAIRSTYLE_SHOES_BODY) {
|
||
if (!type.equals("Body")) {
|
||
continue;
|
||
}
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall()) || Objects.nonNull(designLibraryModelPoint)) {
|
||
//single和models模特时候不传耳环 首饰,鞋子等
|
||
if (!SysFileLevel2TypeEnum.BODY.getRealName().equals(type)) {
|
||
continue;
|
||
}
|
||
}
|
||
DesignPythonItem pythonItem = new DesignPythonItem();
|
||
items.add(pythonItem);
|
||
//类型
|
||
pythonItem.setType(type);
|
||
if (SysFileLevel2TypeEnum.BODY.getRealName().equals(type)) {
|
||
if (Objects.nonNull(designLibraryModelPoint)) {
|
||
pythonItem.setBody_path(designLibraryModelPoint.getTemplateUrl());
|
||
} else {
|
||
// pythonItem.setBody_path("/workspace/python_code/Multi-layer-Virtual-Try-on/dataset_for_test/Img_model.png");
|
||
pythonItem.setBody_path("aida-mannequins/model_1693218345.2714432.png");
|
||
}
|
||
} else {
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(type, Lists.newArrayList(), elementVO.getModelSex());
|
||
pythonItem.setPath(sysFileVO.getUrl());
|
||
pythonItem.setBusinessId(sysFileVO.getId());
|
||
if (SysFileLevel2TypeEnum.SHOES.getRealName().equals(type)) {
|
||
CollectionColorDTO randomColor = getRandomColor(elementVO.getColorBoards());
|
||
pythonItem.setColor(randomColor.getRgbValue());
|
||
pythonItem.setGradient(randomColor.getGradientMinioUrl());
|
||
pythonItem.setGradientString(randomColor.getGradientString());
|
||
}
|
||
}
|
||
}
|
||
return items;
|
||
}
|
||
|
||
private DesignPythonItem calculatePythonItemSkirt(List<CollectionElement> pinData, ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType) {
|
||
// skirt, trousers 只选择一个
|
||
DesignPythonItem skirt = null;
|
||
//剩余的的PinData
|
||
List<Long> existPinDataIds = elementVO.getExistPinDataIds();
|
||
List<CollectionElement> residuePinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
if (CollectionUtil.isNotEmpty(residuePinData)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.SKIRT_TROUSERS.contains(elementVO.getSwitchCategory())) {
|
||
//是否包含的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
elementVO.getSwitchCategory().equals(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
//Pin的数据
|
||
pinData = getPinDataByLevel2Type(pinData, elementVO.getSwitchCategory());
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinDataByType = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = CollectionUtils.isEmpty(residueInnerPinDataByType) ? null : residueInnerPinDataByType.get(0);
|
||
if (Objects.nonNull(elementNew)) {
|
||
skirt = coverToDesignPythonItem(elementNew.getId(), elementVO.getSwitchCategory(), elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
//是否包含skirt的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
DesignPythonItem.SKIRT_TROUSERS.contains(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
for (String type : DesignPythonItem.SKIRT_TROUSERS) {
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = residueInnerPinData.stream()
|
||
.filter(element -> element.getLevel2Type().equals(type)).findFirst().orElse(null);
|
||
if (Objects.nonNull(elementNew)) {
|
||
skirt = coverToDesignPythonItem(elementNew.getId(), type, elementNew.getUrl(), elementVO);
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加已使用的md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
if (Objects.nonNull(skirt)) {
|
||
return skirt;
|
||
}
|
||
switch (designPictureType) {
|
||
case PIN:
|
||
if (Objects.isNull(skirt)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.SKIRT_TROUSERS.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
skirt.setBusinessId(sysFileVO.getId());
|
||
return skirt;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileSkirt(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
skirt.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return skirt;
|
||
}
|
||
}
|
||
break;
|
||
// case USER_LIBRARY:
|
||
// //single模式
|
||
// if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
// if (DesignPythonItem.SKIRT_TROUSERS.contains(elementVO.getSwitchCategory())) {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// Arrays.asList(elementVO.getSwitchCategory()), elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// skirt.setBusinessId(sysFileVO.getId());
|
||
// return skirt;
|
||
// }
|
||
// skirt = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// skirt.setBusinessId(libraryVo.getId());
|
||
// }
|
||
// } else {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// DesignPythonItem.SKIRT_TROUSERS, elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileSkirt(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// skirt.setBusinessId(sysFileVO.getId());
|
||
// //添加已使用的md5
|
||
// return skirt;
|
||
// }
|
||
// skirt = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// skirt.setBusinessId(libraryVo.getId());
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// }
|
||
// break;
|
||
case SYS_FILE:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.SKIRT_TROUSERS.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
skirt.setBusinessId(sysFileVO.getId());
|
||
return skirt;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileSkirt(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
skirt.setBusinessId(sysFileVO.getId());
|
||
//添加已使用的md5
|
||
return skirt;
|
||
}
|
||
break;
|
||
case NO_PIN:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.SKIRT_TROUSERS.contains(elementVO.getSwitchCategory())) {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinDataByType =
|
||
getNoPinData(elementVO.getSketchBoardElements(), Collections.singletonList(elementVO.getSwitchCategory()));
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinDataByType, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
skirt.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
skirt = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
} else {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinData = getNoPinData(elementVO.getSketchBoardElements(), DesignPythonItem.SKIRT_TROUSERS);
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinData, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileSkirt(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
skirt = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
skirt.setBusinessId(sysFileVO.getId());
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
skirt = coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO);
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
}
|
||
return skirt;
|
||
}
|
||
|
||
private List<DesignPythonItem> calculatePythonItemBlouse(List<CollectionElement> pinData, ValidateElementVO elementVO, CurrentDesignPictureTypeEnum designPictureType) {
|
||
List<DesignPythonItem> items = Lists.newArrayList();
|
||
//剩余的的PinData
|
||
List<Long> existPinDataIds = elementVO.getExistPinDataIds();
|
||
List<CollectionElement> residuePinData = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
if (CollectionUtil.isNotEmpty(residuePinData)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(elementVO.getSwitchCategory())) {
|
||
//是否包含的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
elementVO.getSwitchCategory().equals(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
//Pin的数据
|
||
pinData = getPinDataByLevel2Type(pinData, elementVO.getSwitchCategory());
|
||
//剩余的的PinData
|
||
List<CollectionElement> residueInnerPinDataByType = residuePinData(pinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = CollectionUtils.isEmpty(residueInnerPinDataByType) ? null : residueInnerPinDataByType.get(0);
|
||
if (Objects.nonNull(elementNew)) {
|
||
items.add(coverToDesignPythonItem(elementNew.getId(), elementVO.getSwitchCategory(), elementNew.getUrl(), elementVO));
|
||
//去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
//添加MD5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
//是否包含blouse的Pin
|
||
Boolean isPin = residuePinData.stream().filter(residue ->
|
||
DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(residue.getLevel2Type())).findFirst().isPresent();
|
||
//如果包含Pin只传一个
|
||
if (isPin) {
|
||
List<CollectionElement> finalPinData = pinData;
|
||
for (String type : DesignPythonItem.OUTWEAR_DRESS_BLOUSE) {
|
||
// 剩余的的 PinData
|
||
List<CollectionElement> residueInnerPinData = residuePinData(finalPinData, existPinDataIds, elementVO.getHasUseMd5List());
|
||
CollectionElement elementNew = residueInnerPinData.stream()
|
||
.filter(element -> element.getLevel2Type().equals(type)).findFirst().orElse(null);
|
||
if (Objects.nonNull(elementNew)) {
|
||
items.add(coverToDesignPythonItem(elementNew.getId(), type, elementNew.getUrl(), elementVO));
|
||
// 去重用
|
||
existPinDataIds.add(elementNew.getId());
|
||
// 添加md5
|
||
elementVO.getHasUseMd5List().add(elementNew.getMd5());
|
||
|
||
// 提前结束循环
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
if (CollectionUtil.isNotEmpty(items)) {
|
||
return items;
|
||
}
|
||
switch (designPictureType) {
|
||
case PIN:
|
||
if (CollectionUtil.isEmpty(items)) {
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
item.setBusinessId(sysFileVO.getId());
|
||
items.add(item);
|
||
return items;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileOutwear(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
item.setBusinessId(sysFileVO.getId());
|
||
items.add(item);
|
||
return items;
|
||
}
|
||
}
|
||
break;
|
||
// case USER_LIBRARY:
|
||
// //single模式
|
||
// if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
// if (DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(elementVO.getSwitchCategory())) {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// Arrays.asList(elementVO.getSwitchCategory()), elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// item.setBusinessId(sysFileVO.getId());
|
||
// items.add(item);
|
||
// return items;
|
||
// }
|
||
// DesignPythonItem item = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// item.setBusinessId(libraryVo.getId());
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// items.add(item);
|
||
// }
|
||
// } else {
|
||
// LibraryVo libraryVo = getRandomLibrary(elementVO.getLibraryVos(),
|
||
// DesignPythonItem.OUTWEAR_DRESS_BLOUSE, elementVO.getHasUseMd5List());
|
||
// if (StringUtils.isEmpty(libraryVo)) {
|
||
// //系统获取
|
||
// SysFileVO sysFileVO = getRandomSysFileOutwear(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
// DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
// item.setBusinessId(sysFileVO.getId());
|
||
// items.add(item);
|
||
// return items;
|
||
// }
|
||
// DesignPythonItem item = coverToDesignPythonItem(null, libraryVo.getLevel2Type(), libraryVo.getUrl(), elementVO);
|
||
// item.setBusinessId(libraryVo.getId());
|
||
// elementVO.getHasUseMd5List().add(libraryVo.getMd5());
|
||
// items.add(item);
|
||
// }
|
||
// break;
|
||
case SYS_FILE:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(elementVO.getSwitchCategory())) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
item.setBusinessId(sysFileVO.getId());
|
||
items.add(item);
|
||
return items;
|
||
}
|
||
} else {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileOutwear(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
item.setBusinessId(sysFileVO.getId());
|
||
items.add(item);
|
||
return items;
|
||
}
|
||
break;
|
||
case NO_PIN:
|
||
//single模式
|
||
if (SingleOverallEnum.SINGLE.getRealName().equals(elementVO.getSingleOverall())) {
|
||
if (DesignPythonItem.OUTWEAR_DRESS_BLOUSE.contains(elementVO.getSwitchCategory())) {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinDataByType = getNoPinData(
|
||
elementVO.getSketchBoardElements(), Collections.singletonList(elementVO.getSwitchCategory()));
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinDataByType, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileByLevel2Type(elementVO.getSwitchCategory(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
item.setBusinessId(sysFileVO.getId());
|
||
items.add(item);
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
items.add(coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO));
|
||
}
|
||
}
|
||
} else {
|
||
//非Pin的数据
|
||
List<CollectionElement> noPinData = getNoPinData(elementVO.getSketchBoardElements(), DesignPythonItem.OUTWEAR_DRESS_BLOUSE);
|
||
CollectionElement collectionElement = getRandomSketchLibrary(noPinData, elementVO.getHasUseMd5List());
|
||
if (Objects.isNull(collectionElement)) {
|
||
//系统获取
|
||
SysFileVO sysFileVO = getRandomSysFileOutwear(elementVO.getSysFileVo(), elementVO.getSysFileIds(), elementVO.getModelSex());
|
||
DesignPythonItem item = coverToDesignPythonItem(null, sysFileVO.getLevel2Type(), sysFileVO.getUrl(), elementVO);
|
||
item.setBusinessId(sysFileVO.getId());
|
||
items.add(item);
|
||
} else {
|
||
elementVO.getHasUseMd5List().add(collectionElement.getMd5());
|
||
items.add(coverToDesignPythonItem(collectionElement.getId(), collectionElement.getLevel2Type(), collectionElement.getUrl(), elementVO));
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
}
|
||
return items;
|
||
}
|
||
|
||
private DesignPythonItem coverToDesignPythonItem(Long elementId, String type, String path,
|
||
ValidateElementVO elementVO) {
|
||
DesignPythonItem designPythonItemBlouse = new DesignPythonItem();
|
||
if (Objects.nonNull(elementId)) {
|
||
designPythonItemBlouse.setElementId(elementId);
|
||
designPythonItemBlouse.setBusinessId(elementId);
|
||
}
|
||
designPythonItemBlouse.setType(type);
|
||
designPythonItemBlouse.setPath(path);
|
||
//所有的icon都是none
|
||
designPythonItemBlouse.setIcon("none");
|
||
CollectionColorDTO randomColor = getRandomColor(elementVO.getColorBoards());
|
||
designPythonItemBlouse.setColor(randomColor.getRgbValue());
|
||
designPythonItemBlouse.setGradient(randomColor.getGradientMinioUrl());
|
||
designPythonItemBlouse.setGradientString(randomColor.getGradientString());
|
||
if (!elementVO.getDesignPythonItemPrint().getPath().equals("none")
|
||
&& elementVO.getDesignPrintPictureTypeLayoutList().contains(type)) {
|
||
DesignPythonItemPrint designPythonItemPrint = CopyUtil.copyObject(elementVO.getDesignPythonItemPrint(), DesignPythonItemPrint.class);
|
||
designPythonItemPrint.setIfSingle(false);
|
||
designPythonItemPrint.setPrint_path_list(Collections.singletonList(designPythonItemPrint.getPath()));
|
||
designPythonItemBlouse.setPrint(designPythonItemPrint);
|
||
} else {
|
||
DesignPythonItemPrint designPythonItemPrint = new DesignPythonItemPrint();
|
||
designPythonItemPrint.setIfSingle(false);
|
||
designPythonItemPrint.setPrint_path_list(new ArrayList<>());
|
||
designPythonItemBlouse.setPrint(designPythonItemPrint);
|
||
}
|
||
return designPythonItemBlouse;
|
||
}
|
||
|
||
private DesignPythonItem coverSketchToDesignPythonItem(Long elementId, CollectionElement collectionElement, ValidateElementVO elementVO) {
|
||
DesignPythonItem designPythonItemBlouse = new DesignPythonItem();
|
||
if (Objects.nonNull(elementId)) {
|
||
designPythonItemBlouse.setElementId(elementId);
|
||
designPythonItemBlouse.setBusinessId(elementId);
|
||
}
|
||
designPythonItemBlouse.setType(collectionElement.getLevel2Type());
|
||
designPythonItemBlouse.setPath(collectionElement.getUrl());
|
||
//所有的icon都是none
|
||
designPythonItemBlouse.setIcon("none");
|
||
CollectionColorDTO randomColor = getRandomColor(elementVO.getColorBoards());
|
||
designPythonItemBlouse.setColor(randomColor.getRgbValue());
|
||
designPythonItemBlouse.setGradient(randomColor.getGradientMinioUrl());
|
||
designPythonItemBlouse.setGradientString(randomColor.getGradientString());
|
||
if (!elementVO.getDesignPythonItemPrint().getPath().equals("none")
|
||
&& elementVO.getDesignPrintPictureTypeLayoutList().contains(collectionElement.getLevel2Type())) {
|
||
DesignPythonItemPrint designPythonItemPrint = CopyUtil.copyObject(elementVO.getDesignPythonItemPrint(), DesignPythonItemPrint.class);
|
||
designPythonItemPrint.setIfSingle(false);
|
||
designPythonItemPrint.setPrint_path_list(Collections.singletonList(designPythonItemPrint.getPath()));
|
||
designPythonItemBlouse.setPrint(designPythonItemPrint);
|
||
} else {
|
||
DesignPythonItemPrint designPythonItemPrint = new DesignPythonItemPrint();
|
||
designPythonItemPrint.setIfSingle(false);
|
||
designPythonItemPrint.setPrint_path_list(new ArrayList<>());
|
||
designPythonItemBlouse.setPrint(designPythonItemPrint);
|
||
}
|
||
return designPythonItemBlouse;
|
||
}
|
||
|
||
private List<CollectionElement> residuePinData(List<CollectionElement> pinData, List<Long> existPinDataIds, List<String> hasUseMd5List) {
|
||
if (CollectionUtils.isEmpty(pinData)) {
|
||
return null;
|
||
}
|
||
return pinData.stream().filter(v -> (!existPinDataIds.contains(v.getId()))
|
||
&& (!hasUseMd5List.contains(v.getMd5()))).collect(Collectors.toList());
|
||
}
|
||
|
||
private DesignPythonBasic coverToBasic(DesignPythonItem designPythonItem, String singleOverall,
|
||
String switchCategory, DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
DesignPythonBasic basic = new DesignPythonBasic();
|
||
basic.setSingle_overall(singleOverall);
|
||
basic.setSwitch_category(switchCategory);
|
||
// basic.setSave_name(getPythonOutputPath(
|
||
// StringUtils.isEmpty(designPythonItem.getPath()) ? designPythonItem.getBody_path() : designPythonItem.getPath(),
|
||
// PythonToJavaApiOperationTypeEnum.DESIGN_COLLECTION));
|
||
basic.setScale_bag(0.7);
|
||
basic.setSelf_template(Boolean.FALSE);
|
||
if (Objects.nonNull(designLibraryModelPoint)) {
|
||
basic.setSelf_template(Boolean.TRUE);
|
||
}
|
||
basic.setScale_earrings(0.16);
|
||
basic.setBody_point_test(getMap(designLibraryModelPoint));
|
||
return basic;
|
||
}
|
||
|
||
private Map<String, List<Integer>> getMap(DesignLibraryModelPointVO designLibraryModelPointOld) {
|
||
Map<String, List<Integer>> body_point = Maps.newHashMap();
|
||
if (Objects.nonNull(designLibraryModelPointOld)) {
|
||
DesignLibraryModelPointVO designLibraryModelPoint =
|
||
CopyUtil.copyObject(designLibraryModelPointOld, DesignLibraryModelPointVO.class);
|
||
//自己的template是6个点
|
||
body_point.put("shoulder_left", resolve(designLibraryModelPoint.getShoulderLeft()));
|
||
body_point.put("shoulder_right", resolve(designLibraryModelPoint.getShoulderRight()));
|
||
body_point.put("waistband_left", resolve(designLibraryModelPoint.getWaistbandLeft()));
|
||
body_point.put("waistband_right", resolve(designLibraryModelPoint.getWaistbandRight()));
|
||
body_point.put("hand_point_left", resolve(designLibraryModelPoint.getHandLeft()));
|
||
body_point.put("hand_point_right", resolve(designLibraryModelPoint.getHandRight()));
|
||
} else {
|
||
//默认是13个点
|
||
body_point.put("shoulder_left", Arrays.asList(755, 519));
|
||
body_point.put("shoulder_right", Arrays.asList(912, 519));
|
||
body_point.put("waistband_left", Arrays.asList(777, 725));
|
||
body_point.put("waistband_right", Arrays.asList(891, 725));
|
||
body_point.put("hand_point_left", Arrays.asList(754, 886));
|
||
body_point.put("hand_point_right", Arrays.asList(915, 886));
|
||
body_point.put("head_point_up", Arrays.asList(834, 390));
|
||
body_point.put("head_point_left", Arrays.asList(804, 424));
|
||
body_point.put("head_point_right", Arrays.asList(864, 424));
|
||
body_point.put("toe_left", Arrays.asList(817, 1355));
|
||
body_point.put("toe_right", Arrays.asList(850, 1355));
|
||
body_point.put("ear_point_left", Arrays.asList(802, 439));
|
||
body_point.put("ear_point_right", Arrays.asList(865, 438));
|
||
body_point.put("foot_length", Arrays.asList(784, 1336, 825, 1336));
|
||
}
|
||
return body_point;
|
||
}
|
||
|
||
private List<Integer> resolve(List<BigDecimal> list) {
|
||
List<Integer> integerList = Lists.newArrayList();
|
||
list.forEach(l -> {
|
||
integerList.add(new Integer(l.intValue()));
|
||
});
|
||
return integerList;
|
||
}
|
||
|
||
private List<CollectionElement> getPinData(ValidateElementVO elementVO) {
|
||
List<CollectionElement> pinData = getPinData(elementVO.getSketchBoardElements(), elementVO.getHasUseMd5List(), elementVO.getModelSex());
|
||
if (elementVO.getSingleOverall().equals(SingleOverallEnum.SINGLE.getRealName())) {
|
||
if (!CollectionUtils.isEmpty(pinData)) {
|
||
return pinData.stream().filter(o -> o.getLevel2Type().equals(elementVO.getSwitchCategory())).collect(Collectors.toList());
|
||
} else {
|
||
return pinData;
|
||
}
|
||
} else {
|
||
return pinData;
|
||
}
|
||
}
|
||
|
||
private List<CollectionElement> getPinDataWhole(ValidateElementVO elementVO) {
|
||
List<CollectionElement> pinData = getPinDataWhole(elementVO.getSketchBoardElements(), elementVO.getHasUseMd5List(), elementVO.getModelSex());
|
||
if (elementVO.getSingleOverall().equals(SingleOverallEnum.SINGLE.getRealName())) {
|
||
if (!CollectionUtils.isEmpty(pinData)) {
|
||
return pinData.stream().filter(o -> o.getLevel2Type().equals(elementVO.getSwitchCategory())).collect(Collectors.toList());
|
||
} else {
|
||
return pinData;
|
||
}
|
||
} else {
|
||
return pinData;
|
||
}
|
||
}
|
||
|
||
private List<CollectionElement> getPinDataWhole(List<CollectionElement> sketchBoardElements, List<String> hasUseMd5List, String modelSex) {
|
||
if (CollectionUtils.isEmpty(sketchBoardElements)) {
|
||
return null;
|
||
}
|
||
List<CollectionElement> sketchBoardPins = sketchBoardElements
|
||
.stream().filter(v -> v.getHasPin() == 1).collect(Collectors.toList());
|
||
if (modelSex.equals(Sex.MALE.getValue())) {
|
||
sketchBoardPins = sketchBoardPins.stream().filter(o -> MALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (modelSex.equals(Sex.FEMALE.getValue())) {
|
||
sketchBoardPins = sketchBoardPins.stream().filter(o -> FEMALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (CollectionUtils.isEmpty(sketchBoardPins)) {
|
||
return null;
|
||
}
|
||
return sketchBoardPins;
|
||
}
|
||
|
||
public final static List<String> FEMALE_CATEGORY = Arrays.asList("Dress", "Blouse", "Skirt", "Trousers", "Outwear");
|
||
public final static List<String> MALE_CATEGORY = Arrays.asList("Tops", "Bottoms", "Outwear");
|
||
|
||
private List<CollectionElement> getPinData(List<CollectionElement> sketchBoardElements, List<String> hasUseMd5List, String modelSex) {
|
||
if (CollectionUtils.isEmpty(sketchBoardElements)) {
|
||
return null;
|
||
}
|
||
List<CollectionElement> sketchBoardPins = sketchBoardElements
|
||
.stream().filter(v -> v.getHasPin() == 1 && (!hasUseMd5List.contains(v.getMd5()))).collect(Collectors.toList());
|
||
if (modelSex.equals(Sex.MALE.getValue())) {
|
||
sketchBoardPins = sketchBoardPins.stream().filter(o -> MALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (modelSex.equals(Sex.FEMALE.getValue())) {
|
||
sketchBoardPins = sketchBoardPins.stream().filter(o -> FEMALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (CollectionUtils.isEmpty(sketchBoardPins)) {
|
||
return null;
|
||
}
|
||
return sketchBoardPins;
|
||
}
|
||
|
||
private List<CollectionElement> getNoPinData(ValidateElementVO elementVO) {
|
||
if (elementVO.getSingleOverall().equals(SingleOverallEnum.SINGLE.getRealName())) {
|
||
List<CollectionElement> noPinData = getNoPinData(elementVO.getSketchBoardElements(), elementVO.getModelSex());
|
||
if (CollectionUtils.isEmpty(noPinData)) {
|
||
return null;
|
||
}
|
||
return noPinData.stream().filter(o -> o.getLevel2Type().equals(elementVO.getSwitchCategory())).collect(Collectors.toList());
|
||
} else {
|
||
return getNoPinData(elementVO.getSketchBoardElements(), elementVO.getModelSex());
|
||
}
|
||
}
|
||
|
||
private List<CollectionElement> getNoPinData(List<CollectionElement> sketchBoardElements, String modelSex) {
|
||
if (CollectionUtils.isEmpty(sketchBoardElements)) {
|
||
return null;
|
||
}
|
||
List<CollectionElement> sketchBoardPins = sketchBoardElements
|
||
.stream().filter(v -> v.getHasPin() == 0).collect(Collectors.toList());
|
||
if (modelSex.equals(Sex.MALE.getValue())) {
|
||
sketchBoardPins = sketchBoardPins.stream().filter(o -> MALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (modelSex.equals(Sex.FEMALE.getValue())) {
|
||
sketchBoardPins = sketchBoardPins.stream().filter(o -> FEMALE_CATEGORY.contains(o.getLevel2Type())).collect(Collectors.toList());
|
||
}
|
||
if (CollectionUtils.isEmpty(sketchBoardPins)) {
|
||
return null;
|
||
}
|
||
return sketchBoardPins;
|
||
}
|
||
|
||
private List<CollectionElement> resolveElementFilterHistoryMd5(List<CollectionElement> elemet) {
|
||
//查询历史design数据
|
||
List<String> md5List = elemet.stream().map(CollectionElement::getMd5).collect(Collectors.toList());
|
||
List<DesignHistory> designHistories = designHistoryService.getByMD5List(md5List);
|
||
if (CollectionUtils.isEmpty(designHistories)) {
|
||
return elemet;
|
||
}
|
||
List<String> existMd5List = designHistories.stream().map(DesignHistory::getMd5).collect(Collectors.toList());
|
||
return elemet.stream().filter(f -> !existMd5List.contains(f.getMd5())).collect(Collectors.toList());
|
||
}
|
||
|
||
private List<CollectionElement> getPinDataByLevel2Type(List<CollectionElement> sketchBoardElements, String level2Type) {
|
||
if (CollectionUtils.isEmpty(sketchBoardElements)) {
|
||
return null;
|
||
}
|
||
List<CollectionElement> sketchBoardPins = sketchBoardElements
|
||
.stream().filter(v -> v.getHasPin() == 1 && v.getLevel2Type().equals(level2Type)).collect(Collectors.toList());
|
||
if (CollectionUtils.isEmpty(sketchBoardPins)) {
|
||
return null;
|
||
}
|
||
return CopyUtil.copyList(sketchBoardPins, CollectionElement.class);
|
||
}
|
||
|
||
private List<CollectionElement> getNoPinData(List<CollectionElement> sketchBoardElements, List<String> Level2TypeList) {
|
||
if (CollectionUtils.isEmpty(sketchBoardElements)) {
|
||
return null;
|
||
}
|
||
List<CollectionElement> sketchBoardPins = sketchBoardElements
|
||
.stream().filter(v -> v.getHasPin() == 0 && Level2TypeList.contains(v.getLevel2Type())).collect(Collectors.toList());
|
||
if (CollectionUtils.isEmpty(sketchBoardPins)) {
|
||
return null;
|
||
}
|
||
return CopyUtil.copyList(sketchBoardPins, CollectionElement.class);
|
||
}
|
||
|
||
private SysFileVO getRandomSysFileOutwear(List<SysFileVO> sysFileVo, List<Long> sysFileIds, String modelSex) {
|
||
Long randomIndex = RandomsUtil.randomSysFile(0L, 3L);
|
||
if (CollectionUtils.isEmpty(sysFileVo)) {
|
||
return getRandomSysFileByLevel2Type(DesignPythonItem.OUTWEAR_DRESS_BLOUSE.get(randomIndex.intValue()), sysFileIds, modelSex);
|
||
} else {
|
||
//attribute_retrieval 算法,满足blouse + outwear+dress>8,以及 skirt+trousers>8
|
||
return getRandomSysFileByAttributeRetrieval(DesignPythonItem.OUTWEAR_DRESS_BLOUSE, sysFileVo, sysFileIds);
|
||
}
|
||
}
|
||
|
||
private SysFileVO getRandomSysFileMaleTops(List<SysFileVO> sysFileVo, List<Long> sysFileIds, String modelSex) {
|
||
Long randomIndex = RandomsUtil.randomSysFile(0L, 1L);
|
||
if (CollectionUtils.isEmpty(sysFileVo)) {
|
||
return getRandomSysFileByLevel2Type(DesignPythonItem.TOPS.get(randomIndex.intValue()), sysFileIds, modelSex);
|
||
} else {
|
||
//attribute_retrieval 算法,满足blouse + outwear+dress>8,以及 skirt+trousers>8
|
||
return getRandomSysFileByAttributeRetrieval(DesignPythonItem.TOPS, sysFileVo, sysFileIds);
|
||
}
|
||
}
|
||
|
||
private SysFileVO getRandomSysFileMaleBottoms(List<SysFileVO> sysFileVo, List<Long> sysFileIds, String modelSex) {
|
||
Long randomIndex = RandomsUtil.randomSysFile(0L, 1L);
|
||
if (CollectionUtils.isEmpty(sysFileVo)) {
|
||
return getRandomSysFileByLevel2Type(DesignPythonItem.BOTTOMS.get(randomIndex.intValue()), sysFileIds, modelSex);
|
||
} else {
|
||
//attribute_retrieval 算法,满足blouse + outwear+dress>8,以及 skirt+trousers>8
|
||
return getRandomSysFileByAttributeRetrieval(DesignPythonItem.BOTTOMS, sysFileVo, sysFileIds);
|
||
}
|
||
}
|
||
|
||
private SysFileVO getRandomSysFileSkirt(List<SysFileVO> sysFileVo, List<Long> sysFileIds, String modelSex) {
|
||
Long randomIndex = RandomsUtil.randomSysFile(0L, 2L);
|
||
if (CollectionUtils.isEmpty(sysFileVo)) {
|
||
return getRandomSysFileByLevel2Type(DesignPythonItem.SKIRT_TROUSERS.get(randomIndex.intValue()), sysFileIds, modelSex);
|
||
} else {
|
||
//attribute_retrieval 算法,满足blouse + outwear+dress>8,以及 skirt+trousers>8
|
||
return getRandomSysFileByAttributeRetrieval(DesignPythonItem.SKIRT_TROUSERS, sysFileVo, sysFileIds);
|
||
}
|
||
}
|
||
|
||
private SysFileVO getRandomSysFileByLevel2Type(String level2Type, List<Long> sysFileIds, String modelSex) {
|
||
Long maxId = sysFileService.getMaxIdByLevel2Type(level2Type, modelSex);
|
||
Long minId = sysFileService.getMinIdByLevel2Type(level2Type, modelSex);
|
||
Long sysFileId = null;
|
||
do {
|
||
sysFileId = RandomsUtil.randomSysFile(minId, maxId + 1);
|
||
} while (sysFileIds.contains(sysFileId));
|
||
sysFileIds.add(sysFileId);
|
||
return sysFileService.getById(sysFileId);
|
||
}
|
||
|
||
private SysFileVO getRandomSysFileByAttributeRetrieval(List<String> level2TypeList, List<SysFileVO> sysFileVo, List<Long> sysFileIds) {
|
||
sysFileVo = sysFileVo.stream().filter(
|
||
f -> level2TypeList.contains(f.getLevel2Type()) && (!sysFileIds.contains(f.getId())))
|
||
.collect(Collectors.toList());
|
||
Long maxId = (long) sysFileVo.size();
|
||
Long minId = 0L;
|
||
Long key = null;
|
||
Long sysFileId = null;
|
||
do {
|
||
key = RandomsUtil.randomSysFile(minId, maxId);
|
||
sysFileId = sysFileVo.get(key.intValue()).getId();
|
||
} while (sysFileIds.contains(sysFileId));
|
||
sysFileIds.add(sysFileId);
|
||
return sysFileVo.get(key.intValue());
|
||
}
|
||
|
||
private CollectionColorDTO getRandomColor(List<CollectionColorDTO> colorBoards) {
|
||
if (colorBoards.size() == 1) {
|
||
return colorBoards.get(0);
|
||
}
|
||
long maxColor = colorBoards.size();
|
||
long minColor = 0;
|
||
Long randomIndex = RandomsUtil.randomSysFile(minColor, maxColor);
|
||
return colorBoards.get(randomIndex.intValue());
|
||
}
|
||
|
||
private CollectionElement getRandomSketchLibrary(List<CollectionElement> sketchBoardElementOlds, List<String> hasUseMd5List) {
|
||
if (CollectionUtil.isEmpty(sketchBoardElementOlds)) {
|
||
return null;
|
||
}
|
||
List<CollectionElement> sketchBoardElements = sketchBoardElementOlds.stream().filter(f -> !hasUseMd5List.contains(f.getMd5())).collect(Collectors.toList());
|
||
if (CollectionUtils.isEmpty(sketchBoardElements)) {
|
||
return null;
|
||
}
|
||
if (sketchBoardElements.size() == 1) {
|
||
return sketchBoardElements.get(0);
|
||
}
|
||
long maxSketch = sketchBoardElements.size();
|
||
long minSketch = 0;
|
||
Long randomIndex = RandomsUtil.randomSysFile(minSketch, maxSketch);
|
||
return sketchBoardElements.get(randomIndex.intValue());
|
||
}
|
||
|
||
private DesignPythonItemPrint getRandomPrint(ValidateElementVO elementVO, CurrentDesignPrintPictureTypeEnum designPrintPictureType) {
|
||
//print 不取library的 只取element的
|
||
DesignPythonItemPrint print = new DesignPythonItemPrint();
|
||
if (CollectionUtil.isEmpty(elementVO.getPrintBoardElements())) {
|
||
print.setPath("none");
|
||
return print;
|
||
}
|
||
List<CollectionElement> printBoardElements;
|
||
if (designPrintPictureType.equals(CurrentDesignPrintPictureTypeEnum.PIN)) {
|
||
printBoardElements = elementVO.getPrintBoardElements()
|
||
.stream()
|
||
.filter(f -> !elementVO.getHasUseMd5List().contains(f.getMd5())).collect(Collectors.toList());
|
||
} else {
|
||
printBoardElements = elementVO.getPrintBoardElements();
|
||
}
|
||
if (CollectionUtil.isEmpty(printBoardElements)) {
|
||
print.setPath("none");
|
||
return print;
|
||
}
|
||
switch (designPrintPictureType) {
|
||
case NO:
|
||
//print 已用完
|
||
print.setPath("none");
|
||
return print;
|
||
case NO_PIN:
|
||
printBoardElements = printBoardElements.stream().filter(f -> f.getHasPin() == 0).collect(Collectors.toList());
|
||
break;
|
||
case PIN:
|
||
printBoardElements = printBoardElements.stream().filter(f -> f.getHasPin() == 1).collect(Collectors.toList());
|
||
break;
|
||
default:
|
||
}
|
||
|
||
if (printBoardElements.size() == 1) {
|
||
print.setPath(printBoardElements.get(0).getUrl());
|
||
elementVO.getHasUseMd5List().add(printBoardElements.get(0).getMd5());
|
||
return print;
|
||
}
|
||
long maxPrint = printBoardElements.size();
|
||
long minPrint = 0;
|
||
Long randomIndex = RandomsUtil.randomSysFile(minPrint, maxPrint);
|
||
print.setPath(printBoardElements.get(randomIndex.intValue()).getUrl());
|
||
elementVO.getHasUseMd5List().add(printBoardElements.get(randomIndex.intValue()).getMd5());
|
||
return print;
|
||
}
|
||
|
||
private LibraryVo getRandomLibrary(List<LibraryVo> libraryOldVos, List<String> containLevel2Type, List<String> hasUseMd5List) {
|
||
if (CollectionUtils.isEmpty(libraryOldVos)) {
|
||
return null;
|
||
}
|
||
List<LibraryVo> libraryVos = libraryOldVos.stream().filter(f -> (!hasUseMd5List.contains(f.getMd5())) &&
|
||
CollectionLevel1TypeEnum.SKETCH_BOARD.getRealName().equals(f.getLevel1Type())).collect(Collectors.toList());
|
||
if (CollectionUtils.isEmpty(libraryVos)) {
|
||
return null;
|
||
}
|
||
if (StringUtils.isEmpty(containLevel2Type)) {
|
||
if (libraryVos.size() == 1) {
|
||
return libraryVos.get(0);
|
||
}
|
||
long maxLibrary = libraryVos.size();
|
||
long minLibrary = 0;
|
||
Long randomIndex = RandomsUtil.randomSysFile(minLibrary, maxLibrary);
|
||
return libraryVos.get(randomIndex.intValue());
|
||
} else {
|
||
List<LibraryVo> filter = libraryVos.stream().filter(f -> containLevel2Type.contains(f.getLevel2Type())).collect(Collectors.toList());
|
||
if (CollectionUtils.isEmpty(filter)) {
|
||
return null;
|
||
}
|
||
if (filter.size() == 1) {
|
||
return filter.get(0);
|
||
}
|
||
long maxLibrary = filter.size();
|
||
long minLibrary = 0;
|
||
Long randomIndex = RandomsUtil.randomSysFile(minLibrary, maxLibrary);
|
||
return filter.get(randomIndex.intValue());
|
||
}
|
||
|
||
}
|
||
|
||
/**
|
||
* 生成design服装
|
||
*
|
||
* @param designPythonObjects
|
||
* @return
|
||
*/
|
||
public Boolean design(DesignPythonObjects designPythonObjects) {
|
||
//限流校验
|
||
AccessLimitUtils.validate("design", 5);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
//关闭FastJson的引用检测 防止出现$ref 现象
|
||
String param = JSON.toJSONString(designPythonObjects, SerializerFeature.DisableCircularReferenceDetect);
|
||
log.info("design请求python 参数:####{}", param);
|
||
RequestBody body = RequestBody.create(mediaType, param);
|
||
Request request = new Request.Builder()
|
||
// .url(accessPythonIp + ":" + accessPythonPort + "/api/design")
|
||
.url(fastApiPythonAddress + "/api/design")
|
||
// .url(accessPythonIp + ":10200/aifda/api/v1.0/generate")
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
try {
|
||
response = client.newCall(request).execute();
|
||
log.info("PythonService##response###{}", response);
|
||
log.info("PythonService##responseBodyStr###{}", response.body().string());
|
||
log.info("PythonService##responseBodyJson###{}", JSON.toJSONString(response.body()));
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##design异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
}
|
||
//去除限流
|
||
AccessLimitUtils.validateOut("design");
|
||
if (Objects.isNull(response)) {
|
||
log.error("PythonService##design异常###{}", "response or body is empty!");
|
||
throw new BusinessException("system error!");
|
||
}
|
||
JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(response));
|
||
log.info("PythonService##jsonObject###{}", jsonObject);
|
||
Boolean result = jsonObject.getBoolean("successful");
|
||
if (result) {
|
||
return Boolean.TRUE;
|
||
}
|
||
log.info("PythonService##design异常jsonObject###{}", jsonObject);
|
||
//生成失败
|
||
throw new BusinessException("generate design exception!");
|
||
}
|
||
|
||
/**
|
||
* 生成高级图片（废弃）
|
||
*
|
||
* @param designPath
|
||
* @return
|
||
*/
|
||
public String generateHighDesign(String designPath) {
|
||
//限流校验
|
||
AccessLimitUtils.validate("generateHighDesign", 2);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
Map<String, String> content = Maps.newHashMap();
|
||
content.put("img_path", designPath);
|
||
content.put("img_path_out_put", getPythonOutputPath(
|
||
designPath, PythonToJavaApiOperationTypeEnum.GENERATE_ADVANCED_DESIGN));
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
RequestBody body = RequestBody.create(mediaType, JSON.toJSONString(content));
|
||
Request request = new Request.Builder()
|
||
.url(accessPythonIp + ":11111/aifda/api/v1.0/sketch_to_real")
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
try {
|
||
log.info("生成高级design请求入参content###{}", JSON.toJSONString(content));
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##generateHighDesign异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
}
|
||
//去除限流
|
||
AccessLimitUtils.validateOut("generateHighDesign");
|
||
if (Objects.isNull(response)) {
|
||
log.error("PythonService##generateHighDesign异常###{}", "response or body is empty!");
|
||
throw new BusinessException("system error!");
|
||
}
|
||
JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(response));
|
||
Boolean result = jsonObject.getBoolean("successful");
|
||
if (result) {
|
||
return content.get("img_path_out_put");
|
||
}
|
||
log.info("生成高级design失败###{}", jsonObject);
|
||
//生成失败
|
||
throw new BusinessException("system error!");
|
||
}
|
||
|
||
/**
|
||
* 生成 attribute_retrieval
|
||
*
|
||
* @param sketchUrlList
|
||
* @param modelSex
|
||
* @return
|
||
*/
|
||
public DesignAttributeRetrievalDTO generateAttributeRetrieval(List<String> sketchUrlList, Long userId, String modelSex) {
|
||
//限流校验
|
||
AccessLimitUtils.validate("generateAttributeRetrieval", 4);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
Map<String, Object> content = Maps.newHashMap();
|
||
content.put("sketch_upload_img_path", sketchUrlList);
|
||
content.put("userid", userId);
|
||
content.put("colony", modelSex);
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
System.out.println(JSON.toJSONString(content));
|
||
RequestBody body = RequestBody.create(mediaType, JSON.toJSONString(content));
|
||
Request request = new Request.Builder()
|
||
// .url(accessPythonIp + ":" + accessPythonPort + "/api/attribute_retrieve")
|
||
.url(fastApiPythonAddress + "/api/attribute_retrieve")
|
||
// .url(accessPythonIp+":9991/aifda/api/v1.0/attribute_retrieval")
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response;
|
||
String bodyStr;
|
||
try {
|
||
log.info("generateAttributeRetrieval请求入参content###{}", JSON.toJSONString(content));
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
AccessLimitUtils.validateOut("generateAttributeRetrieval");
|
||
log.error("generateAttributeRetrieval异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
throw new BusinessException("attributeRetrieval.interface.exception");
|
||
}
|
||
//去除限流
|
||
AccessLimitUtils.validateOut("generateAttributeRetrieval");
|
||
if (response.isSuccessful()) {
|
||
try {
|
||
if (Objects.nonNull(response.body())) {
|
||
bodyStr = response.body().string();
|
||
return resolveDesignAttributeRetrievalDTO(bodyStr);
|
||
}
|
||
//生成失败
|
||
throw new BusinessException("attributeRetrieval.interface.exception");
|
||
} catch (JSONException | IOException e) {
|
||
log.error("generateAttributeRetrieval异常###{}", e.getMessage());
|
||
throw new BusinessException("attributeRetrieval.interface.exception");
|
||
}
|
||
}
|
||
log.error("generateAttributeRetrieval异常###{}", response);
|
||
//生成失败
|
||
throw new BusinessException("attributeRetrieval.interface.exception");
|
||
}
|
||
|
||
private static DesignAttributeRetrievalDTO resolveDesignAttributeRetrievalDTO(String bodyStr) {
|
||
DesignAttributeRetrievalDTO response = new DesignAttributeRetrievalDTO();
|
||
JSONObject jsonObject = JSON.parseObject(bodyStr);
|
||
JSONObject data = jsonObject.getJSONObject("data");
|
||
if (data != null) {
|
||
JSONObject jsonObjectSys = data.getJSONObject("sys_lib_dict");
|
||
if (null == jsonObjectSys || jsonObjectSys.isEmpty()) {
|
||
log.error("generateAttributeRetrieval异常###{}", "jsonObjectSys is empty!");
|
||
throw new BusinessException("attributeRetrieval.interface.exception");
|
||
}
|
||
setUrls(jsonObjectSys, response.getSysFileUrlS());
|
||
JSONObject jsonObjectLibrary = data.getJSONObject("user_lib_dict");
|
||
if (null == jsonObjectLibrary || jsonObjectLibrary.isEmpty()) {
|
||
log.error("generateAttributeRetrieval异常###{}", "jsonObjectLibrary is empty!");
|
||
throw new BusinessException("attributeRetrieval.interface.exception");
|
||
}
|
||
setUrls(jsonObjectLibrary, response.getLibraryUrls());
|
||
return response;
|
||
}
|
||
throw new BusinessException("attributeRetrieval.interface.exception");
|
||
}
|
||
|
||
private static void setUrls(JSONObject jsonObjectSys, List<String> urls) {
|
||
List<String> finalUrls = urls;
|
||
SysFileLevel2TypeEnum.ofPythonPath().forEach(path -> {
|
||
JSONArray array = jsonObjectSys.getJSONArray(path);
|
||
List<String> urlList = JSONObject.parseArray(JSON.toJSONString(array), String.class);
|
||
if (CollectionUtil.isNotEmpty(urlList)) {
|
||
finalUrls.addAll(urlList);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 组装和计算designSingle参数
|
||
*
|
||
* @param designSingleDTO
|
||
* @return
|
||
*/
|
||
public DesignPythonObjects covertDesignSingleParam(DesignSingleDTO designSingleDTO, String singleOverall,
|
||
String switchCategory, DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
DesignPythonObjects designPythonObjects = new DesignPythonObjects();
|
||
List<DesignPythonObject> objects = Lists.newArrayList();
|
||
designPythonObjects.setObjects(objects);
|
||
|
||
DesignPythonObject pythonObject = new DesignPythonObject();
|
||
pythonObject.setItems(coverToDesignSinglePythonItem(designSingleDTO, designLibraryModelPoint));
|
||
pythonObject.setBasic(coverToSingleBasic(pythonObject.getItems().get(0),
|
||
singleOverall, switchCategory, designSingleDTO.getPriority(), designLibraryModelPoint));
|
||
objects.add(pythonObject);
|
||
return designPythonObjects;
|
||
}
|
||
|
||
/**
|
||
* 组装和计算设计包括图层的单品的参数，不需要priority
|
||
*
|
||
* @param designSingleDTO
|
||
* @param singleOverall
|
||
* @param switchCategory
|
||
* @param designLibraryModelPoint
|
||
* @return
|
||
*/
|
||
public DesignPythonObjects covertDesignSingleParam(DesignSingleIncludeLayersDTO designSingleDTO, String singleOverall,
|
||
String switchCategory, DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
DesignPythonObjects designPythonObjects = new DesignPythonObjects();
|
||
List<DesignPythonObject> objects = Lists.newArrayList();
|
||
designPythonObjects.setObjects(objects);
|
||
|
||
DesignPythonObject pythonObject = new DesignPythonObject();
|
||
designPythonObjects.setProcess_id(designSingleDTO.getProcessId());
|
||
pythonObject.setItems(coverToDesignSinglePythonItem(designSingleDTO, designLibraryModelPoint));
|
||
pythonObject.setBasic(coverToSingleBasic(singleOverall, switchCategory, designLibraryModelPoint));
|
||
objects.add(pythonObject);
|
||
return designPythonObjects;
|
||
}
|
||
|
||
private List<DesignPythonItem> coverToDesignSinglePythonItem(DesignSingleDTO designSingleDTO, DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
List<DesignSingleItemDTO> designPythonItemDto = designSingleDTO.getClothes();
|
||
if (!CollectionUtils.isEmpty(designSingleDTO.getOthers())) {
|
||
designPythonItemDto.addAll(designSingleDTO.getOthers());
|
||
}
|
||
List<DesignPythonItem> response = CopyUtil.copyList(designPythonItemDto, DesignPythonItem.class, (o, d) -> {
|
||
d.setBusinessId(o.getId());
|
||
d.setIcon("none");
|
||
d.setPrint(resolveDesignSinglePrint(o.getPrintObject(), o.getPath()));
|
||
});
|
||
DesignPythonItem body = new DesignPythonItem();
|
||
body.setType(SysFileLevel2TypeEnum.BODY.getRealName());
|
||
if (Objects.nonNull(designLibraryModelPoint)) {
|
||
body.setBody_path(designLibraryModelPoint.getTemplateUrl());
|
||
} else {
|
||
// body.setBody_path("/home/pangkaicheng/python_code/Multi-layer-Virtual-Try-on/dataset_for_test/Img_model.png");
|
||
body.setBody_path("/workspace/python_code/Multi-layer-Virtual-Try-on/dataset_for_test/Img_model.png");
|
||
}
|
||
response.add(body);
|
||
return response;
|
||
}
|
||
|
||
/**
|
||
* 设计包括图层的单品，每次只针对一个单品
|
||
*
|
||
* @param designSingleIncludeLayersDTO
|
||
* @param designLibraryModelPoint
|
||
* @return
|
||
*/
|
||
private List<DesignPythonItem> coverToDesignSinglePythonItem(DesignSingleIncludeLayersDTO designSingleIncludeLayersDTO, DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
List<DesignSingleItemDTO> designSingleItemList = designSingleIncludeLayersDTO.getDesignSingleItemDTOList();
|
||
List<DesignPythonItem> response = new ArrayList<>();
|
||
|
||
designSingleItemList.forEach(designSingleItem -> {
|
||
Long businessId;
|
||
if (!designSingleIncludeLayersDTO.getIsPreview() && designSingleItem.getChanged()) {
|
||
String s = String.valueOf(designSingleItem.getId());
|
||
businessId = Long.parseLong(s.substring(0, s.length() - 3));
|
||
} else {
|
||
businessId = designSingleItem.getId();
|
||
}
|
||
|
||
// 判断是否是渐变色
|
||
String minioPath = null;
|
||
String gradientString = null;
|
||
if (!Objects.isNull(designSingleItem.getGradient())) {
|
||
String colorImg = designSingleItem.getGradient().getColorImg();
|
||
if (StringUtil.isNullOrEmpty(colorImg)) {
|
||
throw new BusinessException("The base64 data of the image is empty");
|
||
}
|
||
minioPath = minioUtil.base64UploadToPath(colorImg, gradientBucketName, null);
|
||
designSingleItem.getGradient().setColorImg(null);
|
||
gradientString = JSONObject.toJSONString(designSingleItem.getGradient());
|
||
|
||
// todo 当渐变色不为空时，是否需要将颜色置为 0 0 0
|
||
}
|
||
|
||
response.add(new DesignPythonItem(
|
||
designSingleItem.getType(),
|
||
designSingleItem.getPath(),
|
||
designSingleItem.getColor(),
|
||
resolveDesignSinglePrint(designSingleItem.getPrintObject(), null),
|
||
resolveDesignElement(designSingleItem.getTrims()),
|
||
// businessId designItemDetailId （python端确认没有作用,但是数据库需要存，作用：未知）
|
||
// designSingleItem.getId(),
|
||
businessId,
|
||
pythonTAllInfoService.getImageIdByPath(designSingleItem.getPath()),
|
||
designSingleItem.getOffset(),
|
||
designSingleItem.getScale(),
|
||
designSingleItem.getPriority(),
|
||
minioPath,
|
||
gradientString));
|
||
});
|
||
|
||
|
||
String bodyPath;
|
||
if (Objects.nonNull(designLibraryModelPoint)) {
|
||
bodyPath = designLibraryModelPoint.getTemplateUrl();
|
||
} else {
|
||
// bodyPath = "/workspace/python_code/Multi-layer-Virtual-Try-on/dataset_for_test/Img_model.png";
|
||
bodyPath = "aida-mannequins/model_1693218345.2714432.png";
|
||
}
|
||
response.add(new DesignPythonItem(SysFileLevel2TypeEnum.BODY.getRealName(), bodyPath, pythonTAllInfoService.getImageIdByPath(bodyPath)));
|
||
return response;
|
||
}
|
||
|
||
|
||
private DesignPythonItemPrint resolveDesignSinglePrint(DesignSinglePrintDTO printObject, String clothesPath) {
|
||
// 没有印花时的参数设置
|
||
if (printObject.getIfSingle().equals(Boolean.FALSE) && CollectionUtil.isEmpty(printObject.getPrints())) {
|
||
return new DesignPythonItemPrint(new ArrayList<>(), false);
|
||
}
|
||
DesignPythonItemPrint print = CopyUtil.copyObject(printObject, DesignPythonItemPrint.class);
|
||
|
||
int size = printObject.getPrints().size();
|
||
// 占位符填充数组
|
||
List<List<Double>> location = new ArrayList<>(Collections.nCopies(size, null));
|
||
List<Double> scale = new ArrayList<>(Collections.nCopies(size, null));
|
||
List<Double> angle = new ArrayList<>(Collections.nCopies(size, null));
|
||
ArrayList<String> paths = new ArrayList<>(Collections.nCopies(size, null));
|
||
|
||
// 设置印花的位置、大小、旋转角度
|
||
// 优先级越大，越靠近顶层，在传输给python的数组中，越靠前
|
||
List<DesignSinglePrint> prints = printObject.getPrints();
|
||
prints.forEach(p -> {
|
||
p.getLocation().set(0, p.getLocation().get(0));
|
||
p.getLocation().set(1, p.getLocation().get(1));
|
||
Integer priority = p.getPriority();
|
||
location.set(size - priority, p.getLocation());
|
||
scale.set(size - priority, p.getScale());
|
||
angle.set(size - priority, p.getAngle());
|
||
paths.set(size - priority, p.getMinIOPath());
|
||
// log.info("本次print打点locations###{}###fileVO{}", p.getLocation(), JSON.toJSONString(fileVO));
|
||
});
|
||
print.setLocation(location);
|
||
print.setPrint_scale_list(scale);
|
||
print.setPrint_angle_list(angle);
|
||
print.setPrint_path_list(paths);
|
||
|
||
return print;
|
||
}
|
||
|
||
private DesignPythonItemElement resolveDesignElement(DesignSinglePrintDTO trims) {
|
||
// 没有design element 时的参数设置
|
||
if (Objects.isNull(trims.getIfSingle()) && CollectionUtil.isEmpty(trims.getPrints())) {
|
||
return null;
|
||
}
|
||
DesignPythonItemElement print = new DesignPythonItemElement();
|
||
|
||
int size = trims.getPrints().size();
|
||
// 占位符填充数组
|
||
List<List<Double>> location = new ArrayList<>(Collections.nCopies(size, null));
|
||
List<Double> scale = new ArrayList<>(Collections.nCopies(size, null));
|
||
List<Double> angle = new ArrayList<>(Collections.nCopies(size, null));
|
||
ArrayList<String> paths = new ArrayList<>(Collections.nCopies(size, null));
|
||
|
||
// 设置印花的位置、大小、旋转角度
|
||
// 优先级越大，越靠近顶层，在传输给python的数组中，越靠前
|
||
List<DesignSinglePrint> prints = trims.getPrints();
|
||
prints.forEach(p -> {
|
||
p.getLocation().set(0, p.getLocation().get(0));
|
||
p.getLocation().set(1, p.getLocation().get(1));
|
||
Integer priority = p.getPriority();
|
||
location.set(size - priority, p.getLocation());
|
||
scale.set(size - priority, p.getScale());
|
||
angle.set(size - priority, p.getAngle());
|
||
paths.set(size - priority, p.getMinIOPath());
|
||
// log.info("本次print打点locations###{}###fileVO{}", p.getLocation(), JSON.toJSONString(fileVO));
|
||
});
|
||
print.setLocation(location);
|
||
print.setElement_scale_list(scale);
|
||
print.setElement_angle_list(angle);
|
||
print.setElement_path_list(paths);
|
||
|
||
return print;
|
||
}
|
||
|
||
private DesignPythonBasic coverToSingleBasic(DesignPythonItem designPythonItem, String singleOverall,
|
||
String switchCategory, List<String> priority,
|
||
DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
DesignPythonBasic basic = new DesignPythonBasic();
|
||
basic.setSingle_overall(singleOverall);
|
||
basic.setSwitch_category(switchCategory);
|
||
basic.setSave_name(getPythonOutputPath(
|
||
StringUtils.isEmpty(designPythonItem.getPath()) ? designPythonItem.getBody_path() : designPythonItem.getPath(),
|
||
PythonToJavaApiOperationTypeEnum.DESIGN_COLLECTION));
|
||
basic.setPriority(priority);
|
||
basic.setSelf_template(Boolean.FALSE);
|
||
if (Objects.nonNull(designLibraryModelPoint)) {
|
||
basic.setSelf_template(Boolean.TRUE);
|
||
}
|
||
basic.setScale_bag(0.7);
|
||
basic.setScale_earrings(0.16);
|
||
basic.setBody_point_test(getMap(designLibraryModelPoint));
|
||
return basic;
|
||
}
|
||
|
||
/**
|
||
* 设计包括图层的单品，不用指定save_name和priority
|
||
*
|
||
* @param singleOverall
|
||
* @param switchCategory
|
||
* @param designLibraryModelPoint
|
||
* @return
|
||
*/
|
||
private DesignPythonBasic coverToSingleBasic(String singleOverall, String switchCategory,
|
||
DesignLibraryModelPointVO designLibraryModelPoint) {
|
||
DesignPythonBasic basic = new DesignPythonBasic();
|
||
basic.setSingle_overall(singleOverall);
|
||
basic.setSwitch_category(switchCategory);
|
||
basic.setSelf_template(Boolean.FALSE);
|
||
if (Objects.nonNull(designLibraryModelPoint)) {
|
||
basic.setSelf_template(Boolean.TRUE);
|
||
}
|
||
basic.setScale_bag(0.7);
|
||
basic.setScale_earrings(0.16);
|
||
basic.setBody_point_test(getMap(designLibraryModelPoint));
|
||
basic.setLayer_order(Boolean.TRUE);
|
||
return basic;
|
||
}
|
||
|
||
/**
|
||
* 组装和计算designSingle参数
|
||
*
|
||
* @param modelsDotDTO
|
||
* @return
|
||
*/
|
||
public DesignPythonObjects covertModelsDotParam(ModelsDotDTO modelsDotDTO, String singleOverall, String switchCategory) {
|
||
DesignPythonObjects designPythonObjects = new DesignPythonObjects();
|
||
List<DesignPythonObject> objects = Lists.newArrayList();
|
||
designPythonObjects.setObjects(objects);
|
||
designPythonObjects.setProcess_id(UUID.randomUUID().toString());
|
||
DesignPythonObject pythonObject = new DesignPythonObject();
|
||
pythonObject.setItems(coverToModelsDotPythonItem(modelsDotDTO));
|
||
pythonObject.setBasic(coverToModelsDotBasic(pythonObject.getItems().get(0), modelsDotDTO));
|
||
objects.add(pythonObject);
|
||
return designPythonObjects;
|
||
}
|
||
|
||
private List<DesignPythonItem> coverToModelsDotPythonItem(ModelsDotDTO modelsDotDTO) {
|
||
List<DesignPythonItem> response = Lists.newArrayList();
|
||
if (modelsDotDTO.getTemplateUrl().contains("female")) {
|
||
DesignPythonItem dress = new DesignPythonItem();
|
||
dress.setType(SysFileLevel2TypeEnum.DRESS.getRealName());
|
||
dress.setColor("none");
|
||
dress.setIcon("none");
|
||
DesignPythonItemPrint designPythonItemPrint = new DesignPythonItemPrint();
|
||
designPythonItemPrint.setIfSingle(false);
|
||
designPythonItemPrint.setPrint_path_list(new ArrayList<>());
|
||
dress.setPrint(designPythonItemPrint);
|
||
dress.setPath("aida-sys-image/images/female/blouse/blouse_p5_817.jpg");
|
||
response.add(dress);
|
||
|
||
DesignPythonItem skirt = new DesignPythonItem();
|
||
skirt.setType(SysFileLevel2TypeEnum.TROUSERS.getRealName());
|
||
skirt.setColor("none");
|
||
skirt.setIcon("none");
|
||
skirt.setPrint(designPythonItemPrint);
|
||
skirt.setPath("aida-sys-image/images/female/trousers/trousers_974.jpg");
|
||
response.add(skirt);
|
||
} else {
|
||
DesignPythonItem top = new DesignPythonItem();
|
||
top.setType(MalePosition.TOPS.getValue());
|
||
top.setColor("none");
|
||
top.setIcon("none");
|
||
DesignPythonItemPrint designPythonItemPrint = new DesignPythonItemPrint();
|
||
designPythonItemPrint.setIfSingle(false);
|
||
designPythonItemPrint.setPrint_path_list(new ArrayList<>());
|
||
top.setPrint(designPythonItemPrint);
|
||
top.setPath("aida-sys-image/images/male/tops/mens_test_10.png");
|
||
response.add(top);
|
||
|
||
DesignPythonItem bottom = new DesignPythonItem();
|
||
bottom.setType(MalePosition.BOTTOMS.getValue());
|
||
bottom.setColor("none");
|
||
bottom.setIcon("none");
|
||
DesignPythonItemPrint designPythonItemPrint1 = new DesignPythonItemPrint();
|
||
designPythonItemPrint1.setIfSingle(false);
|
||
designPythonItemPrint1.setPrint_path_list(new ArrayList<>());
|
||
bottom.setPrint(designPythonItemPrint1);
|
||
bottom.setPath("aida-sys-image/images/male/bottoms/mens_test_10007.png");
|
||
response.add(bottom);
|
||
}
|
||
|
||
DesignPythonItem body = new DesignPythonItem();
|
||
body.setType(SysFileLevel2TypeEnum.BODY.getRealName());
|
||
body.setBody_path(modelsDotDTO.getTemplateUrl());
|
||
response.add(body);
|
||
return response;
|
||
}
|
||
|
||
private DesignPythonBasic coverToModelsDotBasic(DesignPythonItem designPythonItem, ModelsDotDTO modelsDotDTO) {
|
||
DesignPythonBasic basic = new DesignPythonBasic();
|
||
basic.setSingle_overall(SingleOverallEnum.OVERALL.getRealName());
|
||
basic.setSwitch_category("");
|
||
basic.setSave_name(getPythonOutputPath(
|
||
StringUtils.isEmpty(designPythonItem.getPath()) ? designPythonItem.getBody_path() : designPythonItem.getPath(),
|
||
PythonToJavaApiOperationTypeEnum.DESIGN_COLLECTION));
|
||
basic.setSelf_template(Boolean.TRUE);
|
||
basic.setScale_bag(0.7);
|
||
basic.setScale_earrings(0.16);
|
||
|
||
basic.setBody_point_test(getMap(calculateTemplatePoint(modelsDotDTO, modelsDotDTO.getHigh(), modelsDotDTO.getWidth())));
|
||
return basic;
|
||
}
|
||
|
||
public DesignLibraryModelPointVO calculateTemplatePoint(ModelsDotDTO modelsDotDTO, Integer high, Integer width) {
|
||
DesignLibraryModelPointVO libraryModelPoint = new DesignLibraryModelPointVO();
|
||
libraryModelPoint.setHandLeft(calculateTemplatePointOne(modelsDotDTO.getHandLeft(), high, width));
|
||
libraryModelPoint.setHandRight(calculateTemplatePointOne(modelsDotDTO.getHandRight(), high, width));
|
||
libraryModelPoint.setShoulderLeft(calculateTemplatePointOne(modelsDotDTO.getShoulderLeft(), high, width));
|
||
libraryModelPoint.setShoulderRight(calculateTemplatePointOne(modelsDotDTO.getShoulderRight(), high, width));
|
||
libraryModelPoint.setWaistbandLeft(calculateTemplatePointOne(modelsDotDTO.getWaistbandLeft(), high, width));
|
||
libraryModelPoint.setWaistbandRight(calculateTemplatePointOne(modelsDotDTO.getWaistbandRight(), high, width));
|
||
return libraryModelPoint;
|
||
}
|
||
|
||
private List<BigDecimal> calculateTemplatePointOne(List<BigDecimal> originRatioList, Integer high, Integer width) {
|
||
originRatioList.set(0, originRatioList.get(0).multiply(BigDecimal.valueOf(width)));
|
||
originRatioList.set(1, originRatioList.get(1).multiply(BigDecimal.valueOf(high)));
|
||
return originRatioList;
|
||
}
|
||
|
||
public JSONObject designNew(DesignPythonObjects designPythonObjects) {
|
||
// todo 限流校验
|
||
// AccessLimitUtils.validate("design",5);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
//关闭FastJson的引用检测 防止出现$ref 现象
|
||
String param = JSON.toJSONString(designPythonObjects, SerializerFeature.DisableCircularReferenceDetect);
|
||
log.info("design请求python 参数:####{}", param);
|
||
RequestBody body = RequestBody.create(mediaType, param);
|
||
Request request = new Request.Builder()
|
||
.url(accessPythonIp + ":" + accessPythonPort + "/api/design")
|
||
// .url(fastApiPythonAddress + "/api/design")
|
||
// .url(accessPythonIp + ":10200/aifda/api/v1.0/generate")
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response;
|
||
String responseBody;
|
||
try {
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
AccessLimitUtils.validateOut("design");
|
||
log.error("PythonService##design异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
throw new BusinessException("design.interface.exception");
|
||
}
|
||
//去除限流
|
||
// AccessLimitUtils.validateOut("design");
|
||
if (response.isSuccessful()) {
|
||
try {
|
||
if (Objects.nonNull(response.body())) {
|
||
responseBody = response.body().string();
|
||
JSONObject responseObject = JSON.parseObject(responseBody);
|
||
log.info("PythonService##responseObject###{}", responseObject);
|
||
return responseObject;
|
||
}
|
||
throw new BusinessException("design.interface.exception");
|
||
} catch (IOException | JSONException e) {
|
||
log.error("PythonService##design异常###{}", e.getMessage());
|
||
throw new BusinessException("design.interface.exception");
|
||
}
|
||
}
|
||
log.error("PythonService##design异常response###{}", response);
|
||
//生成失败
|
||
throw new BusinessException("design.interface.exception");
|
||
}
|
||
|
||
/**
|
||
* 暂时未用
|
||
*/
|
||
public String generateSketchCaption(String url) {
|
||
//限流校验
|
||
AccessLimitUtils.validate("generateSketchCaption", 5);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
RequestBody body = RequestBody.create(mediaType, url);
|
||
Request request = new Request.Builder()
|
||
.url(accessPythonIp + ":" + accessPythonPort + "/aida/interrogator")
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
String bodyStr = null;
|
||
try {
|
||
log.info("generateSketchCaption请求入参content###{}", url);
|
||
response = client.newCall(request).execute();
|
||
bodyStr = response.body().string();
|
||
} catch (IOException ioException) {
|
||
log.error("generateSketchCaption异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
}
|
||
//去除限流
|
||
AccessLimitUtils.validateOut("generateSketchCaption");
|
||
if (Objects.isNull(response)) {
|
||
log.error("generateSketchCaption异常###{}", "response or body is empty!");
|
||
throw new BusinessException("system error!");
|
||
}
|
||
JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(response));
|
||
Boolean result = jsonObject.getBoolean("successful");
|
||
if (result) {
|
||
return bodyStr;
|
||
}
|
||
log.info("attribute_retrieval失败###{}", bodyStr);
|
||
//生成失败
|
||
throw new BusinessException("system error!");
|
||
}
|
||
|
||
public Boolean generateSketchOrPrint(String params, String port, String servicePath) {
|
||
//限流校验
|
||
// AccessLimitUtils.validate("generateSketchOrPrint", 5);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
// RequestBody body = RequestBody.create(mediaType, JSON.toJSONString(generateToPythonDTO, SerializerFeature.WriteMapNullValue));
|
||
RequestBody body = RequestBody.create(mediaType, params);
|
||
Request request = new Request.Builder()
|
||
// .url("http://18.167.251.121:9992")
|
||
// .url("http://127.0.0.1:5000/api/diffusion")
|
||
// .url(accessPythonIp + ":" + accessPythonPort + "/api/diffusion")
|
||
// .url(accessPythonIp + ":" + accessPythonPort + "/api/generate_image")
|
||
.url(accessPythonIp + ":" + port + servicePath)
|
||
.method("POST", body)
|
||
// .addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
String bodyString;
|
||
try {
|
||
// log.info("generateSketchOrPrint请求入参content###{}", JSON.toJSONString(generateToPythonDTO, SerializerFeature.WriteMapNullValue));
|
||
log.info("generateSketchOrPrint请求入参content###{}", params);
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##generateSketchOrPrint异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
// throw new BusinessException("generate.interface.error");
|
||
throw new BusinessException(ioException.getMessage());
|
||
}
|
||
//去除限流
|
||
// AccessLimitUtils.validateOut("generateSketchOrPrint");
|
||
|
||
// 判断是否生成失败
|
||
if (Objects.isNull(response.body())) {
|
||
log.error("PythonService##generateSketchOrPrint异常###{}", "response or body is empty!");
|
||
// throw new BusinessException("generate.interface.error");
|
||
throw new BusinessException("PythonService##generateSketchOrPrint异常###: response or body is empty!");
|
||
} else if (response.code() != HttpURLConnection.HTTP_OK) {
|
||
log.error("PythonService##generateSketchOrPrint异常###{}", "Response error!Response code ## " + response.code() + " ##");
|
||
// throw new BusinessException("generate.interface.error");
|
||
throw new BusinessException("PythonService##generateSketchOrPrint异常### Response error!Response code ## " + response.code() + " ##");
|
||
} else {
|
||
try {
|
||
bodyString = response.body().string();
|
||
} catch (IOException e) {
|
||
log.error(e.getMessage());
|
||
// throw new BusinessException("generate.interface.error");
|
||
throw new BusinessException(e.getMessage());
|
||
}
|
||
}
|
||
JSONObject jsonObject = JSON.parseObject(bodyString);
|
||
Boolean result = JSON.parseObject(JSON.toJSONString(response)).getBoolean("successful");
|
||
|
||
if (result && jsonObject.get("code").equals(200)) {
|
||
log.info("Generate##responseObject###{}", jsonObject);
|
||
// return setGenerateImageList(jsonObject.getJSONObject("data"));
|
||
return Boolean.TRUE;
|
||
} else {
|
||
log.info("generateSketchOrPrintPrint失败###{}", jsonObject);
|
||
log.info("Generate Exception! Code : " + jsonObject.get("code"));
|
||
return Boolean.FALSE;
|
||
}
|
||
}
|
||
|
||
public Response sendPostToModel(String content, String portAndRoute, String functionName) {
|
||
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
RequestBody body = RequestBody.create(mediaType, content);
|
||
Request request = new Request.Builder()
|
||
.url(accessPythonIp + ":" + accessPythonPort + portAndRoute)
|
||
// .url(fastApiPythonAddress + portAndRoute)
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
// String bodyString = null;
|
||
try {
|
||
log.info(functionName + "请求入参content###{}", content);
|
||
response = client.newCall(request).execute();
|
||
// bodyString = response.body().string();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##" + functionName + "异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
}
|
||
return response;
|
||
}
|
||
|
||
private List<String> setGenerateImageList(JSONObject jsonObject) {
|
||
List<String> imageUrlList = JSONObject.parseArray(jsonObject.get("list").toString(), String.class);
|
||
if (imageUrlList.isEmpty()) {
|
||
log.error("PythonService##generateSketchOrPrint异常###{}", "diffusion response list is null");
|
||
// 如果这里返回为空，是判断出错还是返回给前端空
|
||
throw new BusinessException("The data returned on the python side is empty");
|
||
}
|
||
|
||
return imageUrlList;
|
||
}
|
||
/** 废弃状态 */
|
||
public String composeLayers(List<OutfitDetailPythonItem> layersDetail) {
|
||
HashMap<String, List<OutfitDetailPythonItem>> layers = new HashMap<>();
|
||
HashMap<String, HashMap<String, List<OutfitDetailPythonItem>>> content = new HashMap<>();
|
||
layers.put("layers", layersDetail);
|
||
content.put("0", layers);
|
||
String jsonString = JSON.toJSONString(content, SerializerFeature.WriteNullStringAsEmpty);
|
||
|
||
// todo 添加限流
|
||
Response response = this.sendPostToModel(jsonString, "/api/preview_control", "composeLayers");
|
||
// todo 结束限流
|
||
|
||
String bodyString;
|
||
// 生成失败
|
||
if (Objects.isNull(response) || Objects.isNull(response.body())) {
|
||
log.error("PythonService##composeLayers异常###{}", "response or body is empty!");
|
||
throw new BusinessException("compose-layer.interface.exception");
|
||
} else if (response.code() != HttpURLConnection.HTTP_OK) {
|
||
log.error("PythonService##composeLayers异常###{}", "Response error!Response code ## " + response.code() + " ##");
|
||
throw new BusinessException("compose-layer.interface.exception");
|
||
} else {
|
||
try {
|
||
bodyString = response.body().string();
|
||
} catch (IOException e) {
|
||
throw new BusinessException("compose-layer.interface.exception");
|
||
}
|
||
}
|
||
JSONObject jsonObject = JSON.parseObject(bodyString);
|
||
Boolean result = JSON.parseObject(JSON.toJSONString(response)).getBoolean("successful");
|
||
if (result && jsonObject.get("msg").equals("OK!")) {
|
||
return getCompositeImage(jsonObject.getJSONObject("code"));
|
||
}
|
||
log.info("composeLayers 失败###{}", jsonObject);
|
||
//生成失败
|
||
throw new BusinessException("compose-layer.interface.exception");
|
||
}
|
||
|
||
private String getCompositeImage(JSONObject jsonObject) {
|
||
JSONObject item0 = jsonObject.getJSONObject("0");
|
||
return item0.getString("synthesis_url");
|
||
}
|
||
|
||
public String getClothCategory(String path, String gender) {
|
||
HashMap<String, String> content = new HashMap<>();
|
||
content.put("sketch_img_url", path);
|
||
content.put("colony", gender);
|
||
List<HashMap<String, String>> contents = Collections.singletonList(content);
|
||
String jsonString = JSON.toJSONString(contents, SerializerFeature.WriteNullStringAsEmpty);
|
||
|
||
// todo 添加限流
|
||
Response response = this.sendPostToModel(jsonString, "/api/category_recognition", "getClothCategory");
|
||
// todo 结束限流
|
||
|
||
String bodyString;
|
||
// 生成失败
|
||
if (Objects.isNull(response) || Objects.isNull(response.body())) {
|
||
log.error("PythonService##GetClothCategory###{}", "response or body is empty!");
|
||
throw new BusinessException("cloth-classification.interface.exception");
|
||
} else if (response.code() != HttpURLConnection.HTTP_OK) {
|
||
log.error("PythonService##GetClothCategory###{}", "Response error!Response code ## " + response.code() + " ##");
|
||
throw new BusinessException("cloth-classification.interface.exception");
|
||
} else {
|
||
try {
|
||
bodyString = response.body().string();
|
||
} catch (IOException e) {
|
||
throw new BusinessException("cloth-classification.interface.exception");
|
||
}
|
||
}
|
||
JSONObject jsonObject = JSON.parseObject(bodyString);
|
||
try {
|
||
Boolean result = JSON.parseObject(JSON.toJSONString(response)).getBoolean("successful");
|
||
if (result && jsonObject.get("msg").equals("OK!")) {
|
||
JSONObject data = jsonObject.getJSONObject("data");
|
||
JSONArray list = JSONArray.parseArray(data.get("list").toString());
|
||
JSONObject map = (JSONObject) list.get(0);
|
||
return map.get("category").toString();
|
||
}
|
||
} catch (NullPointerException e) {
|
||
log.info("getClothCategory 失败###{}，未返回category", jsonObject);
|
||
throw new BusinessException("cloth-classification.interface.exception");
|
||
}
|
||
log.info("getClothCategory 失败###{}", jsonObject);
|
||
//生成失败
|
||
throw new BusinessException("cloth-classification.interface.exception");
|
||
}
|
||
|
||
public Boolean cancelGenerateTask(String taskId) {
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
// String url = accessPythonIp + ":" + accessPythonPort + "/api/generate_cancel/" + taskId;
|
||
String url = fastApiPythonAddress + "/api/generate_cancel/" + taskId;
|
||
Request request = new Request.Builder()
|
||
.url(url)
|
||
// .addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
// .addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
try {
|
||
log.info("cancelGenerateTask请求入参content###{}", taskId);
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##cancelGenerateTask异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
return null;
|
||
}
|
||
int responseCode = response.code();
|
||
response.close();
|
||
|
||
if (responseCode != HttpURLConnection.HTTP_OK) {
|
||
log.info("generate-python 取消请求失败");
|
||
return Boolean.FALSE;
|
||
}
|
||
log.info("generate-python 取消请求成功");
|
||
return Boolean.TRUE;
|
||
}
|
||
|
||
public Boolean superResolution(SuperResolutionDTO superResolutionDTO) throws BusinessException {
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
|
||
HashMap<String, String> content = new HashMap<>();
|
||
content.put("sr_image_url", superResolutionDTO.getImages());
|
||
content.put("sr_xn", superResolutionDTO.getScale().toString());
|
||
content.put("sr_tasks_id", superResolutionDTO.getUniqueId());
|
||
|
||
String jsonString = JSON.toJSONString(content, SerializerFeature.WriteNullStringAsEmpty);
|
||
RequestBody body = RequestBody.create(mediaType, jsonString);
|
||
Request request = new Request.Builder()
|
||
.url(fastApiPythonAddress + "/api/super_resolution")
|
||
.method("POST", body)
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
try {
|
||
log.info("superResolution请求入参content###{}", jsonString);
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##superResolution异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
return null;
|
||
}
|
||
int responseCode = response.code();
|
||
response.close();
|
||
|
||
if (responseCode != HttpURLConnection.HTTP_OK) {
|
||
// 基本不会有除200以外的code
|
||
log.info("superResolution 请求超分操作失败。 Response code " + response.code());
|
||
throw new BusinessException("superResolution 请求超分操作失败。 Response code " + response.code());
|
||
}
|
||
log.info("superResolution 请求超分操作成功");
|
||
return Boolean.TRUE;
|
||
}
|
||
|
||
public String promptTranslate(String text) throws BusinessException {
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
|
||
HashMap<String, String> content = new HashMap<>();
|
||
content.put("text", text);
|
||
|
||
String jsonString = JSON.toJSONString(content, SerializerFeature.WriteNullStringAsEmpty);
|
||
RequestBody body = RequestBody.create(mediaType, jsonString);
|
||
Request request = new Request.Builder()
|
||
// .url(accessPythonIp + ":" + accessPythonPort + "/api/translateToEN")
|
||
.url(fastApiPythonAddress + "/api/translateToEN")
|
||
.method("POST", body)
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response = null;
|
||
try {
|
||
log.info("promptTranslation请求入参content###{}", jsonString);
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##promptTranslation异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
return text;
|
||
}
|
||
int responseCode = response.code();
|
||
String bodyString;
|
||
try {
|
||
bodyString = response.body().string();
|
||
if (responseCode != HttpURLConnection.HTTP_OK) {
|
||
// 基本不会有除200以外的code
|
||
log.info("promptTranslation 用户输入翻译失败。 Response code " + responseCode);
|
||
throw new BusinessException("promptTranslation 用户输入翻译失败。 Response code " + responseCode);
|
||
}
|
||
JSONObject jsonObject = JSON.parseObject(bodyString);
|
||
Boolean result = JSON.parseObject(JSON.toJSONString(response)).getBoolean("successful");
|
||
if (result && jsonObject.get("msg").equals("OK!")) {
|
||
String translated = jsonObject.get("data").toString();
|
||
log.info("翻译或处理后的文本 ： {}", translated);
|
||
return translated;
|
||
}
|
||
} catch (IOException e) {
|
||
log.error("promptTranslation 用户输入翻译失败; error message => " + e.getMessage());
|
||
throw new RuntimeException(e);
|
||
|
||
} finally {
|
||
response.close();
|
||
}
|
||
|
||
log.info("promptTranslation 用户输入翻译失败，返回用户输入");
|
||
return text;
|
||
}
|
||
|
||
public Boolean toProductImage(String url, String taskId, String prompt) {
|
||
// todo 限流校验
|
||
// AccessLimitUtils.validate("design",5);
|
||
OkHttpClient client = new OkHttpClient().newBuilder()
|
||
.connectTimeout(30, TimeUnit.SECONDS)
|
||
.pingInterval(5, TimeUnit.SECONDS)//websocket轮训间隔(单位:秒)
|
||
.readTimeout(60, TimeUnit.SECONDS)//读取超时(单位:秒)
|
||
.writeTimeout(60, TimeUnit.SECONDS)//写入超时(单位:秒)
|
||
.build();
|
||
MediaType mediaType = MediaType.parse("application/json");
|
||
//关闭FastJson的引用检测 防止出现$ref 现象
|
||
Map<String, String> map = new HashMap<>();
|
||
map.put("tasks_id", taskId);
|
||
map.put("image_url", url);
|
||
map.put("prompt", prompt);
|
||
log.info("toProductImage请求python 参数:####{}", map);
|
||
String param = JSON.toJSONString(map, SerializerFeature.WriteNullStringAsEmpty);
|
||
RequestBody body = RequestBody.create(mediaType, param);
|
||
Request request = new Request.Builder()
|
||
// .url(accessPythonIp + ":" + accessPythonPort + "/api/generate_product_image")
|
||
.url(accessPythonIp + ":9996/api/generate_product_image")
|
||
.method("POST", body)
|
||
.addHeader("Authorization", "Basic YWlkbGFiOjEyMw==")
|
||
.addHeader("Content-Type", "application/json")
|
||
.build();
|
||
Response response;
|
||
String responseBody;
|
||
try {
|
||
response = client.newCall(request).execute();
|
||
} catch (IOException ioException) {
|
||
log.error("PythonService##toProductImage异常###{}", ExceptionUtil.getThrowableList(ioException));
|
||
throw new BusinessException("toProductImage.interface.exception");
|
||
}
|
||
if (response.isSuccessful()) {
|
||
return Boolean.TRUE;
|
||
}
|
||
log.error("PythonService##toProductImage异常response###{}", response);
|
||
//生成失败
|
||
throw new BusinessException("toProductImage.interface.exception");
|
||
}
|
||
}
|