TIT 操作系统实验三 动态分区(First Fit、Next Fit、Best Fit、Worst Fit )

已于 2022-05-12 15:55:30 修改
阅读量2.8k 收藏 31
点赞数 9
分类专栏： 操作系统 文章标签： 算法 操作系统 数据结构
于 2021-12-09 18:36:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49488584/article/details/121838487
版权

文章目录

实验三 动态分区算法

前言

  • 参考教材《操作系统 第四版》汤小丹

  • 首次适应算法(First Fit)。空闲分区以地址递增的次序连接。分配内存时顺序查找，找到大小能满足要求的第一个空闲分区

  • 邻近适应算法(Next Fit)。又称循环首次适应算法，由首次适应算法演变而成。不同之处是，分配内存时从上次查找结束的位置开始继续查找

  • 最佳适应算法(Best Fit)。空闲分区按容量递增的方式形成分区链，找到第一个满足要求的空闲分区

  • 最坏适应算法(Worst Fit)。又称最大适应算法，空闲分区以容量递减的次序链接，找到第一个能满足要求的空闲分区，即挑选出最大的分区

  • 实验三Memory类中建了很多内部内和方法，分开展示代码部分只是为了方便学习每段代码的具体逻辑。运行代码直接C2C完整代码即可，以防某个函数或类放错位置

实验目的

通过这次实验，加深对动态分区分配算法的理解，进一步掌握首次适应算法、循环首次适应算法、最佳适应算法、最坏适应算法的实现方法

实验内容

设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。分别利用四种动态分区分配算法将m个进程放入空闲分区，给出进程在空闲分区中的分配情况

实验步骤

内存分配菜单

// 内存分配菜单
public void allocation(int size) {
    System.out.println("1.首次适应算法 2.循环首次适应算法 3.最佳适应算法 4.最坏适应算法");
    System.out.print("请选择分配算法:");
    Scanner in = new Scanner(System.in);
    int choice = in.nextInt();
    switch (choice) {
        case 1:
            FF(size);
            break;
        case 2:
            NF(size);
            break;
        case 3:
            BF(size);
            break;
        case 4:
            WF(size);
            break;
        default:
            System.out.println("请重新选择!");
    }
}

首次适应算法

// 首次适应算法
private void FF(int size) {
    // 遍历分区链表
    for (pointer = 0; pointer < zones.size(); pointer++) {
        Zone tmp = zones.get(pointer);
        // 找到可用分区（空闲且大小足够）
        if (tmp.isFree && (tmp.size > size)) {
            doAllocation(size, pointer, tmp);
            return;
        }
    }
    // 遍历结束后未找到可用分区, 则内存分配失败
    System.out.println("无可用内存空间!");
}

循环首次适应算法

// 循环首次适应算法
private void NF(int size) {
    Zone tmp = zones.get(pointer);
    if (tmp.isFree && (tmp.size > size)) {
        doAllocation(size, pointer, tmp);
        return;
    }
    int len = zones.size();
    int i = (pointer + 1) % len;
    for (; i != pointer; i = (i + 1) % len) {
        tmp = zones.get(i);
        if (tmp.isFree && (tmp.size > size)) {
            doAllocation(size, i, tmp);
            return;
        }
    }
    // 全遍历后如果未分配则失败
    System.out.println("无可用内存空间!");
}

最佳适应算法

// 最佳适应算法
private void BF(int size) {
    int flag = -1;
    int min = this.size;
    for (pointer = 0; pointer < zones.size(); pointer++) {
        Zone tmp = zones.get(pointer);
        if (tmp.isFree && (tmp.size > size)) {
            if (min > tmp.size - size) {
                min = tmp.size - size;
                flag = pointer;
            }
        }
    }
    if (flag == -1) {
        System.out.println("无可用内存空间!");
    } else {
        doAllocation(size, flag, zones.get(flag));
    }
}

最坏适应算法

