Liu Haoyu / vehicle-simple

package com.objecteye.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.objecteye.pojo.VehicleDetails;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import sun.misc.BASE64Encoder;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.ArrayList;

@Component
public class VehicleDetailsUtils {

    @Value("${snapshotPrefix}")
    private String snapshotPrefix;
    @Value("${picture.storePath}")
    private String storePath;


    private float sdkThreshold = 0.7F;  //sdk的阈值
    private float cpsbThreshold = 0.9F;  //车牌识别的阈值
    private String errorMsg = "识别异常";

    /**
     * 将SDK中的数据封装成VehicleDetails类
     */
    public VehicleDetails sdkToVehicleDetails(JSONObject vehicleDetailsOne) {
        VehicleDetails vehicleDetails = new VehicleDetails();
        //因为是用户上传过来的数据，所以图片路径为空
        vehicleDetails.setPicurl(null);  //图片路径
        //获取车辆类型
        JSONObject vehicle_recg_res = vehicleDetailsOne.getJSONObject("vehicle_recg_res");
        Float name_score = vehicle_recg_res.getFloat("name_score");
        String vehicle_type = errorMsg;
        String vehicle_recg_info = errorMsg;
        if (name_score > sdkThreshold) {
            name_score = (float) Math.round(name_score * 100) / 100;
            if (name_score > 1) {
                name_score = 1F;
            }
            vehicle_type = vehicle_recg_res.getString("vehicle_type");
            String vehicle_brand = vehicle_recg_res.getString("vehicle_brand");
            String vehicle_subbrand = vehicle_recg_res.getString("vehicle_subbrand");
            String vehicle_issue_year = vehicle_recg_res.getString("vehicle_issue_year");
            vehicle_recg_info = vehicle_brand + "-" + vehicle_subbrand + "-" + vehicle_issue_year;
        }
        vehicleDetails.setVehicle_recg_type(vehicle_type);   //车辆类型
        vehicleDetails.setVehicle_recg_brand(vehicle_recg_info);   //车辆品牌型号(检测得到的车品牌、车子品牌、年份拼接而成)
        vehicleDetails.setVehicle_recg_name_score(name_score);  //品牌可信度

        //获取车身颜色
        JSONObject vehicle_color_res = vehicleDetailsOne.getJSONObject("vehicle_color_res");
        Float colorScore = vehicle_color_res.getFloat("score");
        String vehicleColor = errorMsg;
        if (colorScore > sdkThreshold) {
            Integer vehicle_color_index = vehicle_color_res.getInteger("index");
            vehicleColor = RelationMappingUtil.getVehicleColor(vehicle_color_index);
        }
        vehicleDetails.setVehicle_color(vehicleColor);  //车颜色

        //获取车辆号牌信息
        JSONObject vehicle_plate_det_recg_res = vehicleDetailsOne.getJSONObject("vehicle_plate_det_recg_res");
        Float numScore = vehicle_plate_det_recg_res.getFloat("numScore");
        String vehiclePlateType = errorMsg;
        String plateHPHM = errorMsg;
        String ehicle_plate_status = "无号牌";
        if (numScore > cpsbThreshold) {
            numScore = (float) Math.round(numScore * 100) / 100;
            if (numScore > 1) {
                numScore = 1F;
            }

            Integer type = vehicle_plate_det_recg_res.getInteger("type");
            vehiclePlateType = RelationMappingUtil.getVehiclePlateType(type);

            JSONArray plateNumParams = vehicle_plate_det_recg_res.getJSONArray("plateNumParams");
            int size = plateNumParams.size();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < size; i++) {
                JSONObject plateNumParamOne = plateNumParams.getJSONObject(i);
                Float maxprob = plateNumParamOne.getFloat("maxprob");//每位号牌可信度
                String character = "*"; //每位号牌，默认为*，当置信度低于某个值时设置为*
                if (maxprob >= sdkThreshold) {
                    character = plateNumParamOne.getString("character");
                }
                character = plateNumParamOne.getString("character");
                sb.append(character);
            }
            plateHPHM = sb.toString();
            //判断车牌状态
            if (plateHPHM.contains("*")) {
                ehicle_plate_status = "污损号牌";
            } else {
                ehicle_plate_status = "完整号牌";
            }
        }
        vehicleDetails.setVehicle_plate_type(vehiclePlateType);  //车牌类型
        vehicleDetails.setVehicle_plate_hphm(plateHPHM); //车牌号码
        vehicleDetails.setVehicle_plate_detectScore(numScore);  //车牌可信度
        vehicleDetails.setVehicle_plate_status(ehicle_plate_status); //车牌状态


        //获取特殊车辆类型：渣土车   危化品车    其他
        JSONObject vehicle_special_res = vehicleDetailsOne.getJSONObject("vehicle_special_res");
        Float specialScore = vehicle_special_res.getFloat("score");
        String vehicleSpecialType = errorMsg;
        if (specialScore > sdkThreshold) {
            Integer vehicle_special_res_type = vehicle_special_res.getInteger("type");
            vehicleSpecialType = RelationMappingUtil.getVehicleSpecialType(vehicle_special_res_type);
        }
        vehicleDetails.setSpecialty_vehicle_type(vehicleSpecialType);   //特殊品类车辆类型

        //因为是用户上传的图片所以没有抓拍时间，默认为当前时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String picTime = sdf.format(System.currentTimeMillis());
        vehicleDetails.setPictime(picTime);  //抓拍时间(2019-09-24 15:46:12)

        //获取设备名称（因为是用户上传的图片，所以设备名称默认为“用户手动上传”）
        String equipmentName = "无地点信息";
        vehicleDetails.setEquipmentName(equipmentName);//设备名称

        //获取经纬度（来源于用户上传的图片，所以不存在经纬度，默认为北京的经纬度）
        vehicleDetails.setLongitude("116.40");  //经度
        vehicleDetails.setLatitude("39.90");   //纬度

        //获取所有违法状态
        JSONObject vehicle_illegal_det_res = vehicleDetailsOne.getJSONObject("vehicle_illegal_det_res");
        String driverIllStatus = null;
        String copilotIllStatus = null;
        //主驾驶状态
        JSONObject driver = vehicle_illegal_det_res.getJSONObject("driver");
        StringBuilder driverIll = new StringBuilder();
        JSONObject driverSmoke = driver.getJSONObject("smoke");
        Float driverSmokeConfidence = driverSmoke.getFloat("confidence");
        if (driverSmokeConfidence >= sdkThreshold) {
            String driverSmokeStatus = null;
            Integer status = driverSmoke.getInteger("status");
            switch (status) {
                case 1000:
                    driverSmokeStatus = "抽烟";
                    break;
                case 1001:
                    driverSmokeStatus = "未抽烟";
                    break;
                default:
                    driverSmokeStatus = "抽烟未知";
            }
            driverIll.append(driverSmokeStatus).append("、");
        }

        JSONObject driverBelt = driver.getJSONObject("belt");
        Float driverBeltConfidence = driverBelt.getFloat("confidence");
        if (driverBeltConfidence >= sdkThreshold) {
            String driverBeltStatus = null;
            Integer status = driverBelt.getInteger("status");
            switch (status) {
                case 1000:
                    driverBeltStatus = "未系安全带";
                    break;
                case 1001:
                    driverBeltStatus = "系安全带";
                    break;
                default:
                    driverBeltStatus = "安全带未知";
            }
            driverIll.append(driverBeltStatus).append("、");
        }

        JSONObject driverPhone = driver.getJSONObject("phone");
        Float driverPhoneConfidence = driverPhone.getFloat("confidence");
        if (driverPhoneConfidence >= sdkThreshold) {
            String driverPhoneStatus = null;
            Integer status = driverPhone.getInteger("status");
            switch (status) {
                case 1000:
                    driverPhoneStatus = "打电话";
                    break;
                case 1001:
                    driverPhoneStatus = "未打电话";
                    break;
                default:
                    driverPhoneStatus = "打电话未知";
            }
            driverIll.append(driverPhoneStatus).append("、");
        }

        JSONObject driverPerson = driver.getJSONObject("person");
        Float driverPersonConfidence = driverPerson.getFloat("confidence");
        if (driverPersonConfidence >= sdkThreshold) {
            String driverPersonStatus = null;
            Integer status = driverPerson.getInteger("status");
            switch (status) {
                case 1000:
                    driverPersonStatus = "无人";
                    break;
                case 1001:
                    driverPersonStatus = "有人";
                    break;
                case 1003:
                    driverPersonStatus = "无人";
                    break;
                case 1004:
                    driverPersonStatus = "有人";
                    break;
                default:
                    driverPersonStatus = "有无人未知";
            }
            driverIll.append(driverPersonStatus).append("、");
        }
        String driverIllInfo = driverIll.toString();

        if (driverIllInfo.length() >= 1) {
            driverIllStatus = driverIllInfo.substring(0, driverIllInfo.length() - 1);
        }


