基于WebGL和JavaScript实现交互式图像扭曲：坐标系统与点位管理-js教程-PHP中文网

基于webgl和javascript实现交互式图像扭曲：坐标系统与点位管理

本文深入探讨了在JavaScript和WebGL中实现图像扭曲，特别是Beier-Neely方法时遇到的挑战与解决方案。核心内容聚焦于处理HTML页面、Canvas和WebGL之间复杂的坐标系统转换，以及如何有效地管理和传递交互式扭曲点数据到GPU。文章提供了详细的代码示例和专业指导，帮助开发者克服常见的坐标偏移问题，并为处理大量扭曲点提供了进阶思路。

1. 引言：图像扭曲与Beier-Neely方法

图像扭曲（Image Warping）是一种通过几何变换改变图像形状的技术，广泛应用于人脸变形、特效制作和图像校正等领域。Beier和Neely在1992年提出的“基于特征的图像变形”（Feature-Based Image Metamorphosis）方法，通过定义源图像和目标图像上的对应特征线对，实现了平滑自然的图像变形效果。在Web环境中，结合JavaScript的交互性和WebGL的GPU加速能力，可以实现高性能的实时图像扭曲。

然而，在实现过程中，开发者常会遇到一系列技术挑战，尤其是不同坐标系统之间的转换以及如何高效地将大量交互点数据传递给GPU。本教程将重点解决这些问题，并提供一个基于WebGL的图像扭曲实现示例。

2. WebGL图像扭曲基础设置

实现图像扭曲首先需要一个基本的WebGL渲染环境，包括HTML结构、JavaScript初始化代码以及GLSL着色器。

2.1 HTML结构

一个基本的HTML页面需要一个<canvas>元素用于WebGL渲染，以及一些按钮用于用户交互（如选择图片、添加扭曲点）。

立即学习“Java免费学习笔记（深入）”；

<script src="https://cdnjs.cloudflare.com/ajax/libs/gl-matrix/2.8.1/gl-matrix-min.js"></script>

<button id="sl">选择图片</button>
<br>
<button id="editMode">进入点编辑模式</button>
<button id="point" disabled>添加扭曲点</button>
<br>
<canvas id="canvas"></canvas>
<style>
    .warpPoint {
        display: inline-block;
        border-radius: 50%;
        border: 1px solid black;
        background: gold;
        position: absolute;
        width: 10px;
        height: 10px;
    }

    .warpPoint:hover {
        cursor: pointer;
    }
</style>

登录后复制

2.2 JavaScript WebGL初始化

JavaScript代码负责获取WebGL上下文，编译链接着色器，创建纹理，并设置渲染循环。

// 全局常量，用于扭曲强度和半径，方便测试和调整
const STRENGTH = 0.2;
const RADIUS = 50.0 / 300.0; // 相对半径，例如50像素在300像素宽的图像中

let warpPoints = []; // 存储扭曲点数据，每个点包含位置、强度和半径
let warpPointsFlat = []; // 扁平化的扭曲点数组，用于传递给GLSL uniform
let warpPointCount = 0;
let isEditing = false; // 标记是否处于点编辑模式
let img = new Image();
let resolution = vec2.create(); // Canvas分辨率
let canvas = document.getElementById('canvas');
let warpPointCountLoc; // GLSL uniform location
let sl = document.getElementById('sl'); // 选择图片按钮
let editMode = document.getElementById('editMode'); // 编辑模式切换按钮
let point = document.getElementById('point'); // 添加扭曲点按钮
let program, gl, imageLoc, resolutionLoc, texture; // WebGL核心对象

// 初始化Canvas分辨率
resolution[0] = canvas.clientWidth;
resolution[1] = canvas.clientHeight;

// 辅助函数：创建着色器、程序、纹理
function createShader(type, source) { /* ... */ }
function createProgram(vertexShader, fragmentShader) { /* ... */ }
function createTexture(image) { /* ... */ }

