基于XSLT生成地图多边形内部随机点的技术求助

我完全懂你之前把JS逻辑嵌入XSL没成功的痛点——核心问题往往是XSLT的上下文环境和JS的执行时机没协调好。下面给你一套可落地的方案，分步骤拆解：

一、先搞定多边形内部随机点的JS核心函数 #

先把生成逻辑单独写稳，这个函数接收多边形的顶点坐标数组（比如[{x:10,y:20}, {x:30,y:40}, ...]），返回一个在内部的随机点对象：

function getRandomPointInPolygon(vertices) {
    // 第一步：计算多边形的包围盒，缩小随机范围
    let minX = Infinity, maxX = -Infinity;
    let minY = Infinity, maxY = -Infinity;
    vertices.forEach(v => {
        minX = Math.min(minX, v.x);
        maxX = Math.max(maxX, v.x);
        minY = Math.min(minY, v.y);
        maxY = Math.max(maxY, v.y);
    });

    // 第二步：随机生成点，用射线法判断是否在内部
    let point;
    do {
        point = {
            x: minX + Math.random() * (maxX - minX),
            y: minY + Math.random() * (maxY - minY)
        };
    } while (!isPointInPolygon(point, vertices));

    return point;
}

// 射线法判断点是否在多边形内部
function isPointInPolygon(point, vertices) {
    let inside = false;
    const x = point.x, y = point.y;
    for (let i = 0, j = vertices.length - 1; i < vertices.length; j = i++) {
        const xi = vertices[i].x, yi = vertices[i].y;
        const xj = vertices[j].x, yj = vertices[j].y;
        
        const intersect = ((yi > y) !== (yj > y))
            && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
        if (intersect) inside = !inside;
    }
    return inside;
}

这个逻辑的优势是：先用包围盒缩小随机范围，再用射线法做精确判断，既保证效率又不会出错。

二、在XSLT中正确嵌入并调用JS函数 #

之前失败大概率是没处理好XSLT和JS的交互，这里分两种场景给你方案：

场景1：用XSLT 1.0配合MSXML（Windows环境） #

如果是在Windows下用MSXML处理器，你可以用<msxsl:script>标签嵌入JS：

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:msxsl="urn:schemas-microsoft-com:xslt"
                xmlns:custom="http://your-namespace.com/custom">

    <msxsl:script language="JScript" implements-prefix="custom">
        // 把上面的getRandomPointInPolygon和isPointInPolygon函数放这里
        function getRandomPointInPolygon(vertices) {
            // 实现代码...
        }
        function isPointInPolygon(point, vertices) {
            // 实现代码...
        }

        // 注意：XSLT传递过来的参数是XML节点集合，需要先转成JS对象数组
        function generateRandomPoint(xmlVertices) {
            let vertices = [];
            for (let i = 0; i < xmlVertices.length; i++) {
                vertices.push({
                    x: parseFloat(xmlVertices[i].selectSingleNode('x').text),
                    y: parseFloat(xmlVertices[i].selectSingleNode('y').text)
                });
            }
            let point = getRandomPointInPolygon(vertices);
            // 返回XSLT能处理的XML片段或者字符串
            return `<point x="${point.x.toFixed(2)}" y="${point.y.toFixed(2)}"/>`;
        }
    </msxsl:script>

    <xsl:template match="/">
        <newXML>
            <polygon>
                <!-- 保留原多边形的边信息 -->
                <xsl:copy-of select="polygon/edges"/>
            </polygon>
            <randomPoints>
                <!-- 生成5个随机点，可修改数量 -->
                <xsl:call-template name="generatePoints">
                    <xsl:with-param name="count" select="5"/>
                    <xsl:with-param name="vertices" select="polygon/vertices/vertex"/>
                </xsl:call-template>
            </randomPoints>
        </newXML>
    </xsl:template>

    <xsl:template name="generatePoints">
        <xsl:param name="count"/>
        <xsl:param name="vertices"/>
        <xsl:if test="$count > 0">
            <!-- 调用自定义JS函数生成点 -->
            <xsl:value-of select="custom:generateRandomPoint($vertices)" disable-output-escaping="yes"/>
            <!-- 递归生成下一个点 -->
            <xsl:call-template name="generatePoints">
                <xsl:with-param name="count" select="$count - 1"/>
                <xsl:with-param name="vertices" select="$vertices"/>
            </xsl:call-template>
        </xsl:if>
    </xsl:template>

</xsl:stylesheet>

这里关键是：

• 用implements-prefix给JS函数绑定命名空间，方便XSLT调用
• 把XML节点转成JS能处理的坐标对象数组
• 用disable-output-escaping="yes"让生成的XML片段正确输出

场景2：用XSLT 2.0/3.0配合Saxon（跨平台） #

如果用Saxon这类支持XSLT 3.0的处理器，你可以用<xsl:script>（标准语法）嵌入JS，或者直接用XQuery的随机函数配合自定义函数：

<xsl:stylesheet version="3.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:xs="http://www.w3.org/2001/XMLSchema"
                xmlns:custom="http://your-namespace.com/custom"
                exclude-result-prefixes="xs custom">

    <xsl:script language="javascript" implement-prefix="custom">
        // 同样放入getRandomPointInPolygon和isPointInPolygon函数
        function getRandomPointInPolygon(vertices) {
            // 实现代码...
        }
        function isPointInPolygon(point, vertices) {
            // 实现代码...
        }

        // 接收XSLT的序列，转成JS数组
        function generatePoint(verticesSeq) {
            let vertices = [];
            for (let v of verticesSeq) {
                vertices.push({x: parseFloat(v.x), y: parseFloat(v.y)});
            }
            let p = getRandomPointInPolygon(vertices);
            return {x: p.x, y: p.y};
        }
    </xsl:script>

    <xsl:template match="/">
        <newXML>
            <xsl:copy-of select="polygon"/>
            <randomPoints>
                <!-- 生成5个随机点 -->
                <xsl:for-each select="1 to 5">
                    <point>
                        <xsl:variable name="randPoint" select="custom:generatePoint(/polygon/vertices/vertex)"/>
                        <xsl:attribute name="x" select="$randPoint/x"/>
                        <xsl:attribute name="y" select="$randPoint/y"/>
                    </point>
                </xsl:for-each>
            </randomPoints>
        </newXML>
    </xsl:template>

</xsl:stylesheet>

Saxon对JS的支持更标准，不需要处理转义的问题，直接返回对象就能在XSLT中调用属性。

三、测试与调优建议 #

• 先单独测试JS函数：用固定的顶点数组调用getRandomPointInPolygon，验证返回的点确实在内部
• 调整随机点的精度：用toFixed(n)控制坐标的小数位数，避免输出太长的数字
• 性能优化：如果多边形很大，包围盒的范围可以再优化，或者用网格预划分的方式减少射线法的判断次数

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