边界模式scipy.ndimage.lap

Question

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

查看函数文档，支持多个选项：

• “反映”（d c b a | a b c d | d c b a）
• “常数”（k k k k | a b c d | k k k k k）
• “最近”（a a a a | a b c d | d d d d d）
• “镜子”（d c b | a b c d | c b a）
• “包装”（a b c d | a b c d | a b c d）

我个人缺少的一件事是一个平滑延续选项。在上述符号中，它对应于镜像选项的稍微修改版本：

• “平稳延续”（a-d）（a-c）（a-b）| a b c d |（d-c）（d-b）（d-a））

这样做的动机是不要在边界处引入纽结，所有支持的选项似乎都是为了任意输入而做的。在

问题：有没有办法在scipy/numpy进行拉普拉斯运算？

Answer 1

我深入研究了一点凌乱的源代码。 我的发现让我觉得仅仅使用pythonscypi/numpy添加定制模式并不容易：最终将在python中重新编写scipy的大部分主干代码。在

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

这可能是github上需要解决的一个问题：要么允许自定义的构建数组方法，要么实现新的模式。或者每人一张票。在

见here。引用：

/* 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;
}

请注意，我绝对不是scipy方面的专家，所以可能我遗漏了一些重要的东西，或者有非常有文档记录的原因可以解释建议的模式是什么。

---

编辑2019-Ap-24 somedocumentation here 我不知道所有细节，但据我所知：

• 它指的是Philippe Thevenez博士的学术工作作为某些算法的潜在来源。
• 这张罚单似乎表明未来可能会开发其他一些模式。

This ticket还处理新模式。在

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