获取NX装配结构信息

最近在做一个项目，需要获取NX装配结构信息，这里把代码分享给大家，希望对各位有帮助，注意以下几点：

1）代码获取了PART的属性、表达式等，因此一些细节可能需要您根据实际情况修改。

2）读写XML用的pugixml，需要您包含到工程中，接口使用的是宽字符模式，所以在pugiconfig.hpp需要打开宽字符开关。

 题外话，本人用过的解析XML的库有微软MSXML、markup、tinyxml、pugixml等，其中pugixml是最好用的，强烈推荐给大家，下载地址：pugixml。

3）代码功能是传入一个装配part，生成一个包含装配信息的xml。

4）代码采用ug open c实现，如果您需要在C#、Java等其他工程中调用，可将其包装成独立的exe，采用后台方式调用。

5）如果您不需要生成XML，可不生成，直接使用其内存对象即可。

6）该代码只是抛砖引玉，仅供参考。

VS后台传参如下：

由于装配结构嵌套可能非常多，生成的xml结构大致如下：

代码如下：

// GenarateAssemblyInfo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "pugiconfig.hpp"
#include "pugixml.hpp"
#include <windows.h>
#include <stdlib.h>
#include <uf_attr.h>
#include <uf_modl.h>
#include <uf.h>
#include <uf_part.h>
#include <uf_assem.h>
#include <uf_ui_ugopen.h>
#include <map>
#include <vector>
#include <NXSigningResource.cpp>
using namespace std;

#ifndef SAFE_DELETE 
#define SAFE_DELETE(p) do{ if(p){delete(p);(p)=NULL;} }while(0)
#endif
typedef    struct _tagAssemblyInfo
{
    _tagAssemblyInfo()
    {
        
    }

    virtual ~_tagAssemblyInfo()
    {
        for (vector<_tagAssemblyInfo*>::iterator iter = children.begin(); iter != children.end(); ++iter)
        {
            SAFE_DELETE (*iter);
        }
    }

    string path;//原型路径
    map<string,map<string, string>> attr;  //组,键值对
    vector<_tagAssemblyInfo*> children;//子件
}AssemblyInfo;


string TCHAR2char( const TCHAR* STR)
{
    string strchar;
    if (!*STR)
    {
        return strchar;
    }
    
    //返回字符串的长度
    int size = WideCharToMultiByte(CP_ACP, 0, STR, -1, NULL, 0, NULL, FALSE);

    //申请一个多字节的字符串变量
    char* str = new char[sizeof(char) * size];

    //将STR转成str
    WideCharToMultiByte(CP_ACP, 0, STR, -1, str, size, NULL, FALSE);
    strchar = str;
    delete (str);

    return strchar;
}

TCHAR* char2TCAHR(const char* str)
{
    int size = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);

    TCHAR* retStr = new TCHAR[size * sizeof(TCHAR)];

    MultiByteToWideChar(CP_ACP, 0, str, -1, retStr, size);

    return retStr;
}

void ReadExpression(AssemblyInfo* info,tag_t obj)
{
    if ((NULL == info) || (NULL_TAG == obj))
    {
        return ;
    }
    
    int number_of_exps = 0;
    tag_t *exps = NULL;
    UF_MODL_ask_exps_of_part(obj,&number_of_exps,&exps);
    char *name = "Exp";
    for (int i = 0; i < number_of_exps; ++i)
    {
        tag_t expTag = *(exps + i);
        char* expStr = NULL;
        UF_MODL_ask_exp_tag_string(expTag, &expStr);
        char* leftStr = NULL;
        char* rightStr = NULL;
        UF_MODL_dissect_exp_string(expStr, &leftStr, &rightStr,&expTag );
        info->attr[name].insert(make_pair(leftStr,rightStr));
        UF_free(expStr);
        UF_free(leftStr);
        UF_free(rightStr);
    }

    UF_free(exps);
}


void ReadAttribute(AssemblyInfo* info,tag_t obj)
{
    if ((NULL == info) || (NULL_TAG == obj))
    {
        return ;
    }
    
    char* category[] = {"ParameterExpression","ParameterMapping", "FxPartThumbnail"}; //组名称

    for (int i = 0; i < _countof(category); ++i)
    {
        int num_attributes = 0;
        logical has_attribute = false;
        
        UF_ATTR_info_t attr_info = {0};
        UF_ATTR_init_user_attribute_info(&attr_info);

        UF_ATTR_iterator_t query;
        UF_ATTR_init_user_attribute_iterator(&query);
        query.category = category[i];
        query.check_category = true;
        query.type = UF_ATTR_string;
        
        UF_ATTR_get_user_attribute(obj,&query,&attr_info,&has_attribute);
        while (has_attribute)
        {
            info->attr[query.category].insert(make_pair(attr_info.title,attr_info.string_value));
            UF_ATTR_free_user_attribute_info_strings(&attr_info);
            UF_ATTR_get_next_user_attribute(obj,&query,&attr_info,&has_attribute);
        }
    }
}

