Question

给出所有三角形的列表

v2_T = delaunay(v2_p)

从所有点“v2_p”的列表中，并给出所有三角形邻居的列表

v2_N = neighbors(v2_T)

如何订购“v2_T”，从第一个三角形开始，你在“v2_T”中找到的下一个三角形将始终至少有一个我之前列出的三角形邻居。我能想到的执行类似任务的closet函数可能是二叉树搜索或涉及递归算法的东西。

有人可以提供样本Octave代码吗？感谢。

Answer 1

以下是我对上述问题的未提交解决方案。这是用c ++编写的Octave的动态链接函数，文件名为“dlf_percolate.cc”。要编译此函数，请使用命令系统（'mkoctfile filedirectory / dlf_percolate.cc'）或八度终端中的替代命令mkoctfile“filedirectory / dlf_percolate.cc”，其中必须指定文件目录“filedirectory”的文件所在的位置“ dlf_percolate.cc“已保存。为了测试函数v1_I = dlf_percolate（v2_N），需要生成的邻居列表v2_N =邻居（v2_T），其中v2_T是生成的delaunay三角形列表，neighbor（）是Octave中不存在的函数。可以使用包“msh”http://octave.sourceforge.net/msh/中使用的函数来计算邻居v2_N。一旦有人有v2_N，就可以计算出渗透顺序中数字标记三角形的顺序为v1_I = dlf_percolate（v2_N，v_first_neigh），其中“v_first_neigh”是开始计算所列三角形“v1_I”的渗透顺序的第一个三角形。

#include <octave/oct.h>
void func_perc
    (
        Matrix & v2_neigh_list
        ,
        ColumnVector & v1_perc_list
        ,
        ColumnVector & b1_toggled_neigh
        ,
        int & v0_perc_index
        ,
        int v0_next_neigh
    ) ;
DEFUN_DLD (dlf_percolate, args, ,
"Returns a list of sorted indices of the neighbors in percolated order."
) {
    int v0_first_neigh = 1 ;
    switch( args.length() )
    {
    case 1:
        // v0_first_neigh = 1 default value
        break;
    case 2:
        v0_first_neigh = args(1).scalar_value() ;
        break;
    default:
        error("Only one or two inputs are needed!") ;
        return args;
        break;
    }
    octave_value_list o1_retval ;
    Matrix v2_neigh_list = args(0).matrix_value() ;
    int v0_cols = v2_neigh_list.cols();
    int v0_rows = v2_neigh_list.rows();
    if( ( v0_first_neigh <= 0 ) || ( v0_rows < v0_first_neigh ) )
    {
        error("v0_first_neigh must be a valid member of the list!") ;
        return args;
    }
    ColumnVector v1_perc_list(v0_rows,0);
    ColumnVector b1_toggled_neigh(v0_rows,false);
    int v0_perc_index = 0 ;
    func_perc
        (
            v2_neigh_list
            ,
            v1_perc_list
            ,
            b1_toggled_neigh
            ,
            v0_perc_index
            ,
            v0_first_neigh
        ) ;
    o1_retval(0) = v1_perc_list ;
    return o1_retval ;
}
void func_perc
    (
        Matrix & v2_neigh_list
        ,
        ColumnVector & v1_perc_list
        ,
        ColumnVector & b1_toggled_neigh
        ,
        int & v0_perc_index
        ,
        int v0_next_neigh
    )
    {
        if
            (
                ( v0_next_neigh > 0 )
                &&
                ( ( v0_perc_index ) < v1_perc_list.length() )
                &&
                ( b1_toggled_neigh( v0_next_neigh - 1 ) == false )
            )
            {
                v1_perc_list( v0_perc_index ) = v0_next_neigh ;
                v0_perc_index++;
                b1_toggled_neigh( v0_next_neigh - 1 ) = true ;
                for( int v0_i = 0 ; v0_i < v2_neigh_list.cols() ; v0_i++ )
                    {
                        func_perc
                            (
                                v2_neigh_list
                                ,
                                v1_perc_list
                                ,
                                b1_toggled_neigh
                                ,
                                v0_perc_index
                                ,
                                v2_neigh_list( v0_next_neigh - 1 , v0_i )
                            ) ;
                    }
            }
        return ;
    }

我相信任何计算出的渗透路径都必须包含递归算法。如果不是这样，递归至少可以使代码实现更容易解决这些类型的问题。我在Octave脚本中为此函数设计的第一个构建称为递归的Octave函数，它在递归算法的每一步都逐渐变慢。我相信Octave函数中的递归效率不高，因为解释性语言的功能过于强大。在c ++中为Octave编写本机函数是一种更有效地实现递归算法的方法。 c ++函数func_perc（）是dlf_percolate（）中使用的递归算法。

如何在Octave中将delaunay三角形列表排序到有序的渗透列表？

1 个答案: