人脸识别尝试

2022-10-25

人脸识别尝试

参考材料

[(181条消息) Java实现人脸识别(各项目结构都有案例说明)_高冷小伙的博客-CSDN博客_java实现人脸识别](https://blog.csdn.net/alpha_xia/article/details/121755220?ops_request_misc=&request_id=&biz_id=102&utm_term=java 人脸识别&utm_medium=distribute.pc_search_result.none-task-blog-2~~all~~sobaiduweb~default-0-121755220.nonecase&spm=1018.2226.3001.4187)

下次SDK

人脸识别核心部分是蚕蛹蓝虹公司免费的SDK

下载地址：

开发者中心 (arcsoft.com.cn)

测试阶段

官方给的程序

package samplecode;

import com.arcsoft.face.*;
import com.arcsoft.face.enums.*;
import com.arcsoft.face.toolkit.ImageInfo;

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

import com.arcsoft.face.toolkit.ImageInfoEx;

import static com.arcsoft.face.toolkit.ImageFactory.getGrayData;
import static com.arcsoft.face.toolkit.ImageFactory.getRGBData;


public class FaceEngineTest {


    public static void main(String[] args) {

        String appId = "7K7KG9zfBVrtyhgdfdfg";
        String sdkKey = "AuyJsdgsdfhsf"


        FaceEngine faceEngine = new FaceEngine("D:\\AreFace\\libs\\WIN64");
        //激活引擎，只需要一次
        int errorCode = faceEngine.activeOnline(appId, sdkKey);

        if (errorCode != ErrorInfo.MOK.getValue() && errorCode != ErrorInfo.MERR_ASF_ALREADY_ACTIVATED.getValue()) {
            System.out.println("引擎激活失败");
        }


        ActiveFileInfo activeFileInfo=new ActiveFileInfo();
        errorCode = faceEngine.getActiveFileInfo(activeFileInfo);
        if (errorCode != ErrorInfo.MOK.getValue() && errorCode != ErrorInfo.MERR_ASF_ALREADY_ACTIVATED.getValue()) {
            System.out.println("获取激活文件信息失败");
        }

        //引擎配置，保存默认即可
        EngineConfiguration engineConfiguration = new EngineConfiguration();
        engineConfiguration.setDetectMode(DetectMode.ASF_DETECT_MODE_IMAGE);
        engineConfiguration.setDetectFaceOrientPriority(DetectOrient.ASF_OP_ALL_OUT);
        engineConfiguration.setDetectFaceMaxNum(10);
        engineConfiguration.setDetectFaceScaleVal(16);
        //功能配置，可以设置面容识别时是否分析年龄、性别、3d等。
        FunctionConfiguration functionConfiguration = new FunctionConfiguration();
        functionConfiguration.setSupportAge(true);
        functionConfiguration.setSupportFace3dAngle(true);
        functionConfiguration.setSupportFaceDetect(true);
        functionConfiguration.setSupportFaceRecognition(true);
        functionConfiguration.setSupportGender(true);
        functionConfiguration.setSupportLiveness(true);
        functionConfiguration.setSupportIRLiveness(true);
        engineConfiguration.setFunctionConfiguration(functionConfiguration);


        //初始化引擎
        errorCode = faceEngine.init(engineConfiguration);

        if (errorCode != ErrorInfo.MOK.getValue()) {
            System.out.println("初始化引擎失败");
        }


        //人脸检测
        ImageInfo imageInfo = getRGBData(new File("d:\\aaa.jpg"));
        List<FaceInfo> faceInfoList = new ArrayList<FaceInfo>();
        errorCode = faceEngine.detectFaces(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), imageInfo.getImageFormat(), faceInfoList);
        System.out.println(faceInfoList);

        //特征提取
        FaceFeature faceFeature = new FaceFeature();
        errorCode = faceEngine.extractFaceFeature(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), imageInfo.getImageFormat(), faceInfoList.get(0), faceFeature);
        System.out.println("特征值大小：" + faceFeature.getFeatureData().length);

        //人脸检测2
        ImageInfo imageInfo2 = getRGBData(new File("d:\\ccc.jpg"));
        List<FaceInfo> faceInfoList2 = new ArrayList<FaceInfo>();
        errorCode = faceEngine.detectFaces(imageInfo2.getImageData(), imageInfo2.getWidth(), imageInfo2.getHeight(),imageInfo.getImageFormat(), faceInfoList2);
        System.out.println(faceInfoList);

        //特征提取2
        FaceFeature faceFeature2 = new FaceFeature();
        errorCode = faceEngine.extractFaceFeature(imageInfo2.getImageData(), imageInfo2.getWidth(), imageInfo2.getHeight(), imageInfo.getImageFormat(), faceInfoList2.get(0), faceFeature2);
        System.out.println("特征值大小：" + faceFeature.getFeatureData().length);

        //特征比对
        FaceFeature targetFaceFeature = new FaceFeature();
        targetFaceFeature.setFeatureData(faceFeature.getFeatureData());
        FaceFeature sourceFaceFeature = new FaceFeature();
        sourceFaceFeature.setFeatureData(faceFeature2.getFeatureData());
        FaceSimilar faceSimilar = new FaceSimilar();

        errorCode = faceEngine.compareFaceFeature(targetFaceFeature, sourceFaceFeature, faceSimilar);

        System.out.println("相似度：" + faceSimilar.getScore());

        //设置活体测试
        errorCode = faceEngine.setLivenessParam(0.5f, 0.7f);
        //人脸属性检测，如果上面功能配置没有的话，这里就不可用
        FunctionConfiguration configuration = new FunctionConfiguration();
        configuration.setSupportAge(true);
        configuration.setSupportFace3dAngle(true);
        configuration.setSupportGender(true);
        configuration.setSupportLiveness(true);
        errorCode = faceEngine.process(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), imageInfo.getImageFormat(), faceInfoList, configuration);


        //性别检测，如果上面功能配置没有的话，这里就不可用
        List<GenderInfo> genderInfoList = new ArrayList<GenderInfo>();
        errorCode = faceEngine.getGender(genderInfoList);
        System.out.println("性别：" + genderInfoList.get(0).getGender());

        //年龄检测，如果上面功能配置没有的话，这里就不可用
        List<AgeInfo> ageInfoList = new ArrayList<AgeInfo>();
        errorCode = faceEngine.getAge(ageInfoList);
        System.out.println("年龄：" + ageInfoList.get(0).getAge());

        //3D信息检测，如果上面功能配置没有的话，这里就不可用
        List<Face3DAngle> face3DAngleList = new ArrayList<Face3DAngle>();
        errorCode = faceEngine.getFace3DAngle(face3DAngleList);
        System.out.println("3D角度：" + face3DAngleList.get(0).getPitch() + "," + face3DAngleList.get(0).getRoll() + "," + face3DAngleList.get(0).getYaw());

        //活体检测，如果上面功能配置没有的话，这里就不可用
        List<LivenessInfo> livenessInfoList = new ArrayList<LivenessInfo>();
        errorCode = faceEngine.getLiveness(livenessInfoList);
        System.out.println("活体：" + livenessInfoList.get(0).getLiveness());


        //IR属性处理，如果上面功能配置没有的话，这里就不可用
        ImageInfo imageInfoGray = getGrayData(new File("d:\\IR_480p.jpg"));
        List<FaceInfo> faceInfoListGray = new ArrayList<FaceInfo>();
        errorCode = faceEngine.detectFaces(imageInfoGray.getImageData(), imageInfoGray.getWidth(), imageInfoGray.getHeight(), imageInfoGray.getImageFormat(), faceInfoListGray);

        FunctionConfiguration configuration2 = new FunctionConfiguration();
        configuration2.setSupportIRLiveness(true);
        errorCode = faceEngine.processIr(imageInfoGray.getImageData(), imageInfoGray.getWidth(), imageInfoGray.getHeight(), imageInfoGray.getImageFormat(), faceInfoListGray, configuration2);
        //IR活体检测，如果上面功能配置没有的话，这里就不可用
        List<IrLivenessInfo> irLivenessInfo = new ArrayList<IrLivenessInfo>();
        errorCode = faceEngine.getLivenessIr(irLivenessInfo);
        System.out.println("IR活体：" + irLivenessInfo.get(0).getLiveness());

        ImageInfoEx imageInfoEx = new ImageInfoEx();
        imageInfoEx.setHeight(imageInfo.getHeight());
        imageInfoEx.setWidth(imageInfo.getWidth());
        imageInfoEx.setImageFormat(imageInfo.getImageFormat());
        imageInfoEx.setImageDataPlanes(new byte[][]{imageInfo.getImageData()});
        imageInfoEx.setImageStrides(new int[]{imageInfo.getWidth() * 3});
        List<FaceInfo> faceInfoList1 = new ArrayList<FaceInfo>();
        errorCode = faceEngine.detectFaces(imageInfoEx, DetectModel.ASF_DETECT_MODEL_RGB, faceInfoList1);

        FunctionConfiguration fun = new FunctionConfiguration();
        fun.setSupportAge(true);
        errorCode = faceEngine.process(imageInfoEx, faceInfoList1, functionConfiguration);
        List<AgeInfo> ageInfoList1 = new ArrayList<AgeInfo>();
        int age = faceEngine.getAge(ageInfoList1);
        System.out.println("年龄：" + ageInfoList1.get(0).getAge());

        FaceFeature feature = new FaceFeature();
        errorCode = faceEngine.extractFaceFeature(imageInfoEx, faceInfoList1.get(0), feature);


        //引擎卸载
        errorCode = faceEngine.unInit();

    }
}

注意这里需要导包吧需要的包导到maven里边

学习阶段

分析官方给的pdf，来分析又什么用法，学会阅读官方文档也是一种能力

使用步奏第一阶段配置引擎

获得引擎

==代码中出现的数组都是乱码，具体值需要自己到官网拷贝==

String appId = "7asdasfG3cxqKmpF1DwijXxJ73s75v7uZqxoT";
String sdkKey = "AuyJJasdqwafgadgBnD5wXzSEPtXs5C";


      FaceEngine faceEngine = new FaceEngine("D:\\AreFace\\libs\\WIN64");
      //激活引擎，只需要一次
      int errorCode = faceEngine.activeOnline(appId, sdkKey);

      if (errorCode != ErrorInfo.MOK.getValue() && errorCode != ErrorInfo.MERR_ASF_ALREADY_ACTIVATED.getValue()) {
          System.out.println("引擎激活失败");
      }

C:\Users\Lenovo\Desktop\人脸识别尝试\libs\WIN64该文件名是从官网拷贝下来的压缩包解压后 xx.dll文件所在的位置

第二步获得激活文件

激活文件是可以直接new 生成没有对其的配置

//创建激活文件
ActiveFileInfo activeFileInfo = new ActiveFileInfo();
errorCode = faceEngine.getActiveFileInfo(activeFileInfo);

//判断激活文件是否获取成功
if (errorCode != ErrorInfo.MOK.getValue() && errorCode != ErrorInfo.MERR_ASF_ALREADY_ACTIVATED.getValue()) {
    System.out.println("获取激活文件信息失败");
}

第三步配置引擎

//设置配置引擎对象
EngineConfiguration engineConfiguration = new EngineConfiguration();

//几个比较重要的配置设置

//检测模式设置
//这里因为我们是对图片进行人脸识别，因此这里我们使用一个IMAGE模式
engineConfiguration.setDetectMode(DetectMode.ASF_DETECT_MODE_IMAGE);

//可检测图片人脸方向设置
engineConfiguration.setDetectFaceOrientPriority(DetectOrient.ASF_OP_ALL_OUT);//这里我设置的是全方位角设置

具体功能请参考文档文档在下载下来的压缩包里有

第四步配置引擎功能

引擎功能即引擎能够干什么；

//功能配置，可以设置面容识别时是否分析年龄、性别、3d等。
FunctionConfiguration functionConfiguration = new FunctionConfiguration();
functionConfiguration.setSupportAge(true);
functionConfiguration.setSupportFace3dAngle(true);
functionConfiguration.setSupportFaceDetect(true);
functionConfiguration.setSupportFaceRecognition(true);
functionConfiguration.setSupportGender(true);
functionConfiguration.setSupportLiveness(true);
functionConfiguration.setSupportIRLiveness(true);
       
engineConfiguration.setFunctionConfiguration(functionConfiguration);

第五步初始化引擎

将配置好的引擎和引擎功能的对象都放到引擎里

//初始化引擎 (将配置设置到引擎中)
     errorCode = faceEngine.init(engineConfiguration);

     if (errorCode!=ErrorInfo.MOK.getValue()){
         System.out.println("引擎初始化失败");
     }

引擎准备阶段就到此结束，下边就是引擎能进行的操作了

再次强调

EngineConfiguration engineConfiguration = new EngineConfiguration();
engineConfiguration.setDetectMode(DetectMode.ASF_DETECT_MODE_IMAGE);
engineConfiguration.setDetectFaceOrientPriority(DetectOrient.ASF_OP_ALL_OUT);
engineConfiguration.setDetectFaceMaxNum(10);
engineConfiguration.setDetectFaceScaleVal(16);

配置引擎时，这里个配置比较重要

从上到下分别是

引擎识别模式，是识别静态图片还是视频流
引擎可以识别的头像角度，这里设置的是都可以识别
引擎识别来拿的最大数量
以及引擎识别等级

使用步奏第二部分使用引擎

准备图像

人脸特征获取

//准备文件
      File file = new File("D:\\aaa.jpg");

      //这里使用detectFaces方法来对图片进行分析 detectFaces需要很多参数 这里使用getRGBData方法来获得这些参数
      ImageInfo imageInfo = getRGBData(file);
      //分析得到的数据保存在faceInfoList列表中
      List<FaceInfo> faceInfoList = new ArrayList<FaceInfo>();
      faceEngine.detectFaces(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), imageInfo.getImageFormat(), faceInfoList);


      System.out.println(faceInfoList);

结果：

1	[com.arcsoft.face.Rect(245, 397 - 937, 1089),1]

如果一个图中有多个人脸也是能够识别的

com.arcsoft.face.Rect(1974, 213 - 2749, 987),1
com.arcsoft.face.Rect(1352, 769 - 1839, 1256),1
com.arcsoft.face.Rect(1112, 550 - 1417, 854),1
com.arcsoft.face.Rect(327, 692 - 571, 936),1
com.arcsoft.face.Rect(950, 249 - 1200, 498),1
com.arcsoft.face.Rect(961, 708 - 1186, 933),1

人脸特征提取

extractFaceFeature方法

//人脸特征提取

       //在输入一个图片
       File file1 = new File("D:\\aaa.jpg");


       ImageInfo imageInfo1 = getRGBData(file1);
       //分析得到的数据保存在faceInfoList列表中
       List<FaceInfo> faceInfoList1 = new ArrayList<FaceInfo>();
       faceEngine.detectFaces(imageInfo1.getImageData(), imageInfo1.getWidth(), imageInfo1.getHeight(), imageInfo1.getImageFormat(), faceInfoList1);


       for (FaceInfo faceInfo : faceInfoList1) {
           System.out.println(faceInfo);
       }


       //人脸信息都存放在这个对象里
       FaceFeature faceFeature = new FaceFeature();
       faceEngine.extractFaceFeature(imageInfo1.getImageData(),imageInfo1.getWidth(), imageInfo1.getHeight(), imageInfo1.getImageFormat(),faceInfoList1.get(0),faceFeature);

       System.out.println("图片AAA.jpg的特征是大小为:"+faceFeature.getFeatureData().length);

人脸相似度对比

准备两张图片，按照上述的方法，获得两个feature 来进行比较


//在输入一个图片
File file1 = new File("D:\\fff.jpg");


ImageInfo imageInfo1 = getRGBData(file1);
//分析得到的数据保存在faceInfoList列表中
List<FaceInfo> faceInfoList1 = new ArrayList<FaceInfo>();
faceEngine.detectFaces(imageInfo1.getImageData(), imageInfo1.getWidth(), imageInfo1.getHeight(), imageInfo1.getImageFormat(), faceInfoList1);


for (FaceInfo faceInfo : faceInfoList1) {
    System.out.print("第一张图片获得的数据:");
    System.out.println(faceInfo);
}


//人脸信息都存放在这个对象里
FaceFeature faceFeature = new FaceFeature();
faceEngine.extractFaceFeature(imageInfo1.getImageData(),imageInfo1.getWidth(), imageInfo1.getHeight(), imageInfo1.getImageFormat(),faceInfoList1.get(0),faceFeature);

System.out.println("图片fff.jpg的特征值大小为:"+faceFeature.getFeatureData().length);

//第二个图片
File file2 = new File("D:\\eee.jpg");
ImageInfo imageInfo2 = getRGBData(file2);
ArrayList<FaceInfo> faceInfoList2 = new ArrayList<>();
faceEngine.detectFaces(imageInfo2.getImageData(),imageInfo2.getWidth(),imageInfo2.getHeight(),imageInfo2.getImageFormat(),faceInfoList2);

for (FaceInfo faceInfo : faceInfoList2) {
    System.out.print("第二张图片获得的数据:");
    System.out.println(faceInfo);
}
//获得脸部信息
FaceFeature faceFeature1 = new FaceFeature();
faceEngine.extractFaceFeature(imageInfo2.getImageData(),imageInfo2.getWidth(),imageInfo2.getHeight(),imageInfo2.getImageFormat(),faceInfoList2.get(0),faceFeature1);
System.out.println("图片eee.jpg的特征值大小为:"+faceFeature1.getFeatureData().length);

/*
* @Param faceFeature
* @Param faceFeature1
* */
FaceSimilar faceSimilar = new FaceSimilar();
//进行图片对比
faceEngine.compareFaceFeature(faceFeature,faceFeature1, CompareModel.ID_PHOTO,faceSimilar);
System.out.println("两张图片的相似度为:"+faceSimilar.getScore());

通过两个面部特征对象调用方法进行比较最后获得值

获得可以获得的数据

可以获得的数据包括

