scipy.ndimage.laplace中的边界模

Question

函数scipy.ndimage.laplace可用于计算N维数组中的Laplace算子.如果一个人想要使用这个函数，例如，在物理学中的应用，关键的部分往往是如何处理边界。

在查看功能文档时，支持了一些选项：

• “反映”(d、c、b、a、a、b、c、d、d、c、b、a)
• “常数”(k _a，b，c，d，k，k)
• “最近”(a，a，b，c，d，d)
• “镜像”(d、c、b、a、b、c、d、c、b、a)
• “包装”(a，b，c，d，b，c，d)

我个人错过的一件事是‘平滑延续’选项。在上面的表示法中，它对应于镜像选项的稍微修改的版本：

• “平稳延续”((a-d) (a-c) (a-b) \x{e76f}a、b、c、d (d-c) (d-b) (d-a)

这样做的动机是不要在边界上引入扭结，所有支持的选项似乎都是用于任意输入的。

问题:有什么方法可以在scipy/numpy中完成这个拉普拉斯操作吗？

Answer 1

我稍微钻研了一下原始代码。我所发现的让我觉得仅仅使用python /numpy添加自定义模式并不容易:您最终将重新编码python中的大部分参数代码。

您所指的模式是在底层的C代码中进行管理的。您将需要更改C枚举值，使用自定义模式逻辑相应地更新源文件，并生成新的包。

这可能是在github上打开的一个问题/演化:要么允许自定义构建数组方法，要么实现新模式。或者每人一张票。

见这里。引用：

/* Extend a line in memory to implement boundary conditions: */
int NI_ExtendLine(double *buffer, npy_intp line_length,
                  npy_intp size_before, npy_intp size_after,
                  NI_ExtendMode extend_mode, double extend_value)
{
    double *first = buffer + size_before;
    double *last = first + line_length;
    double *src, *dst, val;

    switch (extend_mode) {
        /* aaaaaaaa|abcd|dddddddd */
        case NI_EXTEND_NEAREST:
            src = first;
            dst = buffer;
            val = *src;
            while (size_before--) {
                *dst++ = val;
            }
            src = last - 1;
            dst = last;
            val = *src;
            while (size_after--) {
                *dst++ = val;
            }
            break;
        /* abcdabcd|abcd|abcdabcd */
        case NI_EXTEND_WRAP:
            src = last - 1;
            dst = first - 1;
            while (size_before--) {
                *dst-- = *src--;
            }
            src = first;
            dst = last;
            while (size_after--) {
                *dst++ = *src++;
            }
            break;
        /* abcddcba|abcd|dcbaabcd */
        case NI_EXTEND_REFLECT:
            src = first;
            dst = first - 1;
            while (size_before && src < last) {
                *dst-- = *src++;
                --size_before;
            }
            src = last - 1;
            while (size_before--) {
                *dst-- = *src--;
            }
            src = last - 1;
            dst = last;
            while (size_after && src >= first) {
                *dst++ = *src--;
                --size_after;
            }
            src = first;
            while (size_after--) {
                *dst++ = *src++;
            }
            break;
        /* cbabcdcb|abcd|cbabcdcb */
        case NI_EXTEND_MIRROR:
            src = first + 1;
            dst = first - 1;
            while (size_before && src < last) {
                *dst-- = *src++;
                --size_before;
            }
            src = last - 2;
            while (size_before--) {
                *dst-- = *src--;
            }
            src = last - 2;
            dst = last;
            while (size_after && src >= first) {
                *dst++ = *src--;
                --size_after;
            }
            src = first + 1;
            while (size_after--) {
                *dst++ = *src++;
            }
            break;
        /* kkkkkkkk|abcd]kkkkkkkk */
        case NI_EXTEND_CONSTANT:
            val = extend_value;
            dst = buffer;
            while (size_before--) {
                *dst++ = val;
            }
            dst = last;
            while (size_after--) {
                *dst++ = val;
            }
            break;
        default:
            PyErr_Format(PyExc_RuntimeError,
                         "mode %d not supported", extend_mode);
            return 0;
    }
    return 1;
}

请注意，我是绝对不是专家在参与，所以我可能错过了一些重大的东西，或有非常有记录的原因解释什么是提议的模式。

编辑2019年-Ap-24一些这里的文件我没有得到所有的细节，但根据我的理解：

• 它将Philippe Thevenez博士的学术工作作为部分算法的潜在来源。
• 这张票似乎表明，未来可能会发展出其他一些模式。

这张票还处理新的模式。

考虑到门票的开放日期，它可能需要一段时间才会到来。