// 最坏适应算法
private void WF(int size) {
    int flag = -1;
    int max = 0;
    for (pointer = 0; pointer < zones.size(); pointer++) {
        Zone tmp = zones.get(pointer);
        if (tmp.isFree && (tmp.size > size)) {
            if (max < tmp.size - size) {
                max = tmp.size - size;
                flag = pointer;
            }
        }
    }
    if (flag == -1) {
        System.out.println("无可用内存空间!");
    } else {
        doAllocation(size, flag, zones.get(flag));
    }
}

内存分配

// 开始分配
private void doAllocation(int size, int location, Zone tmp) {
    // 要是剩的比最小分区MIN_SIZE小，则把剩下那点给前一个进程
    if (tmp.size - size <= MIN_SIZE) {
        tmp.isFree = false;
    } else {
        Zone split = new Zone(tmp.head + size, tmp.size - size);
        zones.add(location + 1, split);
        tmp.size = size;
        tmp.isFree = false;
    }
    System.out.println("成功分配 " + size + "KB 内存!");
}

内存回收

// 内存回收
public void collection(int id) {
    if (id >= zones.size()) {
        System.out.println("无此分区编号!");
        return;
    }
    Zone tmp = zones.get(id);
    int size = tmp.size;
    if (tmp.isFree) {
        System.out.println("指定分区未被分配, 无需回收");
        return;
    }
    // 如果回收的分区后一个是空闲就和后一个合并
    if (id < zones.size() - 1 && zones.get(id + 1).isFree) {
        Zone next = zones.get(id + 1);
        tmp.size += next.size;
        zones.remove(next);
    }
    // 回收的分区要是前一个是空闲就和前分区合并
    if (id > 0 && zones.get(id - 1).isFree) {
        Zone previous = zones.get(id - 1);
        previous.size += tmp.size;
        zones.remove(id);
        id--;
    }
    zones.get(id).isFree = true;
    System.out.println("内存回收成功!, 本次回收了 " + size + "KB 空间!");
}

展示分区

// 展示分区状况
public void showZones() {
	System.out.println("分区编号\t    分区始址\t     分区大小\t 空闲状态\t");
	for (int i = 0; i < zones.size(); i++) {
		Zone tmp = zones.get(i);
		System.out.println(i + "\t\t" + tmp.head + "\t\t" + tmp.size + "  \t" + tmp.isFree);
	}
}

主函数

public class 动态分区算法 {
    public static void main(String[] args) {
        Memory my = new Memory();// 新建一个内存对象
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入要分配内存还是要释放内存");
            System.out.println("1.分配内存 2.释放内存 3.展示分区状况");
            int n = sc.nextInt();
            switch (n) {
                case 1: {
                    System.out.println("请输入要分配的内存大小");
                    int size = sc.nextInt();
                    my.allocation(size);// 调用对象Memory中内存分配函数allocation
                    my.showZones();// 展示分区状况
                    break;
                }
                case 2: {
                    System.out.println("输入想要释放内存的分区号");
                    int id = sc.nextInt();
                    my.collection(id);// 调用对象Memory中内存释放函数collection
                    break;
                }
                case 3: {
                    my.showZones();// 展示分区状况
                    break;
                }
                default:
                    System.out.println("输的不对");
            }
        }
    }
}

完整代码

package 操作系统实验;

import java.util.Arrays;
import java.util.Scanner;
import java.util.LinkedList;

/*
 * 动态分区算法 FF NF BF WF
 * @author CSDN 张时贰
 * @data 2021年12月9日
 */
public class 动态分区算法 {
    public static void main(String[] args) {
        Memory my = new Memory();// 新建一个内存对象
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入要分配内存还是要释放内存");
            System.out.println("1.分配内存 2.释放内存 3.展示分区状况");
            int n = sc.nextInt();
            switch (n) {
                case 1: {
                    System.out.println("请输入要分配的内存大小");
                    int size = sc.nextInt();
                    my.allocation(size);// 调用对象Memory中内存分配函数allocation
                    my.showZones();// 展示分区状况
                    break;
                }
                case 2: {
                    System.out.println("输入想要释放内存的分区号");
                    int id = sc.nextInt();
                    my.collection(id);// 调用对象Memory中内存释放函数collection
                    break;
                }
                case 3: {
                    my.showZones();// 展示分区状况
                    break;
                }
                default:
                    System.out.println("输的不对");
            }
        }
    }
}

