这篇文章主要介绍“TensorFlow.js怎么实现AI换脸使用”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“TensorFlow.js怎么实现AI换脸使用”文章能帮助大家解决问题。

步骤 1：准备工作

在开始之前，需要确保已经安装了Node.js和npm。在终端中输入以下命令来验证：

node -v
npm -v

如果输出了相应的版本号，说明已经安装成功。

接着，需要安装一些必要的依赖包。在终端中进入项目目录，输入以下命令来安装：

npm install @tensorflow/tfjs @tensorflow-models/face-landmarks-detection @tensorflow/tfjs-node
npm install canvas

这里要注意有一个坑，安装@tensorflow/tfjs-node的时候，需要确保你有全局安装过

windows-build-tools

cnpm

步骤 2：加载模型

加载TensorFlow.js提供的面部关键点检测模型。这个模型是识别人脸的关键点，包括眼睛、鼻子、嘴巴等等。代码如下：

// 导入所需的依赖包
const tf = require('@tensorflow/tfjs-node');
const faceLandmarksDetection = require('@tensorflow-models/face-landmarks-detection');
// 加载面部关键点检测模型
const loadModel = async () => {
  const model = await faceLandmarksDetection.load(
    faceLandmarksDetection.SupportedPackages.mediapipeFacemesh,
    { shouldLoadIrisModel: false }
  );
  return model;
};
// 调用loadModel函数加载模型
const model = await loadModel();

上述代码中作用是识别人脸的关键点，使用

faceLandmarksDetection.load

mediapipeFacemesh

shouldLoadIrisModel

loadModel

步骤 3：加载图片

接下来，需要加载需要处理的两张图片。使用canvas来完成这个任务。代码如下：

const { createCanvas, loadImage } = require('canvas');
// 加载两张图片
const loadImages = async () => {
  // 创建canvas并获取context
  const canvas = createCanvas(640, 480);
  const ctx = canvas.getContext('2d');
  // 加载sourceImage
  const sourceImage = await loadImage('source.jpg');
  canvas.width = sourceImage.width;
  canvas.height = sourceImage.height;
  ctx.drawImage(sourceImage, 0, 0);
  // 加载targetImage
  const targetImage = await loadImage('target.jpg');
  canvas.width = targetImage.width;
  canvas.height = targetImage.height;
  ctx.drawImage(targetImage, 0, 0);
  // 返回结果
  return { sourceImage, targetImage, canvas };
};
// 调用loadImages函数加载图片
const { sourceImage, targetImage, canvas } = await loadImages();

这里假设source.jpg和target.jpg是两张需要处理的图片。

步骤 4：提取面部关键点

有了模型和图片之后，就可以提取出两张图片中的面部关键点了。提取面部关键点代码如下：

const extractFaceLandmarks = async (model, image) => {
  // 将image转换成tensor
  const tensor = tf.browser.fromPixels(image);
  // 使用estimateFaces方法得到关键点
  const predictions = await model.estimateFaces({
    input: tensor,
    returnTensors: false,
    flipHorizontal: false,
    predictIrises: false
  });
  // 释放tensor占用的内存
  tensor.dispose();
  return predictions;
};
// 提取sourceImage和targetImage的面部关键点
const sourceFaceLandmarks = await extractFaceLandmarks(model, sourceImage);
const targetFaceLandmarks = await extractFaceLandmarks(model, targetImage);

这段代码实现了从图片中提取面部关键点的功能。通过将图片转换为tensor，然后使用

estimateFaces

步骤 5：应用变形

有了两张图片的面部关键点之后，就可以开始应用变形了。代码如下：

// 导入FaceMesh和Geometry2d类
const { FaceMesh } = require('@mediapipe/face_mesh');
const { Geometry2d } = require('@mediapipe/geometry');
// 定义applyWarp函数
const applyWarp = (sourceFaceLandmarks, targetFaceLandmarks, sourceImage, targetImage) => {
  // 创建FaceMesh、Geometry2d实例
  const faceMesh = new FaceMesh();
  const sourceGeometry = new Geometry2d();
  const targetGeometry = new Geometry2d();
  // 定义warpTriangles函数，使用Delaunay算法将source和target的关键点连接起来，得到一组三角形网格
  const warpTriangles = (sourcePoints, targetPoints) => {
    const delaunay = d3.Delaunay.from(sourcePoints);
    const { triangles } = delaunay;
    const sourceTriangles = triangles.map(i => sourcePoints[i]);
    const targetTriangles = triangles.map(i => targetPoints[i]);
    return { sourceTriangles, targetTriangles };
  };
  // 对source和target的关键点应用warpTriangles函数，得到sourceTriangles和targetTriangles
  const { sourceTriangles, targetTriangles } = warpTriangles(sourceFaceLandmarks[0].scaledMesh, targetFaceLandmarks[0].scaledMesh);
  // 将sourceTriangles和targetTriangles转换为Geometry2d实例
  sourceGeometry.setFromPoints(sourceTriangles.flat());
  targetGeometry.setFromPoints(targetTriangles.flat());
  // 计算仿射变换矩阵
  const warp = sourceGeometry.getAffineTransform(targetGeometry);
  // 创建canvas并绘制sourceImage
  const { canvas } = createCanvas(sourceImage.width, sourceImage.height);
  const ctx = canvas.getContext('2d');
  ctx.beginPath();
  ctx.moveTo(sourceFaceLandmarks[0].scaledMesh[0][0], sourceFaceLandmarks[0].scaledMesh[0][1]);
  for (let i = 1; i < sourceFaceLandmarks[0].scaledMesh.length; i++) {
    ctx.lineTo(sourceFaceLandmarks[0].scaledMesh[i][0], sourceFaceLandmarks[0].scaledMesh[i][1]);
  }
  ctx.closePath();
  ctx.clip();
  // 将targetImage按照仿射变换矩阵映射到sourceImage上
  ctx.setTransform(warp[0], warp[3], warp[1], warp[4], warp[2], warp[5]);
  ctx.drawImage(targetImage, 0, 0, targetImage.width, targetImage.height, 0, 0, sourceImage.width, sourceImage.height);
  // 将生成的图片转换为buffer并返回
  return canvas.toBuffer();
};
// 应用applyWarp函数
const result = applyWarp(sourceFaceLandmarks, targetFaceLandmarks, sourceImage, targetImage);

这里使用的是FaceMesh模型，它可以将面部关键点转换为三角形网格。然后使用Delaunay算法将两张图片中的关键点连接起来，得到一组三角形网格。最后，将sourceImage中的每个三角形，通过仿射变换映射到targetImage上，从而实现换脸的效果。将生成的图片转换为buffer，即可完成整个换脸过程。

result

applyWarp

用Node.js中的fs模块将result保存为图片。以下是示例代码：

const fs = require('fs');
fs.writeFileSync('result.jpg', result);

将

result

result.jpg