年龄 getAge
性别 getGender
人脸三维角度信息 getFace#DAngle
是否为活物 getLiveness

//获得 年龄 性别

        faceEngine.process(imageInfo2.getImageData(),imageInfo2.getWidth(),imageInfo2.getHeight(),imageInfo2.getImageFormat(),faceInfoList2,functionConfiguration);


        ImageInfoEx infoEx = new ImageInfoEx();
        infoEx.setHeight(imageInfo2.getHeight());
        infoEx.setWidth(imageInfo2.getWidth());
        infoEx.setImageFormat(imageInfo2.getImageFormat());
        infoEx.setImageDataPlanes(new byte[][]{imageInfo2.getImageData()});
        infoEx.setImageStrides(new int[]{imageInfo2.getWidth() * 3});
        List<FaceInfo> faceInfoList3 = new ArrayList<>();
        faceEngine.detectFaces(infoEx, DetectModel.ASF_DETECT_MODEL_RGB,faceInfoList3);

        //这里又设置了一个引擎功能 不知道为何
        FunctionConfiguration configuration = new FunctionConfiguration();
        configuration.setSupportAge(true);
        configuration.setSupportFace3dAngle(true);
        configuration.setSupportGender(true);
        configuration.setSupportLiveness(true);

        faceEngine.process(infoEx,faceInfoList3,configuration);


        ArrayList<AgeInfo> ageInfos = new ArrayList<>();
        int age = faceEngine.getAge(ageInfos);
        System.out.println("图片eee.jpg中人物的大致年龄为:"+ageInfos.get(0).getAge());

        ArrayList<GenderInfo> genderInfos = new ArrayList<>();
        faceEngine.getGender(genderInfos);
        System.out.println("图片eee.jpg中的人物的性别为:"+genderInfos.get(0).getGender());

中间有一个新建立的FunctionConfiguration()的对象configure，但是我不明白为什么要新建一个因为之前的程序中已经存在这个对象了，而且设置的配置也是相同的，日后继续学习

总结

使用别人的包，固然是一个快速入门的方法，但是具象性太多，只能获得面部数据，年龄，性别，是否为活物，等等等。

做一个人脸识别功能，是能够实现的，但是无法生成标志着红框框的图片，生产那种高大上的好像在追踪分析的图片。（或许是我自己不会）

学完这个包的使用，增加了自己阅读各种依赖官方文档的能力，人工智能涉足，后续会继续向更深处学习，争取能够手搓出一个程序

操作系统银行家算法下的安全性算法

2022-10-24

操作系统银行家算法下的安全性算法

具体介绍：

(181条消息) 操作系统中的银行家算法与安全性算法_Tsuki_L的博客-CSDN博客_安全性算法

这里我只做我自己的实现，具体含义以及逻辑请参考上述的blog

算法实现

算法的目的是为了查询一个序列是否有安全性序列

pojo类即实体类

package com.dwx.pojo;

public class Task {
    private int A;
    private int B;
    private int C;

    public int getA() {
        return A;
    }

    public void setA(int a) {
        A = a;
    }

    public int getB() {
        return B;
    }

    public void setB(int b) {
        B = b;
    }

    public int getC() {
        return C;
    }

    public void setC(int c) {
        C = c;
    }

    @Override
    public String toString() {
        return "task{" +
                "A=" + A +
                ", B=" + B +
                ", C=" + C +
                '}';
    }

    public Task(int a, int b, int c) {
        A = a;
        B = b;
        C = c;
    }

    public Task() {
    }
}

安全性算法的实现

package com.dwx.untils;

import com.dwx.pojo.Task;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

public class MySecurityAlgorithms {


    //这是一个安全性算法

    public void getSecurityList(int num, List<Task> taskList, Task available, List<Task> allocation) {
        //数据
        boolean finish[] = new boolean[num];
        Task work = new Task();

        //默认所有的finish初始化都为false
        //数据初始化
        for (int i = 0; i < num; i++) {
            finish[i] = false;
        }
        work = available;

        int[] safeList = new int[num];


        //表示回合里边有程序能够执行 如果回合里没有程序能够执行 则说明没有足够量的资源可以执行 程序进入等待状态
        boolean can = true;
        //按照顺序遍历taskList
        //找到能够完成的进程
        int i = 0;
        while (can) {
            can = false;

            //遍历整个taskList
            for (int j = 0; j < num; j++) {

                Task p = taskList.get(j);
                Task a = allocation.get(j);
                //如果资源都足够 且都符合执行条件 那么就执行
                if (p.getA() <= work.getA() + a.getA() && p.getB() <= work.getB() + a.getB() && p.getC() <= work.getC() + a.getC() && !finish[j]) {
                    work.setA(work.getA() + a.getA());
                    work.setB(work.getB() + a.getB());
                    work.setC(work.getC() + a.getC());
                    finish[j] = true;
                    can = true;

                    //将序号读入安全序列
                    safeList[i] = j;
                    i++;
                }
            }
        }
        //如果所有的finish都为true 则说明有执行过了 也有安全的序列

        int t = 0;
        for (boolean b : finish) {
            if (b) {
                t++;
            }
        }

        if (t == num) {
            System.out.print("找到了安全序列 安全序列为：");
            for (int k = 0; k < num; k++) {
                if (k == num - 1) {
                    System.out.println("p" + safeList[k]);
                } else {
                    System.out.print("p" + safeList[k] + "-->");
                }
            }
            System.out.println();
        } else {
            System.out.println("未找到安全序列");
        }

    }

}

测试类

import com.dwx.pojo.Task;
import com.dwx.untils.MySecurityAlgorithms;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

public class MySATest {
    @Test
    public void MySITest() {
        MySecurityAlgorithms mySecurityAlgorithms = new MySecurityAlgorithms();
        int num = 5;
        //需求队列
        List<Task> taskList = new ArrayList<Task>();

        taskList.add(new Task(7,5,3));
        taskList.add(new Task(3,2,2));
        taskList.add(new Task(9,0,2));
        taskList.add(new Task(2,2,2));
        taskList.add(new Task(4,3,3));

        //已分配资源队列
        List<Task> allocation = new ArrayList<Task>();
        allocation.add(new Task(0,1,0));
        allocation.add(new Task(2,0,0));
        allocation.add(new Task(3,0,2));
        allocation.add(new Task(2,1,1));
        allocation.add(new Task(0,0,2));

        Task available = new Task(3,3,2);
        mySecurityAlgorithms.getSecurityList(num,taskList,available,allocation);
    }
}