//新建一个内存类
class Memory {
    private int size;// 内存大小
    private static final int MIN_SIZE = 2;// 最小剩余分区大小
    private LinkedList<Zone> zones;// 内存分区
    private int pointer;// 上次分配的空闲区位置

    // 新建一个内部类，分区节点类
    class Zone {
        private int size;// 分区大小
        private int head;// 分区始址
        private boolean isFree;// 空闲状态

        public Zone(int head, int size) {
            this.head = head;
            this.size = size;
            this.isFree = true;
        }
    }

    // 默认内存大小512K
    public Memory() {
        this.size = 512;
        this.pointer = 0;// 默认首次运行程序，上次分配的空闲区位置为0
        this.zones = new LinkedList<>();
        zones.add(new Zone(0, size));
    }

    public Memory(int size) {
        this.size = size;
        this.pointer = 0;
        this.zones = new LinkedList<>();
        zones.add(new Zone(0, size));
    }

    // 内存分配菜单
    public void allocation(int size) {
        System.out.println("1.首次适应算法 2.循环首次适应算法 3.最佳适应算法 4.最坏适应算法");
        System.out.print("请选择分配算法:");
        Scanner in = new Scanner(System.in);
        int choice = in.nextInt();
        switch (choice) {
            case 1:
                FF(size);
                break;
            case 2:
                NF(size);
                break;
            case 3:
                BF(size);
                break;
            case 4:
                WF(size);
                break;
            default:
                System.out.println("请重新选择!");
        }
    }

    // 首次适应算法
    private void FF(int size) {
        // 遍历分区链表
        for (pointer = 0; pointer < zones.size(); pointer++) {
            Zone tmp = zones.get(pointer);
            // 找到可用分区（空闲且大小足够）
            if (tmp.isFree && (tmp.size > size)) {
                doAllocation(size, pointer, tmp);
                return;
            }
        }
        // 遍历结束后未找到可用分区, 则内存分配失败
        System.out.println("无可用内存空间!");
    }

    // 循环首次适应算法
    private void NF(int size) {
        Zone tmp = zones.get(pointer);
        if (tmp.isFree && (tmp.size > size)) {
            doAllocation(size, pointer, tmp);
            return;
        }
        int len = zones.size();
        int i = (pointer + 1) % len;
        for (; i != pointer; i = (i + 1) % len) {
            tmp = zones.get(i);
            if (tmp.isFree && (tmp.size > size)) {
                doAllocation(size, i, tmp);
                return;
            }
        }
        // 全遍历后如果未分配则失败
        System.out.println("无可用内存空间!");
    }

    // 最佳适应算法
    private void BF(int size) {
        int flag = -1;
        int min = this.size;
        for (pointer = 0; pointer < zones.size(); pointer++) {
            Zone tmp = zones.get(pointer);
            if (tmp.isFree && (tmp.size > size)) {
                if (min > tmp.size - size) {
                    min = tmp.size - size;
                    flag = pointer;
                }
            }
        }
        if (flag == -1) {
            System.out.println("无可用内存空间!");
        } else {
            doAllocation(size, flag, zones.get(flag));
        }
    }

    // 最坏适应算法
    private void WF(int size) {
        int flag = -1;
        int max = 0;
        for (pointer = 0; pointer < zones.size(); pointer++) {
            Zone tmp = zones.get(pointer);
            if (tmp.isFree && (tmp.size > size)) {
                if (max < tmp.size - size) {
                    max = tmp.size - size;
                    flag = pointer;
                }
            }
        }
        if (flag == -1) {
            System.out.println("无可用内存空间!");
        } else {
            doAllocation(size, flag, zones.get(flag));
        }
    }

    // 开始分配
    private void doAllocation(int size, int location, Zone tmp) {
        // 要是剩的比最小分区MIN_SIZE小，则把剩下那点给前一个进程
        if (tmp.size - size <= MIN_SIZE) {
            tmp.isFree = false;
        } else {
            Zone split = new Zone(tmp.head + size, tmp.size - size);
            zones.add(location + 1, split);
            tmp.size = size;
            tmp.isFree = false;
        }
        System.out.println("成功分配 " + size + "KB 内存!");
    }