        //副驾驶状态
        JSONObject copilot = vehicle_illegal_det_res.getJSONObject("copilot");
        StringBuilder copilotIll = new StringBuilder();
        JSONObject copilotSmoke = copilot.getJSONObject("smoke");
        Float copilotSmokeConfidence = copilotSmoke.getFloat("confidence");
        if (copilotSmokeConfidence >= sdkThreshold) {
            String copilotSmokeStatus = null;
            Integer status = copilotSmoke.getInteger("status");
            switch (status) {
                case 1000:
                    copilotSmokeStatus = "抽烟";
                    break;
                case 1001:
                    copilotSmokeStatus = "未抽烟";
                    break;
                default:
                    copilotSmokeStatus = "抽烟未知";
            }
            copilotIll.append(copilotSmokeStatus).append("、");
        }

        JSONObject copilotBelt = copilot.getJSONObject("belt");
        Float copilotBeltConfidence = copilotBelt.getFloat("confidence");
        if (copilotBeltConfidence >= sdkThreshold) {
            String copilotBeltStatus = null;
            Integer status = copilotBelt.getInteger("status");
            switch (status) {
                case 1000:
                    copilotBeltStatus = "未系安全带";
                    break;
                case 1001:
                    copilotBeltStatus = "系安全带";
                    break;
                default:
                    copilotBeltStatus = "安全带未知";
            }
            copilotIll.append(copilotBeltStatus).append("、");
        }

        JSONObject copilotPhone = copilot.getJSONObject("phone");
        Float copilotPhoneConfidence = copilotPhone.getFloat("confidence");
        if (copilotPhoneConfidence >= sdkThreshold) {
            String copilotPhoneStatus = null;
            Integer status = copilotPhone.getInteger("status");
            switch (status) {
                case 1000:
                    copilotPhoneStatus = "打电话";
                    break;
                case 1001:
                    copilotPhoneStatus = "未打电话";
                    break;
                default:
                    copilotPhoneStatus = "打电话未知";
            }
            copilotIll.append(copilotPhoneStatus).append("、");
        }

        JSONObject copilotPerson = copilot.getJSONObject("person");
        Float copilotPersonConfidence = copilotPerson.getFloat("confidence");
        if (copilotPersonConfidence >= sdkThreshold) {
            String copilotPersonStatus = null;
            Integer status = copilotPerson.getInteger("status");
            switch (status) {
                case 1000:
                    copilotPersonStatus = "无人";
                    break;
                case 1001:
                    copilotPersonStatus = "有人";
                    break;
                case 1003:
                    copilotPersonStatus = "无人";
                    break;
                case 1004:
                    copilotPersonStatus = "有人";
                    break;
                default:
                    copilotPersonStatus = "有无人未知";
            }
            copilotIll.append(copilotPersonStatus).append("、");
        }
        String copilotIllInfo = copilotIll.toString();
        if (copilotIllInfo.length() >= 1) {
            copilotIllStatus = copilotIllInfo.substring(0, copilotIllInfo.length() - 1);
        }
        //将主副驾驶状态填入
        vehicleDetails.setVehicle_illegal_driver_status(driverIllStatus); //主驾驶状态
        vehicleDetails.setVehicle_illegal_copilot_status(copilotIllStatus); //副驾驶状态

        //获取车头照片
        JSONObject vehicle_detect_res = vehicleDetailsOne.getJSONObject("vehicle_detect_res");
        Float score = vehicle_detect_res.getFloat("score");
        Integer ctCenter = 0; //车头中间线，用于分割主副驾位置
        if (score >= 0.5) {
            JSONObject syRectParam = vehicle_detect_res.getJSONObject("syRectParam");
            Integer width = syRectParam.getInteger("width");
            Integer left = syRectParam.getInteger("left");
            ctCenter = left + (width / 2);
        }

        //获取主副驾驶遮阳板、挂件、纸巾盒、转经筒
        JSONObject vehicle_pendant_det_res = vehicleDetailsOne.getJSONObject("vehicle_pendant_det_res");
        JSONArray vehiclePendantDetectInfoParams = vehicle_pendant_det_res.getJSONArray("vehiclePendantDetectInfoParams");
        Integer count = vehicle_pendant_det_res.getInteger("count");
        int njbNumber = 0;  //年检标数量
        String driverZYB = "无"; //主驾遮阳板
        String copilotZYB = "无"; //副驾遮阳板
        String gj = "无";  //挂件
        String zjh = "无";  //纸巾盒
        String zjt = "无"; //转经筒
        for (int i = 0; i < count; i++) {
            JSONObject vehiclePendantJson = vehiclePendantDetectInfoParams.getJSONObject(i);//单个属性
            Float confidence = vehiclePendantJson.getFloat("confidence");
            if (confidence >= sdkThreshold) {
                Integer index = vehiclePendantJson.getInteger("index");
                switch (index) {
                    case 3:
                        //判断主副驾驶
                        //获取遮阳板距离左边的距离
                        Integer zybLeft = vehiclePendantJson.getJSONObject("syRectParam").getInteger("left");
                        if (zybLeft > ctCenter) {  //为副驾驶
                            copilotZYB = "有";
                        } else {
                            driverZYB = "有";
                        }
                    case 4:
                        njbNumber++;
                    case 5:
                        gj = "有";
                    case 6:
                        zjh = "有";
                    case 7:
                        zjt = "有";

                }
            }
        }
        vehicleDetails.setVehicle_driver_sunvisor(driverZYB);  //主驾遮阳板
        vehicleDetails.setVehicle_copilot_sunvisor(copilotZYB);  //副驾遮阳板
        vehicleDetails.setVehicle_annualInspectionStandard(String.valueOf(njbNumber)); //年检标
        vehicleDetails.setVehicle_pendant(gj); //挂件
        vehicleDetails.setVehicle_tissuebox(zjh); //纸巾盒
        vehicleDetails.setVehicle_prayerwheel(zjt);//转经筒