结果

1	找到了安全序列安全序列为：p1-->p3-->p4-->p0-->p2

1.2.1版本存在问题与优化

2022-10-23

1.2.1版本存在问题与优化

存在问题

由于我使用的是团队服务器，服务器是通过IP地址来进行访问的，没有域名，很难记得，因此我尝试，使用二维码来实现对网站方便的访问

解决方法

二维码技术

(180条消息) java实现二维码的生成与解析_jam_fanatic的博客-CSDN博客_java 二维码生成

需要的依赖

1 <dependency>
2     <groupId>com.google.zxing</groupId>
3     <artifactId>core</artifactId>
4     <version>3.3.3</version>
5 </dependency>

代码

生成二维码类

import com.google.zxing.common.BitMatrix;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class MatrixToImageWriter {

    private static final int BLACK = 0xFF000000;
    private static final int WHITE = 0xFFFFFFFF;

    private MatrixToImageWriter() {
    }

    public static BufferedImage toBufferedImage(BitMatrix matrix) {
        int width = matrix.getWidth();
        int height = matrix.getHeight();
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                image.setRGB(x, y, matrix.get(x, y) ? BLACK : WHITE);
            }
        }
        return image;
    }

    public static void writeToFile(BitMatrix matrix, String format, File file) throws IOException {
        BufferedImage image = toBufferedImage(matrix);
        if (!ImageIO.write(image, format, file)) {
            throw new IOException("Could not write an image of format " + format + " to " + file);
        }
    }

}