void GetAssembly(AssemblyInfo* info,tag_t occ)
{
    if ((NULL == info) || (NULL_TAG == occ))
    {
        return ;
    }
    tag_t prototype = UF_ASSEM_ask_prototype_of_occ(occ);
    UF_PART_set_display_part(prototype);

    //根据obj获取路径及属性
    char part_fspec [MAX_FSPEC_SIZE+1] = {0};
    UF_PART_ask_part_name(prototype,part_fspec);
    info->path = part_fspec;

    //根据obj获取属性
    ReadAttribute(info, prototype);

    //根据obj获取表达式
    ReadExpression(info, prototype);

    //遍历子节点
    tag_t *child_part_occs = NULL;

    int number = UF_ASSEM_ask_part_occ_children(occ, &child_part_occs);
    for (int i = 0; i < number; ++i)
    {
        AssemblyInfo* childInfo = new AssemblyInfo();
        info->children.push_back(childInfo);
        GetAssembly(childInfo, *(child_part_occs + i));
    }

    UF_free(child_part_occs);
}

void WriteNode(AssemblyInfo* info, pugi::xml_node parent)
{
    if ((NULL == info) || (NULL == parent))
    {
        return ;
    }
    _TCHAR* tmpStr = NULL;
    pugi::xml_node assembly = parent.append_child(_T("assembly"));
    tmpStr = char2TCAHR(info->path.c_str());
    assembly.append_attribute(_T("name")).set_value(tmpStr);
    SAFE_DELETE(tmpStr);
    pugi::xml_node attrs = assembly.append_child(_T("attrs"));

    //属性
    for (map<string,map<string, string>>::iterator iter = info->attr.begin(); iter != info->attr.end(); ++iter)
    {
        pugi::xml_node category = attrs.append_child(_T("category"));
        tmpStr = char2TCAHR(iter->first.c_str());
        category.append_attribute(_T("name")).set_value(tmpStr);
        SAFE_DELETE(tmpStr);
        map<string, string>& attrsMap = iter->second;
        for (map<string, string>::iterator iterAttr = attrsMap.begin(); iterAttr != attrsMap.end(); ++iterAttr)
        {
            pugi::xml_node attr = category.append_child(_T("attr"));
            tmpStr = char2TCAHR(iterAttr->first.c_str());
            attr.append_attribute(_T("name")).set_value(tmpStr);
            SAFE_DELETE(tmpStr);
            tmpStr = char2TCAHR(iterAttr->second.c_str());
            attr.append_attribute(_T("value")).set_value(tmpStr);
            SAFE_DELETE(tmpStr);
        }
    }

    //子节点
    pugi::xml_node children = assembly.append_child(_T("children"));
    for (int i = 0; i < info->children.size(); ++i)
    {
        WriteNode(info->children[i], children);
    }
}

void WriteXml(AssemblyInfo* info,_TCHAR* xmlFile)
{
    if ((NULL == info) || (NULL == xmlFile))
    {
        return ;
    }

    pugi::xml_document doc;
    pugi::xml_node decNode = doc.append_child(pugi::node_declaration);
    pugi::xml_attribute vAttr = decNode.append_attribute(_T("version"));
    vAttr.set_value(_T("1.0"));
    pugi::xml_attribute encAttr = decNode.append_attribute(_T("encoding"));
    encAttr.set_value(_T("utf-8"));

    pugi::xml_node root = doc.append_child(_T("root"));
    WriteNode(info,root);

    doc.save_file(xmlFile, _T("	"), pugi::format_indent, pugi::encoding_utf8);
}

int _tmain(int argc, _TCHAR* argv[])
{
    if (argc < 3)
    {
        return 0;
    }

    if (UF_initialize() != 0) 
    {
        return 0; 
    }

    const _TCHAR* prtPath  = argv[1];
    TCHAR* xmlFile = argv[2];    
    tag_t tag = NULL_TAG;
    UF_PART_load_status_t status;
    UF_PART_open(TCHAR2char(prtPath).c_str(),&tag,&status);
    if (status.failed)
    {
        return 0;
    }

    tag_t occ = UF_ASSEM_ask_root_part_occ(tag);
    AssemblyInfo* info = new AssemblyInfo();
    if (NULL == info)
    {
        return 0;
    }

    GetAssembly(info, occ);
    WriteXml(info,xmlFile);

    UF_terminate();
    delete info;
    return 0;
}