// 调整Canvas大小并更新WebGL视口
function resizeCanvas() {
    canvas.width = canvas.clientWidth;
    canvas.height = canvas.clientHeight;
    resolution[0] = canvas.width;
    resolution[1] = canvas.height;
    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
}

// 页面加载完成后的初始化
window.onload = function () {
    gl = canvas.getContext("webgl");
    if (!gl) {
        alert("您的浏览器不支持WebGL！");
        return;
    }

    // 顶点着色器：将屏幕坐标转换为UV坐标
    let vertexShader = createShader(gl.VERTEX_SHADER, `
        attribute vec2 position;
        varying vec2 uv;
        void main() {
            uv = position * 0.5 + 0.5; // 将-1到1的NDC坐标转换为0到1的UV坐标
            gl_Position = vec4(position, 0.0, 1.0);
        }
    `);

    // 片段着色器：应用扭曲效果并采样纹理
    let fragmentShader = createShader(gl.FRAGMENT_SHADER, `
        precision mediump float;
        const int MAX_WARP_POINTS = 10; // 限制扭曲点数量，受限于uniform数组大小
        uniform vec2 resolution;
        uniform vec4 warpPoints[MAX_WARP_POINTS]; // 每个点包含xy位置、强度z和半径w
        uniform int warpPointCount;
        uniform sampler2D image;
        varying vec2 uv;

        void main() {
            vec2 pos = uv; // 当前像素的原始UV坐标
            vec2 newPos = pos; // 经过扭曲后的新UV坐标

            for(int i = 0; i < MAX_WARP_POINTS; i++) {
                if(i >= warpPointCount) {
                    break;
                }
                vec2 warpPoint = warpPoints[i].xy;
                vec2 offset = warpPoint - pos; // 像素到扭曲点的向量
                float dist = length(offset); // 像素到扭曲点的距离
                vec2 direction = offset / dist; // 归一化方向向量
                float strength = warpPoints[i].z;
                float radius = warpPoints[i].w;

                if (dist < radius) {
                    // 应用扭曲：距离越近，扭曲越强
                    // smoothstep用于平滑过渡扭曲效果
                    newPos -= strength * direction * (1.0 - smoothstep(0.0, radius, dist));
                }
            }
            gl_FragColor = texture2D(image, newPos); // 从扭曲后的位置采样纹理
        }
    `);

    program = createProgram(vertexShader, fragmentShader);
    gl.useProgram(program);

    // 获取uniform和attribute位置
    let positionLoc = gl.getAttribLocation(program, 'position');
    resolutionLoc = gl.getUniformLocation(program, 'resolution');
    warpPointCountLoc = gl.getUniformLocation(program, 'warpPointCount');
    imageLoc = gl.getUniformLocation(program, 'image');

    // 创建一个矩形（两个三角形）用于渲染整个图像
    let positionBuffer = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
        -1.0, -1.0, 1.0, -1.0, -1.0, 1.0,
        -1.0, 1.0, 1.0, -1.0, 1.0, 1.0
    ]), gl.STATIC_DRAW);

    gl.enableVertexAttribArray(positionLoc);
    gl.vertexAttribPointer(positionLoc, 2, gl.FLOAT, false, 0, 0);
};

// 窗口大小改变时重新调整Canvas并渲染
window.addEventListener('resize', function () {
    resizeCanvas();
    render();
});

登录后复制

3. 坐标系统转换的挑战与解决方案

在Web环境中，处理鼠标事件和WebGL渲染时，涉及到至少三种不同的坐标系统：

页面坐标 (Page Coordinates): 鼠标事件 (e.clientX, e.clientY) 和HTML元素 (offsetLeft, offsetTop) 使用的坐标，原点在浏览器视口的左上角，Y轴向下。
Canvas元素坐标 (Canvas Element Coordinates): 相对于Canvas元素左上角的坐标，Y轴向下。
WebGL UV坐标 (Texture Coordinates): 在GLSL着色器中使用的纹理坐标，范围通常是 [0.0, 1.0]，原点在纹理的左下角，Y轴向上。