测试类

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class MyTest {


    public static void main(String[] args) {
        System.out.println("开始生成...");
        code();
        System.out.println("生成完毕！");
    }

    public static void code() {
        try {
            String content = "https://www.baidu.com";
            String path = "E:/测试";// 二维码保存的路径
            String codeName = UUID.randomUUID().toString();// 二维码的图片名
            String imageType = "jpg";// 图片类型
            MultiFormatWriter multiFormatWriter = new MultiFormatWriter();
            Map<EncodeHintType, String> hints = new HashMap<EncodeHintType, String>();
            hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
            BitMatrix bitMatrix = multiFormatWriter.encode(content, BarcodeFormat.QR_CODE, 400, 400, hints);
            File file1 = new File(path, codeName + "." + imageType);
            MatrixToImageWriter.writeToFile(bitMatrix, imageType, file1);
        } catch (WriterException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class MyTest {


    public static void main(String[] args) {
        System.out.println("开始生成...");
        code();
        System.out.println("生成完毕！");
    }

    public static void code() {
        try {
            String content = "https://www.baidu.com";
            String path = "E:/测试";// 二维码保存的路径
            String codeName = UUID.randomUUID().toString();// 二维码的图片名
            String imageType = "jpg";// 图片类型
            MultiFormatWriter multiFormatWriter = new MultiFormatWriter();
            Map<EncodeHintType, String> hints = new HashMap<EncodeHintType, String>();
            hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
            BitMatrix bitMatrix = multiFormatWriter.encode(content, BarcodeFormat.QR_CODE, 400, 400, hints);
            File file1 = new File(path, codeName + "." + imageType);
            MatrixToImageWriter.writeToFile(bitMatrix, imageType, file1);
        } catch (WriterException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

IP地址

http://115.29.41.122:8099/union

组合

结束

天梯计划1.2版本更新

2022-10-04

天梯计划1.2版本更新

file:///C:/Users/Lenovo/Desktop/阶梯计划/1.2.1版本/存在问题与优化.md

存在的问题

现在还没有服务器可以使用 √
前端有些问题简单的展示都会出现问题 √
后端逻辑上没有设置如果有人恶意访问后台会怎么样要设置 √
前端的操作没有js的参与确实有点生硬（暂时不用更改 √）
添加更多的功能
- 添加专有名词创建者和浏览量 √
- 对管理员添加role职责总管理员可以对所有的关键词增删改查但是子管理员只能对自己添加的关键词进行删除和修改 √
- 专有名词序列需要添加分页查询功能（暂时还不用）暂时专有名词不够多（暂时没有这个技术 √）

服务器问题

已经放到服务器上了是团队的服务器

http://115.29.41.122:8099/union

我想还是找个好时间买一个自己的服务器

安全问题

直接通过绝对路径进行访问

这里我要求进到这个页面就算了但是如果执行任何操作都需要检查一下user对象是否存在

如果不存在就跳转到404页面

通过一个until达到了我们的目的：能进入后台首页但是啥也做不了

只要要通过后台执行的操作就会跳转到这个页面

新增功能

分析一下逻辑，为了更好的使用这个网站，我认为可以加入更多人来维护这个网站，但是这个网站仍然存在很多问题，需要一点点添加新的功能。

需要在专有名词查询上加上分页功能
专有名词加上 createBy 和 viewCount两个属性
对于管理员加上userRole属性

userRole我本人是1 其他的管理员是2

1表示总管理员可以增删改所有的专有名词

2表示分管理员只能够增，删改自己创造的专有名词

对专有名词添加属性

对专有名词添加属性

已经添加成功

对管理员添加属性

对管理员添加属性

能够实现不同管理员操作不同

人性化问题

人性化问题主要存在于

分页查询的实现
一些不合人类逻辑的设计的改善

分页查询的实现

不合人类逻辑的设计的改善

对于关键词查询页的改善，选用关键词名称加创建管理员昵称的方式更加符合人类的逻辑

还可以添加排序方式通过ID排序或者通过浏览量排序

添加了一个排序方式

已经实现了

阶梯计划开发历程

2022-09-30

开发历程

起点（2022/9/27）

今晚，在某学习平台学习党的先进知识的时候，偶然翻阅到一篇文章

作为名在校大学生，我是能够看懂这些文字的，但是理解意思上很吃力。

对里边的一些特有名词比如“xx个xx”，我是没有理解的。是我个人党的基本理论掌握不牢，作者在写这篇文章时直接使用特有名词来缩短文章篇幅的行为是可以理解的。

解决这个问题的方法有很多，比如建议所有作者在引用完专有名词后在文章末尾对专有名词进行解释。如《毛泽东选集》的每一章，和《邓小平文选》的文章后边都是有做注释的。但是改变别人的方法不可取，也是比较难实现的。

因此我想到，用浏览器是可以帮助我的，但是不能帮助我记录，且很多的浏览器是对知识服务收费的。因此我萌生了自己写一个==专有名词查询网站==的想法。

结构

该网站最启初版，是有两个部分组成，第一部分是像浏览器一样的搜索，查询平台（前台），是给所有用户使用的。

像这种

另一部分是后台管理员页面，用来对词条进行查看和修改

类似于超时订单系统

技术以及来源

后端：使用SSM框架，由我本人手写，数据库选用mysql

前端：使用网上搜索到的免费的前台和后台代码进行改进

2022/9/27

前台结束（只实现一个关键词查询功能）很简单。后续可能会逐步添加一些东西，暂时只有一个查询功能。

大概就这样，后续添加后端。

2022/9/28

登录与后台系统已经打通

现在可以通过登录页面跳转到后台页面了

也实现了退出和修改密码功能

对于订单管理部分：计划是对这个页面进行改造，我并没有掌握ajax技术，因此可能这个页面无法实现分页，可以进行尝试一下

2022/9/30

今天对关键词程序进行了一个实现，增，删，改，查全部完成，但是没有完成分页查询，在后续优化中，会对分页查询进行实现

查询所有

查询单个

增加

修改

删除

删除之后的情况

对于管理员操作对下边这个页面进行操作

2022/10/1

用户程序已经写好了

包括搜索展示修改功能有已经完成

展示

修改

结束

第一版已经结束了，要把我们的项目放到服务器上在运行一下试试

2021年C题的分析

2022-08-21

2021年C题的分析

分析此题，感觉比2021年其他的题要简单。

原文

某建筑和装饰板材的生产企业所用原材料主要是木质纤维和其他植物素纤维材料,
总体可分为 A，B，C 三种类型。该企业每年按 48 周安排生产，需要提前制定 24 周的原
材料订购和转运计划，即根据产能要求确定需要订购的原材料供应商（称为“供应商”）
和相应每周的原材料订购数量（称为“订货量”），确定第三方物流公司（称为“转运
商”）并委托其将供应商每周的原材料供货数量（称为“供货量”）转运到企业仓库。
该企业每周的产能为 2.82 万立方米，每立方米产品需消耗 A 类原材料 0.6 立方米，
或 B 类原材料 0.66 立方米，或 C 类原材料 0.72 立方米。由于原材料的特殊性，供应商
不能保证严格按订货量供货，实际供货量可能多于或少于订货量。为了保证正常生产的
需要，该企业要尽可能保持不少于满足两周生产需求的原材料库存量，为此该企业对供
应商实际提供的原材料总是全部收购。
在实际转运过程中，原材料会有一定的损耗（损耗量占供货量的百分比称为“损耗
率”），转运商实际运送到企业仓库的原材料数量称为“接收量”。每家转运商的运输
能力为 6000 立方米/周。通常情况下，一家供应商每周供应的原材料尽量由一家转运商
运输。
原材料的采购成本直接影响到企业的生产效益，实际中 A 类和 B 类原材料的采购单
价分别比 C 类原材料高 20%和 10%。三类原材料运输和储存的单位费用相同。
附件 1 给出了该企业近 5 年 402 家原材料供应商的订货量和供货量数据。附件 2 给
出了 8 家转运商的运输损耗率数据。请你们团队结合实际情况，对相关数据进行深入分
析，研究下列问题：
1．根据附件 1，对

第一问

问题：

1
2

根据附件 1，对 402 家供应商的供货特征进行量化分析，建立反映保障企业生产
重要性的数学模型，在此基础上确定 50 家最重要的供应商，并在论文中列表给出结果。

根据分析，我们认为此题是一个评价类问题，但是评价标准不好找。有如下几点问题

没有训练集，不能通过拟合等确定个因素的比重
因素太少，只有订货量和供货量

因此，我们分析得，我们采用专家法，自己指定一套评价体系，评价体系如下：

关于重要性，我认为我们对重要客户的依赖度要足够高（订单量要尽可能大）
关于可信度，我认为供货商要极可能满足我们的订单（订单少的数量要尽可能少）

因此我们确定了两个指标重要性S1和可信度S2

S1 = 某个供货商的订单总数/max(供货商订单总数)

S2 = 1 - 某个订货商的缺少数/max(订货商的缺少数)

实践

代码

package com.dwx.C;

import java.util.Scanner;

public class demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //确定企业数为402
        //确定订单次数为240
        int m = 402;
        int n = 240;
        System.out.println(":请输入企业订单数据：");
        //读入企业订单数据
        int[][] Q = new int[402][240];
        for (int i = 0;i < m;i++){
            for (int j = 0;j < n;j++){
                Q[i][j] = scanner.nextInt();
            }
        }

        System.out.println(":请输入供应商数据：");
        //读入供应商数据
        int[][] G = new int[402][240];
        for (int i = 0;i < m;i++){
            for (int j = 0;j < n;j++){
                G[i][j] = scanner.nextInt();
            }
        }


        //对供应商的依赖度进行处理 即先求出供应商的总订单 再求出每个供应商对我们总总订单的占比
        //存储各个供应商的订单量总和
        int[] q1 = new int[402];
        for (int i=0;i<m;i++){
            for (int j=0;j<n;j++){
                q1[i] = q1[i] + Q[i][j];
            }
        }

        //求出我们需求的总和
        int Max = 0;
        for (int i=0;i<m;i++){
            if(q1[i]>Max){
                Max = q1[i];
            }
        }

        //求出占比
        double[] s1 = new double[402];
        System.out.println("对供应商下达的最大订单为:"+Max);
        for (int i=0;i<m;i++){
            s1[i] = q1[i]* 1.0/Max ;
        }

        //输出依赖度
        //保留两位小数

        for (double v : s1) {
            System.out.printf("%.2f\n",v);
        }

        //求可靠度 即 求供应商和订单之间的差异度
        /*
        * 在此我们规定 对于供应商供给的货多于订单量或等于订单量 我们都视为0
        * 当供应商供给订单数量少于订单数量 则即差异度为（订单-实际供货）
        * 我们对每一次订货进行操作 因此不至于有误差
        * 差异度 只对占比比较大的厂家进行使用*/

        //读入厂家数据
        System.out.println("请输入符合要求的供应商:");
        //有意义的供应商有89加
        int m1 = 89;
        int[] M = new int[89];
        for (int i=0;i<m1;i++){
            M[i] = scanner.nextInt();
        }


        int[] d = new int[m1];
        for (int i=0;i<m1;i++){
            for (int j=0;j<n;j++){
                if (G[M[i]][j] >= Q[M[i]][j]){
                    continue;
                }else {
                    d[i] = d[i] + (Q[M[i]][j] - G[M[i]][j]);
                }
            }
        }
        //输出差异度
        System.out.println("输出差异度：");
        for (int i : d) {
            System.out.println(i);
        }

        //求得最小差异度
        int min = 9999;
        for (int i=0;i<m1;i++){
            if (d[i] < min){
                min = d[i];
            }
        }
        System.out.println("最小数为:"+min);
        //求得可信度
        double[] K = new double[m1];
        for (int i=0;i<m1;i++){
            K[i] = d[i]*1.0/min;
        }

        //输出可信度
        System.out.println("输出可信度:");
       for (int i=0;i<m1;i++){
           System.out.println("供应商"+M[i]+"的差异数为:"+K[i]);
       }

       /*
       * 可信度分数 = 1 - 差异度/max(差异度s)*/

        int max = 0;
        for (int i = 0;i < m1;i++){
            if (d[i] > max){
                max = d[i];
            }
        }
        System.out.println("最大值为:"+max);
        double[] k = new double[m1];
        for (int i=0;i<m1;i++){
            k[i] = 1 - d[i]*1.0/max;
        }

        for (double v : k) {
            System.out.printf("%.4f\n",v);
        }
    }
}

首先获得重要性分数

进行降序排序后，我发现，只有前91名供应商的数据是有效的，因此我认为可以忽略其余的300+的小供应商，避免这些供应商数据稳定性良好影响大供应商的分数。

再对大供应商进行操作，求得他们的可靠性分数

分析数据，可得，数据多在0.99附近，差异性小。

总分 = 依赖性 + 可靠性这样分析，还是有不小的差异性的。

关于《生死疲劳》一书部分情节的疑问

2022-08-02

关于《生死疲劳》一书部分情节的疑问

近期，网上有关于莫言文章是否有问题的讨论很多，我所看过的有

司马南先生对莫言颁奖词的解读： 司马南：莫言是这样获奖的，解读诺贝尔文学奖颁奖词_哔哩哔哩_bilibili

前进四对莫言红高粱中不实片段的批判： 反对历史虚无主义！五万字文稿浓缩版！对吃粥饭和莫言的批判！_哔哩哔哩_bilibili

前进四对UP“吃粥饭”对自己批判的批判： 吃粥饭如何断章取义歪曲历史虚空批判洗白莫言-4-看历史虚无主义者如何把你一步步忽悠瘸了。对吃粥饭对我之虚空批判的严肃批判！_哔哩哔哩_bilibili

李敖谈诺贝尔文学奖：你要出卖自己的祖国，你才有机会获得！： 李敖谈诺贝尔文学奖：你要出卖自己的祖国，你才有机会获得！_哔哩哔哩_bilibili

对于莫言的作品，我只看过《生死疲劳》，我不懂什么历史虚无主义，不清楚我要说明的问题是否是1历史虚无主义造成的，但是我对书中的一些情节有深深的疑问。

西门闹被枪毙

文中西门闹自述自己是：”热爱劳动，勤俭持家，修桥补路，乐善好施……..一个正直的人，一个善良的人，一个大好人“

在被民兵队长黄瞳枪毙前询问：“我到底反了哪条律令。”黄瞳的回答是：“你导演王那里去问个明白吧”

此后，全文再也没有提过关于西门闹反了什么罪，为何被枪毙。因此，这是作者在暗示，西门闹就是惨死，死的不明不白。

同样的话，在西门闹被阎王审问时，通过阎王的嘴说了出来：“好了，西门闹，我知道你是冤枉的。世界上许多人该死，但却不死；许多人不该死，偏偏死了……”

==“许多人”，“冤枉”，“民兵”，“枪毙”==

这几个关键词放到这里，给人的感觉是，中共在执行土地革命时，有大量的“矫枉过正”行为，对于地主不分好坏一股脑全部枪毙，造成了很多人的冤死。

对于此，我表示怀疑，我曾经自己解释过，中国这么大，会不会真的有地方发生这种事，但是如果这样解释，就陷入了历史虚无主义的陷阱，我们要用史实来思考问题。

在《毛泽东选集（第一卷）》的《湖南农民运动考察报告》中有描写当时农民运动的情景：

打倒土豪劣绅，一切权力归农会
所谓的“过分问题”
政治上打压地主
经济上打压地主

这篇考察报告说明了在第一次国民革命时期，湖南农民运动的样貌。

农民运动是农民参与的，农民为主体的运动，农民对当地的地主进行评价，做得当时小资产阶级看来恐怖得不得了的事情也不过是，戴高帽子游乡，到小姐少奶奶的牙床上滚一滚……..

在《白鹿原》一文中，对于地主的审判，也是组织农会，让农民参与，让农民批判地主，在农会对地主批判最高潮的时候，有农民提出铡刀铡死地主，但是被农会会长制止了。

由此，我并没有看到描写民兵等等，恶意杀人事件，土地革命有固定流程，也没有最后“枪毙地主”这一项。

土地革命的目的是：没收地主土地，归还给贫下中农，地主在被没收土地后，理论上还是富

那么有没有被打死的地主？

有的，部分地主不接受革命，组织武装镇压革命，打死打伤民兵，这种地主不该死吗？压迫农民获得的财富，买来枪炮镇压农民不该死吗？

部分地主子女组织成还乡团，回到家乡打死烧杀抢掠，（ “还乡团”为什么如此残忍？_哔哩哔哩_bilibili ），这种人不该死吗？

因此我得到的结论，农民有自己判断的能力，枪毙的都是不愿合作的且品行及其暴烈的。莫言先生笔下写的确是，中共为了打土豪滥杀无辜，不知道莫言先生如何解释。

艺术上推荐系统编写过程（第一版）

2022-06-08

2022/5/21

编写工作开始

熟悉艺术生的填报规则
搭建一个艺术生专业课优先的数据库
将程序的后端搭建起来

问题所在：

经过上网查询，并没有发现网络上有类似的对艺术生的高考推荐程序，因为，艺术生的报考模式很奇怪，报考规则不一样，也没有一个全省的排名，社会上的公司都没在做这方面的工作，我对是否能写出这个程序表示担心。

2022/5/22

重新缕了一下思路后端程序已经搭建完成程序已经写好了问题在于数据库的导入

数据库出问题

数据库发生改变时要求数据类型符合数据库中的要求的数据类型否则就会回滚返回之前的数据
将xlsx转化成csv能够实现数据的快速导入
csv中不存在只有整数部分的小数如（65.0）在导入到数据库时会被认为是整数 (65)

美术推荐已经写好工作重点在于数据库中数据的处理

推荐过程

首先计算这人是属于那个成绩段的
到该程序段通过比例求得他的分数与数据库中的分数线进行比较
找到所有的符合要求的数据返回给前端

2022年5月31日

已经写好了一版，由于太简单，老师不满意继续更改

第一版的输入页面

第一版的展示页面

重新分析了需求

重新建了数据库

2022/6/4

导入学校数据学校推荐程序已经写好了

由于没有使用ajax 不能实现局部刷新是一个跳转过程

前端样式还是需要改

学校的排名太无序，但是我没有别的方法只能让他无序吧

2022/6/5

学院细节已经能写了

继续编写程序

专业（可以上的专业/所有的专业）
录取分数线（需要用ajax）
招生计划（要当年的招生计划）（每年都需要导入数据）

2022/6/6

专业信息已经录入了

程序最后写好了

问题来自：

前端给数据块设置的是默认不展示
前端安排的程序块分布问题分的太开了

明天计划把录取分数线写了不过需要前端进行一点修改了

这个界面不太好看而且明显需要使用ajax 看看是否有平替的方法

2022/6/7

今天把招生计划

只剩下一个页面了“录取分数线”

但是那个录取分数线需要使用ajax，就交给前端的同学去写，我先不动

2022/6/8

ajax就是个屑不用局部刷新加个from表单照样进行查询

除了重新跳到这个页面会是null以外根本没有问题

真不错

程序写完了

招生计划前端加了个样式真不错

2022年6月8日 0点30分程序写完了（第一阶段写完了）

2022年暑假计划

2022-06-05

2022年暑假计划

我们必须在暑假前指定一个暑假计划在暑假后进行一个检验，下边分析一个我们需要做的事

机组学习机组笔记的编写
高数下学习
概率论学习
英语单词背记（准备四级）
驾照考试
数学建模学习（不能托团队后腿）
锻炼（感觉身体肌肉不够太瘦了）

2022-05-26

MtachorCupD题解题思路

第一题的解题思路

对于第一题，是一个求圆进行覆盖的图，基本思路是：

先对这些数进行从大到小的排序
找出最大的数，对这个数进行建站
这个数方圆

第三问

第三问我的思路是将所有的单点都去除掉

然后使用聚类看看聚类的效果，

使用k-means聚类来测试

第一次聚类 428有点小了

第二次聚类 5000 有点大了

采用折半搜索

第三次聚类 2714 有点大了

第四次聚类 1571 有点大了

第五次聚类 999 有点大了

第六次聚类 713有点大了

第七次聚类 571有点大了

第七次聚类 499不合适了

不能用多重聚类这种方法去写因为k-means的机制的原因。k-means是先找到一个点，然后找里这个点进的点，但是跟题目中的要求不同，因此不能这样去考虑

利用最短距离法进行聚类

1
2
3

错误使用 internal.stats.pdistmex
请求的 1x16677862930 (124.3GB)数组超过预设的最大数组大小。创建大于此限制的数组可能需要较长时间，并且会导致 MATLAB
无响应。

无法直接使用最短距离法进行聚类

既然k-means可以搞出几个临近的数我们也可以在k-means聚类后的基础上进行聚类

结果

三等奖

我个人认为还不错

人脸识别尝试

下次SDK

测试阶段

学习阶段

使用步奏第一阶段 配置引擎

获得引擎

第二步 获得激活文件

第三步 配置引擎

第四步 配置引擎功能

第五步 初始化引擎

使用步奏第二部分 使用引擎

人脸特征获取

人脸特征提取

人脸相似度对比

获得可以获得的数据

总结

操作系统银行家算法下的安全性算法

算法实现

1.2.1版本存在问题与优化

存在问题

解决方法

天梯计划1.2版本更新

存在的问题

服务器问题

安全问题

新增功能

对专有名词添加属性

对管理员添加属性

人性化问题

分页查询的实现

不合人类逻辑的设计的改善

开发历程

起点（2022/9/27）

结构

技术以及来源

2022/9/27

2022/9/28

2022/9/30

2022/10/1

结束

2021年C题的分析

第一问

实践

关于《生死疲劳》一书部分情节的疑问

西门闹被枪毙

2022/5/21

2022/5/22

2022年5月31日

2022/6/4

2022/6/5

2022/6/6

2022/6/7

2022/6/8

2022年暑假计划

MtachorCupD题解题思路

第一题的解题思路

第三问

利用最短距离法进行聚类

结果

使用步奏第一阶段配置引擎

第二步获得激活文件

第三步配置引擎

第四步配置引擎功能

第五步初始化引擎

使用步奏第二部分使用引擎