    // 内存回收
    public void collection(int id) {
        if (id >= zones.size()) {
            System.out.println("无此分区编号!");
            return;
        }
        Zone tmp = zones.get(id);
        int size = tmp.size;
        if (tmp.isFree) {
            System.out.println("指定分区未被分配, 无需回收");
            return;
        }
        // 如果回收的分区后一个是空闲就和后一个合并
        if (id < zones.size() - 1 && zones.get(id + 1).isFree) {
            Zone next = zones.get(id + 1);
            tmp.size += next.size;
            zones.remove(next);
        }
        // 回收的分区要是前一个是空闲就和前分区合并
        if (id > 0 && zones.get(id - 1).isFree) {
            Zone previous = zones.get(id - 1);
            previous.size += tmp.size;
            zones.remove(id);
            id--;
        }
        zones.get(id).isFree = true;
        System.out.println("内存回收成功!, 本次回收了 " + size + "KB 空间!");
    }

    // 展示分区状况
    public void showZones() {

        System.out.println("分区编号\t    分区始址\t     分区大小\t 空闲状态\t");
        for (int i = 0; i < zones.size(); i++) {
            Zone tmp = zones.get(i);
            System.out.println(i + "\t\t" + tmp.head + "\t\t" + tmp.size + "  \t" + tmp.isFree);
        }

    }
}

运行结果

首先分配一些内存(手动先输好)，然后展示四个算法的运行结果。如图

image-20211209175516571

使用首次适应算法，申请内存大小10kb，遍历空闲分区找到第二个分区为空，所以插入分区2，剩下40kb作为分区3

image-20211209175653091

使用循环首次适应算法，申请内存大小10kb，上一次运行位置在2号分区，所以从2号分区开始寻找，3号分区为空，将10kb放入三号分区，剩下30kb作为分区4

image-20211209175642200

使用最佳适应算法算法，申请内存大小3kb。首先从小到大遍历空闲分区，7号分区大小15kb，满足条件。将3kb插入7号分区，剩余10kb作为8号分区

image-20211209175503300

使用最坏适应算法，申请内存大小2kb。首先从大到小遍历分区，14号分区最大，所以将2kb插入14号分区，剩余232kb作为15号分区

image-20211209175453420

释放11号分区，将10、11、12号分区合并为10号分区

image-20211209181139366

总结

首次适应算法，从链首开始，查找可以用的空闲区，保留了高地址部分的大空闲区，缺点，低地址部分不断被划分，留下许多小的、很难利用的空闲区

循环首次适应算法，不是每次都从首地址查找，而是从上次查找结束的地方开始找，使空闲区分布的更加均匀，减少查询的开销，缺乏大的空闲区

最佳适应算法，每次查找时，将刚刚好的、稍微大一点点的空闲区分给作业，避免了“大材小用”，但留下许多难以利用的小空闲区

最差适应算法，与“最佳”相反，每次都将最大的空闲区分配给作业，产生碎片的可能性小，对中小型作业有利

附一张《王道考研-操作系统》第37讲动态分区总结

image-20211209181543528

