【NX二次开发】获取两个面之间的所有面

 已知两个蓝色面，使用遍历面的方法求紫色面。算法例子：

bool is_NeighborFace(tag_t tagFace1, tag_t tagFace2)
{
    vector<tag_t> vecEdges1;
    uf_list_p_t list1 = NULL;//定义链表
    UF_MODL_create_list(&list1);  //创建链表
    UF_MODL_ask_face_edges(tagFace1, &list1);
    int count1 = 0;
    UF_MODL_ask_list_count(list1, &count1);//链表计数
    for (int i = 0; i < count1; i++)
    {
        tag_t tagEdge = NULL_TAG;
        UF_MODL_ask_list_item(list1, i, &tagEdge);   //接收链表数据
        vecEdges1.push_back(tagEdge);
    }
    UF_free(list1);     //释放链表指针
    list1 = NULL;

    vector<tag_t> vecEdges2;
    uf_list_p_t list2 = NULL;//定义链表
    UF_MODL_create_list(&list2);  //创建链表
    UF_MODL_ask_face_edges(tagFace2, &list2);
    int count2 = 0;
    UF_MODL_ask_list_count(list2, &count2);//链表计数
    for (int i = 0; i < count2; i++)
    {
        tag_t tagEdge = NULL_TAG;
        UF_MODL_ask_list_item(list2, i, &tagEdge);   //接收链表数据
        vecEdges2.push_back(tagEdge);
    }
    UF_free(list2);     //释放链表指针
    list2 = NULL;

    for (int i = 0; i < vecEdges1.size(); i++)
    {
        for (int j = 0; j < vecEdges2.size(); j++)
        {
            if (vecEdges1[i] == vecEdges2[j])
            {
                return true;
            }
        }
    }
    return false;
}

int get_NeighborFaces(tag_t tagFace, vector<tag_t> *vecFaces)
{
    vector<tag_t> vecAllFaces;
    vector<tag_t> vecEdges;
    //获取面的边【自定义函数】
    get_face_edges(tagFace, 0, &vecEdges);
    for (int i = 0; i < vecEdges.size(); i++)
    {
        vector<tag_t> vecTempFaces;
        //获取边的面【自定义函数】
        get_edge_faces(vecEdges[i], &vecTempFaces);
        for (int j = 0; j < vecTempFaces.size(); j++)
        {

            vecAllFaces.push_back(vecTempFaces[j]);
        }
    }
    //排序去重【自定义函数】
    Setting_Order(vecAllFaces, vecFaces, 3);

    for (vector<tag_t>::iterator itor = (*vecFaces).begin(); itor != (*vecFaces).end(); /*++itor*/)
    {
        if (*itor == tagFace)
        {
            itor = (*vecFaces).erase(itor);
        }
        else
        {
            ++itor;
        }
    }
    return 0;
}

int get_faces_Between_two_faces(tag_t tagFace1, tag_t tagFace2, vector<tag_t> *vecFaces)
{
    //如果输入的两个面相邻则return
    if (is_NeighborFace(tagFace1, tagFace2)) return 0;

    vector<tag_t> vecT1;
    vecT1.push_back(tagFace1);
    int m = 0;
    bool isNOK = true;
    while (isNOK)
    {
        vector<tag_t> vecTemp;
        vecTemp.clear();

        //输入一个面输出与他相邻的面 【自定义函数】
        get_NeighborFaces(vecT1[m], &vecTemp);

        vector<tag_t> vecT1_temp;
        vecT1_temp.clear();
        for (int i = 0; i < vecTemp.size(); i++)
        {
            vecT1_temp.push_back(vecTemp[i]);
        }
        //排序去重 【自定义函数】
        Setting_Order(vecT1_temp, &vecT1, 3);

        for (int i = 0; i < vecT1.size(); i++)
        {
            if (vecT1[i] == tagFace2) isNOK = false;
        }

        m++;
    }

    vector<tag_t> vecT2;
    vecT2.push_back(tagFace2);
    m = 0;
    isNOK = true;
    while (isNOK)
    {
        vector<tag_t> vecTemp;
        vecTemp.clear();
        //输入一个面输出与他相邻的面 【自定义函数】
        get_NeighborFaces(vecT2[m], &vecTemp);

        vector<tag_t> vecT2_temp;
        vecT2_temp.clear();
        for (int i = 0; i < vecTemp.size(); i++)
        {
            vecT2_temp.push_back(vecTemp[i]);
        }
        //排序去重 【自定义函数】
        Setting_Order(vecT2_temp, &vecT2, 3);

        for (int i = 0; i < vecT2.size(); i++)
        {
            if (vecT2[i] == tagFace1) isNOK = false;
        }

        m++;
    }

    for (int i = 0; i < vecT1.size(); i++)
    {
        for (int j = 0; j < vecT2.size(); j++)
        {
            if (vecT1[i] == vecT2[j])
            {
                (*vecFaces).push_back(vecT1[i]);
            }
        }
    }

    for (vector<tag_t>::iterator itor = (*vecFaces).begin(); itor != (*vecFaces).end(); /*++itor*/)
    {
        if ((*itor == tagFace1) || (*itor == tagFace2))
        {
            itor = (*vecFaces).erase(itor);
        }
        else
        {
            ++itor;
        }
    }

    return 0;
}