        //获取车辆特征值
        JSONObject vehicle_fea_res = vehicleDetailsOne.getJSONObject("vehicle_fea_res");
        JSONArray featureArr = vehicle_fea_res.getJSONArray("feature");
        int size = featureArr.size();
        Double[] featureNew = new Double[size];
        for (int i = 0; i < size; i++) {
            featureNew[i] = featureArr.getDouble(i);
        }
        vehicleDetails.setVehicle_fea_res_feature(featureNew);//获取特征值

        return vehicleDetails;
    }

    public ArrayList<VehicleDetails> base64ToVehicleDetailsArr(JSONObject vehicleSDKJsonData) {
        ArrayList<VehicleDetails> vehicleDetailsList = null;
        if (vehicleSDKJsonData.getString("msg").equals("success")) {
            //开始解析数据并封装成List<VehicleDetails>
            JSONObject vehicleSDKResultJsonData = vehicleSDKJsonData.getJSONObject("result");
            //查询本章图片检测到几个车
            Integer count = vehicleSDKResultJsonData.getInteger("count");
            JSONArray vehicleSDKinfoJson = vehicleSDKResultJsonData.getJSONArray("info");
            vehicleDetailsList = new ArrayList<>();
            for (int i = 0; i < count; i++) {
                //获取到单个的车辆数据
                JSONObject vehicleDetailsOne = vehicleSDKinfoJson.getJSONObject(i);
                //调用通过vehicleSDKResultJsonData获取到单个车
                VehicleDetails vehicleDetails = sdkToVehicleDetails(vehicleDetailsOne);
                vehicleDetailsList.add(vehicleDetails);
            }
        }
        return vehicleDetailsList;
    }

    /**
     * 从全景图中获取到抓拍车辆图的base64
     */
    public static String picToSnapshot(String url, int left, int top, int width, int height) {

//      String path = "http://192.168.10.153:8880/192.168.10.78_01_20190927092803811_FACE_ALARM104.jpg";
        String snapshotBase64 = null;
        ByteArrayOutputStream baos = null;
        try {
            URL path = new URL(url);
            BufferedImage image = (BufferedImage) ImageIO.read(path);
            BufferedImage subimage = image.getSubimage(left, top, width, height);
            baos = new ByteArrayOutputStream();
            ImageIO.write(subimage, "jpg", baos);

            byte[] bytes = baos.toByteArray();
            BASE64Encoder encoder = new BASE64Encoder();
            String encode = encoder.encode(bytes);
            snapshotBase64 = "data:image/jpeg;base64," + encode.replaceAll("\n", "").replaceAll("\r", "");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return snapshotBase64;
    }


    /**
     * 通过全景图的URL截取到其中的快照图并放入到指定位置
     */
    String urlCutToImagePath(int index, String imgUrl, String subPath, Integer left, Integer top, Integer width, Integer height) {

        String snapshotPathNew = null;
        try {
            String substring = imgUrl.substring(imgUrl.lastIndexOf('/') + 1);
            BufferedImage read = ImageIO.read(new File(storePath + substring));
            BufferedImage subimage = read.getSubimage(left, top, width, height);
            //获取到快照图的详细路径
            String snapshotName = "SNAPSHOT_" + index + "_" + imgUrl.substring(imgUrl.lastIndexOf('/') + 1);
            String snapshotPath = subPath + snapshotName;
            File t = new File(snapshotPath);
            if (t.exists()) {
                t.delete();
            }
            ImageIO.write(subimage, "jpg", t);

            return snapshotPrefix + snapshotName;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return snapshotPathNew;
    }

}