已知向量夹角与线段长度，如何计算约束线段的关节角度？

问题背景与需求 #

咱们现在有这么个几何场景：两个向量，其中Y轴对齐的向量OG（模长3）固定不动，X轴对齐的向量OE（模长4）可以旋转，两者通过固定长度的线段HG（长度3）和HE（长度2）连接到同一个点H。已知初始状态下angleGamma=90°，两向量的夹角为82.74°，现在需要求解当angleGamma小于90°时对应的angleAlpha（OG与HG的夹角）和angleBeta（OE与HE的夹角）。

核心约束条件 #

要让这个几何系统有可行解，约束线段HG和HE必须满足以下三角不等式条件：

• 两线段长度之和/差要在合理范围内：|OG - OE| ≤ HG + HE ≤ OG + OE
• 单独线段长度也要适配向量模长，确保以G为圆心HG为半径的圆，和以E为圆心HE为半径的圆存在交点（这是求解H点的核心逻辑）

双定位法的两组解 #

这个问题本质是圆的交点问题：以G为圆心、HG为半径画圆，以E为圆心、HE为半径画圆，两个圆的交点就是H点的可能位置，对应两组解：

1. 内侧解：H点落在OG和OE形成的夹角内部
2. 外侧解：H点落在OG和OE形成的夹角外部

可视化与求解代码示例 #

下面是用JSXGraph实现的交互式可视化代码，包含角度转换、圆交点计算、角度求解的完整逻辑，你可以直接运行查看效果：

// 初始化JSXGraph画板，绑定到页面id为jxgbox的元素
const board = JXG.JSXGraph.initBoard('jxgbox', {
    boundingbox: [-5, 5, 5, -5],
    axis: true,
    showNavigation: false
});

// 角度转弧度工具函数
function degToRad(deg) {
    return deg * Math.PI / 180;
}

// 弧度转角度工具函数
function radToDeg(rad) {
    return rad * 180 / Math.PI;
}

// 计算两圆交点的核心函数
function circleIntersection(x1, y1, r1, x2, y2, r2) {
    const dx = x2 - x1;
    const dy = y2 - y1;
    const d = Math.sqrt(dx*dx + dy*dy);

    // 处理无交点、完全重合或包含的情况
    if (d > r1 + r2 || d < Math.abs(r1 - r2) || (d === 0 && r1 === r2)) {
        return [];
    }

    // 计算交点坐标的中间参数
    const a = (r1*r1 - r2*r2 + d*d) / (2*d);
    const h = Math.sqrt(r1*r1 - a*a);
    const xMid = x1 + (dx * a)/d;
    const yMid = y1 + (dy * a)/d;

    // 计算两个交点的坐标
    const point1 = [xMid + (dy * h)/d, yMid - (dx * h)/d];
    const point2 = [xMid - (dy * h)/d, yMid + (dx * h)/d];

    return [point1, point2];
}

// 定义已知参数
const OG_LENGTH = 3;
const OE_LENGTH = 4;
const HG_LENGTH = 3;
const HE_LENGTH = 2;
const INITIAL_GAMMA = 90; // 初始angleGamma角度
const VEC_ANGLE = 82.74; // 两向量的固定夹角（示例值）

// 创建固定点O和固定向量OG（Y轴对齐）
const pointO = board.create('point', [0, 0], {name: 'O', fixed: true});
const pointG = board.create('point', [0, OG_LENGTH], {name: 'G', fixed: true});

// 创建可旋转的向量OE，初始状态对应angleGamma=90°
let currentGamma = degToRad(INITIAL_GAMMA);
const pointE = board.create('point', [OE_LENGTH * Math.cos(currentGamma), OE_LENGTH * Math.sin(currentGamma)], {name: 'E'});

// 更新H点位置并计算角度的函数
function updateHPoints() {
    // 获取G和E的坐标
    const [, gX, gY] = pointG.coords.usrCoords;
    const [, eX, eY] = pointE.coords.usrCoords;

    // 计算两圆交点
    const intersections = circleIntersection(gX, gY, HG_LENGTH, eX, eY, HE_LENGTH);

    // 移除旧的H点和线段（如果存在）
    if (window.hPoint1) board.removeObject(hPoint1);
    if (window.hPoint2) board.removeObject(hPoint2);
    if (window.segHG1) board.removeObject(segHG1);
    if (window.segHE1) board.removeObject(segHE1);
    if (window.segHG2) board.removeObject(segHG2);
    if (window.segHE2) board.removeObject(segHE2);

    if (intersections.length === 2) {
        // 创建两个H点
        hPoint1 = board.create('point', intersections[0], {name: 'H(内侧)', color: '#ff4444'});
        hPoint2 = board.create('point', intersections[1], {name: 'H(外侧)', color: '#33b5e5'});

        // 绘制约束线段
        segHG1 = board.create('segment', [pointG, hPoint1], {color: '#ff4444'});
        segHE1 = board.create('segment', [pointE, hPoint1], {color: '#ff4444'});
        segHG2 = board.create('segment', [pointG, hPoint2], {color: '#33b5e5'});
        segHE2 = board.create('segment', [pointE, hPoint2], {color: '#33b5e5'});

        // 计算内侧解的angleAlpha和angleBeta
        const vecOG = [0, OG_LENGTH];
        const vecHG1 = [hPoint1.X() - gX, hPoint1.Y() - gY];
        const dotAlpha1 = vecOG[0] * vecHG1[0] + vecOG[1] * vecHG1[1];
        const angleAlpha1 = radToDeg(Math.acos(dotAlpha1 / (OG_LENGTH * HG_LENGTH)));

        const vecOE = [eX, eY];
        const vecHE1 = [hPoint1.X() - eX, hPoint1.Y() - eY];
        const dotBeta1 = vecOE[0] * vecHE1[0] + vecOE[1] * vecHE1[1];
        const angleBeta1 = radToDeg(Math.acos(dotBeta1 / (OE_LENGTH * HE_LENGTH)));

        console.log('内侧解角度：', {angleAlpha: angleAlpha1.toFixed(2), angleBeta: angleBeta1.toFixed(2)});

        // 计算外侧解的angleAlpha和angleBeta
        const vecHG2 = [hPoint2.X() - gX, hPoint2.Y() - gY];
        const dotAlpha2 = vecOG[0] * vecHG2[0] + vecOG[1] * vecHG2[1];
        const angleAlpha2 = radToDeg(Math.acos(dotAlpha2 / (OG_LENGTH * HG_LENGTH)));

        const vecHE2 = [hPoint2.X() - eX, hPoint2.Y() - eY];
        const dotBeta2 = vecOE[0] * vecHE2[0] + vecOE[1] * vecHE2[1];
        const angleBeta2 = radToDeg(Math.acos(dotBeta2 / (OE_LENGTH * HE_LENGTH)));

        console.log('外侧解角度：', {angleAlpha: angleAlpha2.toFixed(2), angleBeta: angleBeta2.toFixed(2)});
    }
}

// 初始化时更新H点
updateHPoints();

// 添加滑块控制angleGamma，实时更新E点位置和H点
const gammaSlider = board.create('slider', [[-4, -3], [1, -3], [0, INITIAL_GAMMA, 180]], {name: 'angleGamma(°)'});
gammaSlider.on('drag', function() {
    currentGamma = degToRad(this.Value());
    pointE.moveTo([OE_LENGTH * Math.cos(currentGamma), OE_LENGTH * Math.sin(currentGamma)]);
    updateHPoints();
});

内容的提问来源于stack exchange，提问作者deblocker