张时贰
关注
  • 9
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
操作系统分区分配算法first-fit ,next-fit,worse-fit模拟
10-26
1>基于vs2010，文件比较大。 2>在使用代码之前，建议先看一下‘使用说明.txt'.
实例分析首次适应算法、最佳适应算法、最差适应算法
热门推荐
焕听的专栏
11-15 6万+
关于首次适应算法、最佳适应算法和最差适应算法，先看一下百度百科的解释，已经说出了三者的最大区别。 首次适应算法（first-fit）：从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法的目的在于减少查找时间。 最佳适应算法（best-fit）：从全部空闲区中找出能满足作业要求的，且大小最小的空闲分区，这种方法能使碎片尽量小。 最差适应算法（worst-fit）
动态分区分配算法(First Fit，Next Fit，Best Fit，Worst Fit)
weixin_43886592的博客
07-25 3万+
一、动态分区分配算法的背景 为了能将用户程序装入内存，必须为它分配一定大小的内存空间。连续分配方式是最早出现的一种存储器分配方式， 曾被广泛应用于上世纪60~ -80 年代的OS中，该分配万式为个用户程序分配 一个连续的内存空间， 即程序中代码或数据的逻辑地址相邻，体现在内存空间分配时物理地址的相邻。连续分配方式可分为四类:单一连续分配、固定分区分配、动态分区分配以及动态可重定位分区分配算法四种方式，其中动态分区分配算法就是此实验的实验对象。 动态分区分配又称为可变分区分配，它是根据进程的实际需要，动态地
First Fit next fit best fit off line源代码 和包含测试程序
01-03
on line ，off line on line ，off line on line ，off line on line ，off line on line ，off line on line ，off line on line ，off line on line ，off line on line ，off line on line ，off line on line ，off line
nuxt 服务器渲染动态设置 title和seo关键字的操作
01-21
补充知识：vue 每个页面动态切换title keywords description （seo的设置） 最近接触到需要使用到Seo,要求每个页面拥有不同的title,keywords,description ！！！在这里先添加一步： html文件添加 <meta data-n-...
ESP32 快速入门（九）：自定义 ESP32 分区表 partitions.csv
01-06
esp_image: Image length 1057652 doesn't fit in partition length 1048576 boot: Factory app partition is not bootable boot: No bootable app partitions in the partition table 这里应该是分区表分配给 APP ...
NopCommerce架构分析之(三)EntityFramework数据库初试化及数据操作
01-02
系统启动时执行任务：IStartupTask,启动时执行的任务主要是数据库的初始化和加载。 IStartupTask调用IEfDataProvider进行数据库的初始化。 IEfDataProvider,SqlCeDataProvider：获取数据连接工厂，不同类型数据库，...
javaweb 实验二(TIT)
最新发布
12-13
javaweb 实验二(TIT)
React项目动态设置title标题的方法示例
01-19
那么怎么让title随着路由的切换动态变化呢？ 1.在定义路由时增加title属性。 { path: /regularinvestment, component: Loadable({ loader: () => import('./../../business/Regularinvestment/index'), ...
内存分配算法，包括first-fit，best-fit等
12-28
很详细，很复杂。不过貌似有点小问题，大家可以研究下！
利用 First Fit 和 Best fit 算法解决物流3D bin packing问题 Python实现
10-15
利用First Fit 和 Best fit启发式算法，解决3D物体装箱问题，python实现，用最少的箱子装规定的物体，解决物流问题
动态分区分配内存管理源代码（附有实验报告）最佳适应算法（Best Fit）循环首次适应算法(Next Fit)
06-23
实验题目 设计和实现关于内存管理的内存布局初始化及内存申请分配、内存回收等基本功能操作函数，尝试对用256MB的内存空间进行动态分区方式模拟管理。内存分配的基本单位为1KB，同时要求支持至少两种分配策略，并进行测试和对不同分配策略的性能展开比较评估。 最佳适应算法（Best Fit）： 　　 它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。该算法保留大的空闲区，但造成许多小的空闲区。因为它要不断地找出能满足作业要求的、且大小最小的空闲分区，所以比较比较频繁。但是，对内存的利用率高 循环首次适应算法(Next Fit)： 　　 该算法是首次适应算法的变种。在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。比较次数少于最佳适应算法（Best Fit），内存利用率低于最佳适应算法（Best Fit）。
第4章-实验2-模拟BestFit算法1
08-03
第四章 实验二模拟最佳适应（Best Fit）算法基本思想：BF 的空闲分区表（或空闲分区链）按空闲区大小的升序方式组织。分配时，按空闲分区表（或空闲分区链）的
操作系统原理实验：动态分区分配方式（魔改版first fit（首次适应）算法和best fit（最佳适应）算法）
COFACTOR
05-19 2521
实验目的 了解动态分区分配方式中使用的数据结构和分配算法，进一步加深对动态分区存储管理方式及其实现过程的理解。提高设计实验、发现问题、分析问题和解决问题的能力，并学习撰写规范的科学研究报告。 内容和要求 1．用C或其他语言分别实现动态分区分配过程和回收过程。 2．设置初始状态，每次分配和回收后显示出空闲内存分区链的情况。 实验原理 （1）first fit（首次适应）算法。 现代计算机系统为了确保安全性，操作系统均引入了ASLR（地址空间布局随机化），并与MMU的更复杂的地址翻译机制配合，使得数据在内存中的
装箱问题 BPP first fit、best fit、first fit decreasing、best fit decreasing
软件工程小施同学 的专栏
10-03 3028
装箱问题（ＢＰＰ）：给定一个由刀个实数组成的数列Ｌ＝｛Ｗ１，Ｗ２，…，Ｗ。｝， 这里称Ｗ，∈（０，１】为物件ｆ的尺寸，问题是将每一个物件分配给一个箱使得在每一 个箱中的物件尺寸总和不超过１，且使所使用的箱的数量最小。 至二十世纪７０年代以来，对于该问题人们给出了许多启发式算法。其中最为 人知的有 Ｆｉｒｓｔ—Ｆｉｔ（ＦＦ），Ｂｅｓｔ—Ｆｉｔ（ＢＦ），Ｆｉｒｓｔ—Ｆｉｔ Ｄｅｃｒｅａｓｉｎｇ（ＦＦＤ）及 Ｂｅｓｔ—Ｆｉｔ Ｄｅｃｒｅａｓｉｎｇ（ＢＦＤ），１ ９７４年Ｊｏｈｎｓｏｎ分析了这些算法...
对比first-fit/best-fit/worst-fit/slab以及buddy这几种算法的特点
Ding 的博客
09-08 3万+
以下均为自己对这些算法的理解： fitst-fit算法 First-fit算法：连续物理内存分配算法的一种，将空闲内存块按照地址从小到大的方式连起来，具体实现时使用了双向链表的方式。当分配内存时，从链表头开始向后找，这意味着从低地址向高地址查找，一旦找到可以满足要求的内存块，即将该内存块分配出去即可。在此处为了避免内部碎片问题，具体实现时我们将该可用内存块分为两部分：前一部分大小与所需内存相同，这...
常见内存分配算法：首次适应算法（FirstFit）循环首次适应算法（NextFit）最佳适应算法（BestFit）最坏适应算法（WorstFit）
liying_1234的专栏
07-28 4万+
一、首次适应算法（First Fit）：该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。然后再按      照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链    中。      特点： 该算法倾向于使用内存中低地址部分的空闲区，在高地址部分的空闲区很少被利用，从而保留了高地址部分的大空闲        区。显然为以后到达的大作业分配大的
first-fit、best-fit、worst-fit算法
未来可期
02-25 1364
https://blog.csdn.net/u011070169/article/details/53177987?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task https://blog.csdn.net/liying_1234/article...
我想将人脸特征68个点以此标号并写入tit文件 代码
05-30
好的，你可以使用dlib库中的shape_predictor模型来检测人脸68个关键点，然后将这些关键点的坐标写入tit文件中。以下是一个示例代码： ```python import dlib # 加载dlib预训练的人脸检测器和关键点检测器 detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat") # 读取图像并进行人脸检测 img = dlib.load_rgb_image("face.jpg") dets = detector(img, 1) # 遍历每个检测到的人脸并进行关键点检测 for i, det in enumerate(dets): shape = predictor(img, det) # 将关键点坐标写入tit文件中 with open("face.tit", "w") as f: f.write("68\n") # 写入点数 for j in range(68): x, y = shape.part(j).x, shape.part(j).y f.write(f"{j+1} {x} {y}\n") # 写入点的编号和坐标 ``` 注意，上面的代码中需要使用dlib库中的shape_predictor_68_face_landmarks.dat文件，你需要提前下载该文件并指定其正确的路径。 此外，如果一张图像中有多个人脸，上述代码只会处理其中的一个人脸，你可以根据自己的需求进行修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值