最大的挑战在于从页面坐标正确转换为WebGL UV坐标，尤其是Y轴方向的反转和Canvas在页面中的偏移。

3.1 扭曲点管理 (WarpPoint 类)

为了方便管理交互式扭曲点，我们定义一个 WarpPoint 类，它负责创建HTML元素并在页面上显示，同时处理其位置更新。

乾坤圈新媒体矩阵管家

新媒体账号、门店矩阵智能管理系统

查看详情

// WarpPoint类：管理单个扭曲点的HTML元素和其在WebGL中的数据
function WarpPoint(index) {
    this.index = index;
    this.el = document.createElement("div");
    this.el.className = "warpPoint";
    document.body.appendChild(this.el);

    // 设置扭曲点在页面上的位置，并将其转换为WebGL坐标存储
    this.setPosition = function (x, y) {
        // 设置HTML元素在页面上的绝对位置
        this.el.style.left = `${x}px`;
        this.el.style.top = `${y}px`;

        // 将页面坐标 (x, y) 转换为WebGL UV坐标
        // x_gl: (点的页面X坐标 - Canvas在页面中的X偏移) / Canvas宽度
        let x_gl = (x - canvas.offsetLeft) / resolution[0];
        // y_gl: (Canvas在页面中的底部Y坐标 - 点的页面Y坐标) / Canvas高度
        // (canvas.offsetTop + canvas.offsetHeight) 得到Canvas底部的页面Y坐标
        // 减去点的Y坐标，得到点到Canvas底部的距离，从而实现Y轴反转
        let y_gl = ((canvas.offsetTop + canvas.offsetHeight) - y) / resolution[1];

        // 将WebGL坐标、强度和半径存储到warpPoints数组中
        warpPoints[this.index] = vec4.fromValues(x_gl, y_gl, STRENGTH, RADIUS);
        warpPointsFlat = updateWarpPointsFlat(warpPoints); // 更新扁平化数组
    };

    // 鼠标按下事件处理：拖动扭曲点
    this.el.onmousedown = (e) => {
        var startX = e.clientX;
        var startY = e.clientY;
        var origX = this.el.offsetLeft; // 元素的初始页面X
        var origY = this.el.offsetTop;  // 元素的初始页面Y

        var mouseMoveHandlerBind = (e) => {
            // 计算新的页面位置
            let newX = origX + e.clientX - startX;
            let newY = origY + e.clientY - startY;
            this.setPosition(newX, newY); // 更新点的位置
            render(); // 重新渲染Canvas
        };
        var mouseUpHandler = () => {
            document.removeEventListener('mousemove', mouseMoveHandlerBind);
            document.removeEventListener('mouseup', mouseUpHandler);
        };

        document.addEventListener('mousemove', mouseMoveHandlerBind);
        document.addEventListener('mouseup', mouseUpHandler);
    };
}

登录后复制

3.2 扭曲点数据扁平化 (updateWarpPointsFlat)

WebGL的uniform数组通常需要扁平化的数据。updateWarpPointsFlat函数将vec4数组转换为Float32Array。

function updateWarpPointsFlat(warpPoints) {
    let warpPointsFlat = [];
    for (let i = 0; i < warpPoints.length; i++) {
        warpPointsFlat.push(warpPoints[i][0]); // x
        warpPointsFlat.push(warpPoints[i][1]); // y
        warpPointsFlat.push(STRENGTH); // z (强度)
        warpPointsFlat.push(RADIUS); // w (半径)
    }
    return new Float32Array(warpPointsFlat);
}

登录后复制

3.3 添加扭曲点 (addWarpPoint)

点击“添加扭曲点”按钮时，创建一个新的WarpPoint实例并放置在Canvas中央。

point.onclick = addWarpPoint;
function addWarpPoint() {
    // 初始创建一个vec4占位符
    warpPoints.push(vec4.fromValues(0, 0, STRENGTH, RADIUS));
    var newWarpPoint = new WarpPoint(warpPoints.length - 1); // 传入索引
    // 计算Canvas中央的页面坐标
    let x = canvas.offsetLeft + canvas.width / 2;
    let y = canvas.offsetTop + canvas.height / 2;
    newWarpPoint.setPosition(x, y); // 设置初始位置

    warpPointCount = warpPoints.length;
    warpPointsFlat = updateWarpPointsFlat(warpPoints);
    render(); // 渲染以显示新点和扭曲效果
}

登录后复制

4. 渲染循环 (render 函数)

render 函数是WebGL应用程序的核心，它负责清除画面、更新uniforms并执行绘制命令。

function render() {
    gl.clear(gl.COLOR_BUFFER_BIT); // 清除颜色缓冲区
    gl.useProgram(program); // 使用着色器程序

    gl.uniform2fv(resolutionLoc, resolution); // 传递分辨率

    // 如果存在扭曲点，更新uniform数组
    if (warpPointsFlat.length > 0) {
        for (let i = 0; i < warpPointCount; i++) {
            let offset = i * 4; // 每个点占用4个浮点数 (x, y, strength, radius)
            let warpPoint_i_Location = gl.getUniformLocation(program, 'warpPoints[' + i + ']');
            // 使用subarray传递单个vec4数据
            gl.uniform4fv(warpPoint_i_Location, warpPointsFlat.subarray(offset, offset + 4));
        }
    }

    gl.activeTexture(gl.TEXTURE0); // 激活纹理单元0
    gl.bindTexture(gl.TEXTURE_2D, texture); // 绑定图像纹理

    gl.uniform1i(imageLoc, 0); // 将纹理单元0传递给u_image uniform
    gl.uniform1i(warpPointCountLoc, warpPointCount); // 传递扭曲点数量

    gl.drawArrays(gl.TRIANGLES, 0, 6); // 绘制两个三角形组成的矩形
}

登录后复制

5. 加载图片与交互模式

图片加载和编辑模式切换是用户交互的重要组成部分。

// 选择图片按钮点击事件
sl.onclick = () => {
    var inp = document.createElement("input");
    inp.type = "file";
    inp.onchange = () => {
        var url = URL.createObjectURL(inp.files[0]);
        img.src = url;
        img.onload = () => {
            texture = createTexture(img); // 创建WebGL纹理
            resizeCanvas(); // 根据图片大小调整Canvas
            render(); // 渲染图像
        };
    };
    inp.click(); // 模拟点击文件输入框
};

// 编辑模式切换按钮点击事件
editMode.onclick = () => {
    isEditing = !isEditing; // 切换编辑状态
    point.disabled = !isEditing; // 根据编辑状态启用/禁用添加点按钮
    editMode.innerHTML = isEditing ? "已进入编辑模式。点击切换到扭曲模式" : "已进入扭曲模式。点击切换到编辑模式";
};

登录后复制

6. 进阶：处理大量扭曲点

当前示例通过 uniform vec4 warpPoints[MAX_WARP_POINTS] 数组向着色器传递扭曲点数据。然而，WebGL对 uniform 数组的大小有限制（通常 MAX_WARP_POINTS 不会超过几十或几百）。对于需要数百甚至数千个扭曲点的场景，这种方法不再适用。

解决方案：使用纹理作为数据源 (Texture as Data)

一种常见的解决方案是将扭曲点数据编码到一张纹理中，然后在片段着色器中通过 texture2D 函数采样这张纹理来获取点数据。

数据编码: 将每个扭曲点的 (x, y, strength, radius) 数据打包成纹理的像素颜色值（例如，使用RGBA通道）。
创建数据纹理: 在JavaScript中，创建一个新的 gl.TEXTURE_2D 纹理，其尺寸足以存储所有点数据。例如，如果有N个点，每个点4个浮点数，可以创建一个 N x 1 或 sqrt(N) x sqrt(N) 的纹理，并使用 gl.RGBA 格式和 gl.FLOAT 数据类型（如果支持OES_texture_float扩展）。
着色器中采样: 在

以上就是基于WebGL和JavaScript实现交互式图像扭曲：坐标系统与点位管理的详细内容，更多请关注php中文网其它相关文章！