侧边栏壁纸
博主头像
AUGS 探索实验室

授之以鱼,不如授之以渔

  • 累计撰写 153 篇文章
  • 累计创建 56 个标签
  • 累计收到 0 条评论

目 录CONTENT

文章目录
UF

装配设计

已删除用户
已删除用户
2023-04-01 / 0 评论 / 2 点赞 / 302 阅读 / 0 字

基本概念和术语

在装配环境中总保持只有一个部件是当前活动的，它叫工作部件(work part)。用户创建的所有UF对象、表达式等都是在工作部件中创建。此外，还有一个叫当前显示部件(display part)的概念。在UG的某些应用(如Modeling)时，当前显示部件和工作部件可以不同。

术语描述
tag对象标识，一个tag_t 标识一个UG对象，这个对象不仅仅是几何对象。还可以是部件文件、实例和事例
piece part单个零件，是装配中最基本的元素，包含几何和特征。
Occurence当若干个零件被加入到一个装配中，系统不在装配中拷贝零件和其中的对象，而是将零件加载到内存，并将零件的事例放入到装配中，事例是对实际存在的部件原型的引用。
object Occurence零件中的每个对象，都会在装配中有一个对应的对象事例。
instance当组件被加入到装配中，组件称为实例。对每个实例，都会显示一个对应的事例，实例可理解为一种指针，由下级部件事例指向上级部件事例。
Multi-level装配可以是多层的，即装配中可以有子装配。
prototype一个事例的主几何体。对于组件文件事例情况下，是包含主几何体的零件。
component part组件是部件在装配体中的引用，组件可以是包含更低一级组件的子装配。
reference set在复杂装配中，为简化组件表达而定义的有名字的集合。这个集合包含了部件文件中的几何实体。当传递给函数的引用集名称是NULL时，表示函数对整个操作有用，如果引用集的名称是Empty，则使用empty reference set
display part当前显示在图形窗口中的模型。可以是一个零件，也可以是装配。显示模型必须是完全加载的。
work part建模过程中正在被使用的组件文件。该文件中的几何或装配结构正在被修改。工作组件可以和显示组件相同，或者是装配中的某个显示组件。当工作组件作为一个显示装配中的组件，可以仅仅被部分加载。只有在工作组件中的对象可以被修改。对象的事例不能被改变。

装配树结构

UG装配是以树型结构组织装配中的部件，一个部件文件中只能有一棵装配树，即只能存在一个装配根节点。装配中的节点由部件原型、部件事件与部件实例3种对象进行描述。

部件事件

part occurrence

是装配环境下对实际存在的部件模型（即部件原型）的一种引用，部件事件也可以理解为指向部件原型的指针。如果需要一次或多次装配一个部件，并不复制该部件的原型，而是建立该部件原型所对应的事件。在装配中，不同的部件事件表征不同的装配节点，因此UG赋予它唯一的标识。

部件原型

part Prototype

是真实存在的部件模型，它记录了模型所需的所有数据。当一个部件文件被多次装入时，将产生不同的部件事件，但这些事件都指向相同的部件原型。可以看出，部件原型与部件事件之间形成一对多的映射关系。部件事件随原型的改变而改变，但修改部件事件不会影响它的原型。

部件实例

part Instance

记录子节点与其父节点之间的关联关系，从而形成各节点间的层次结构。在装配体中，部件与其子部件之间的装配关系是利用部件实例来描述的。部件实例是指一次或多次装入装配体的部件对象，它描述装配环境下实例之间的层次关系，并表征惟一的上下级部件间的装配关系。部件实例也可以理解为一种指针，由下级部件事件指向上一级部件事件。可以看出，部件实例与部件事件之间形成一对多的映射关系，即不同的装配节点可能具有相同的装配关系。

装配节点具有相同部件实例的条件有3个：

  1. 装配节点具有相同的部件原型。
  2. 父装配节点不能相同，即父节点事件不同。
  3. 父节点事件指向同一个部件文件，即父节点原型相同。

例如，由于Wheel Part-occur-tag-5与Wheel Part-occur-tag-7具有相同的部件原型和不同的父节点事件Axle Part-occur-tag-3与Axle Part-occur-tag-4，且父节点事件都指向相同的部件原型，因此它们具有相同的部件实例Instance-tag-1；尽管Wheel Part-occur-tag-5与Wheel Part-occur-tag-6指向同一个部件原型，但其父节点相同，不满足上述条件（2）, 因此它们具有不同的部件实例Instance-tag-1与Instance-tag-2 。

image-20230225204327024

image-20230225204338762

常用函数

/* 得到当前的work part prototype tag */
extern tag_t UF_ASSEM_ask_work_part ( ); 

/* 设置当前的work part prototype tag */
extern int UF_ASSEM_set_work_part ( tag_t part ); 

/* 得到当前的work part occurrence tag */
extern tag_t UF_ASSEM_ask_work_occurrence ( ); 

/* 设置当前的work part occurrence tag */
extern int UF_ASSEM_set_work_occurrence ( tag_t part_occur ); 

/* 得到根part的occurrence tag, 输入的part必须是根part prototype tag */
extern tag_t UF_ASSEM_ask_root_part_occ ( tag_t part ); 

/* 得到某个instance的父part prototype tag */
extern tag_t UF_ASSEM_ask_parent_of_instance ( tag_t instance ); 

/* 得到某个instance的part prototype tag */
extern tag_t UF_ASSEM_ask_child_of_instance ( tag_t instance ); 

/* 得到父part下某个instance name的instance tag */
extern tag_t UF_ASSEM_ask_instance_of_name ( tag_t parent_part, const char * instance_name );  

/* 得到父part下某个instance的part occurrence tag */
extern tag_t UF_ASSEM_ask_part_occ_of_inst ( tag_t parent_part_occ, tag_t instance );

/* 得到某个instance的所有part occurrence tag */
extern int UF_ASSEM_ask_part_occs_of_inst ( tag_t instance, tag_t ** part_occs ); 

/* 得到某个part occurrence的instance tag */
extern tag_t UF_ASSEM_ask_inst_of_part_occ ( tag_t part_occur ); 



/* 得到父part下某个part prototype的所有part occurrence tag */
extern int UF_ASSEM_ask_occs_of_part ( tag_t parent_part, tag_t part, tag_t ** part_occs );

/* 得到某个object prototype的所有object occurrence tag */
extern int UF_ASSEM_ask_occs_of_entity ( tag_t object, tag_t ** occurrences ); 

/* 得到某个object或part occurrence的object或part prototype tag */
extern tag_t UF_ASSEM_ask_prototype_of_occ ( tag_t occurrence ); 

/* 得到某个object或part occurrence的父part occurrence tag */
extern tag_t UF_ASSEM_ask_part_occurrence ( tag_t occurrence ); 

/* 得到某个part occurrence下所有子part occurrence tag */
extern int UF_ASSEM_ask_all_part_occ_children ( tag_t part_occur, tag_t ** child_part_occs );


/* 同上 */
extern int UF_ASSEM_ask_part_occ_children ( tag_t part_occur, tag_t ** child_part_occs );

/* 得到某个part occurrence中所有object occurrence tag的个数 */
extern int UF_ASSEM_count_ents_in_part_occ ( tag_t part_occur );

/* 得到某个part occurrence中某个object prototype的object occurrence tag */
extern tag_t UF_ASSEM_find_occurrence ( tag_t part_occur, tag_t object_prototype ); 

/* 得到某个part occurrence在当前work part中的part occurrence tag */
extern int UF_ASSEM_get_occ_in_work_occ ( tag_t part_occ, tag_t * occ_in_work ); 

/* 判断某个part或object tag是否是occurrence tag */
extern logical UF_ASSEM_is_occurrence ( tag_t entity ); 


/* 判断某个part是否是occurrence tag */
extern logical UF_ASSEM_is_part_occurrence ( tag_t occurrence ); 
/* 判断某个part occurrence是否属于当前的work part */
extern int UF_ASSEM_occ_is_in_work_part ( tag_t part_occ, logical * is_in_work ); 
/* 循环查找某个part occurrence中的所有object occurrence tag */
extern tag_t UF_ASSEM_cycle_ents_in_part_occ ( tag_t part_occur, tag_t object_occur ); 
/* 循环查找某个part prototype下的所有instance tag */
extern tag_t UF_ASSEM_cycle_inst_of_part ( tag_t parent_part, tag_t instance );

遍历装配树

遍历装配树的基本算法如下：首先获取装配树根，然后获取根的子部件。对每个子部件递归求解下一级子部件，如此循环，直到子部件为单个零件（ Piece Part ）

Test_assembly_ask_root

int Test_assembly_ask_root(tag_t* work_part_tag, tag_t* work_occ_tag, tag_t* root_part_tag, tag_t* root_occ_tag) {
	tag_t  work_part, work_occ, assem_occ, cycle_occ;
	int      result = 0;
	if (UF_PART_ask_display_part() != NULL_TAG) {
		work_part = UF_ASSEM_ask_work_part();
		work_occ = UF_ASSEM_ask_work_occurrence();
		if (work_occ == NULL_TAG) {
			assem_occ = UF_ASSEM_ask_root_part_occ(work_part);
			if (assem_occ != NULL_TAG) {
				result = 0;
				*work_occ_tag = assem_occ;
				*work_part_tag = work_part;
				*root_occ_tag = assem_occ;
				*root_part_tag = work_part;
			}
			else {
				result = 2;
				*work_occ_tag = NULL_TAG;
				*work_part_tag = work_part;
				*root_occ_tag = NULL_TAG;
				*root_part_tag = work_part;
			}
		}
		else {
			result = 1;
			*work_occ_tag = work_occ;
			*work_part_tag = work_part;
			do { cycle_occ = UF_ASSEM_ask_part_occurrence(work_occ);
			if (cycle_occ != NULL_TAG)
				work_occ = cycle_occ; } while (cycle_occ != NULL_TAG);
			*root_occ_tag = work_occ;
			*root_part_tag = UF_ASSEM_ask_prototype_of_occ(*root_occ_tag);
		}
	}
	else { result = 3;
	*work_occ_tag = NULL_TAG;
	*work_part_tag = NULL_TAG;
	*root_occ_tag = NULL_TAG;
	*root_part_tag = NULL_TAG; }
	return result;
}

Test_assembly_ask_all_children_occs

void Test_assembly_ask_all_children_occs(tag_t part_occ, int* num_children_occs, tag_t** children_occs) {
	int 
		idx = 0, num_occs = 0, error = 0;
	tag_t* occs_tag = NULL;
	*num_children_occs = 0;
	*children_occs = NULL;
	if (part_occ == NULL_TAG)
		return;
	num_occs = UF_ASSEM_ask_part_occ_children(part_occ, &occs_tag);
	if (num_occs > 0) {
		(*num_children_occs) += num_occs;
		*children_occs = (tag_t*)UF_reallocate_memory(*children_occs, (*num_children_occs * sizeof(tag_t)), &error);
		for (idx = 0; idx < num_occs; idx++)
			(*children_occs)[*num_children_occs - num_occs + idx] = occs_tag[idx];
		for (idx = 0; idx < num_occs; idx++)
			Test_assembly_ask_all_children_occs(occs_tag[idx], num_children_occs, children_occs); }
	UF_free(occs_tag);
}

Test_assembly_ask_all_children_insts

void Test_assembly_ask_all_children_insts(tag_t part_occ, int* num_children_insts, tag_t** children_insts)
{
	int
		idx = 0, jdx = 0, num_children_occs = 0, error = 0;
	tag_t* children_occs = NULL, instance = NULL_TAG;
	*num_children_insts = 0;
	*children_insts = NULL;
	if (part_occ == NULL_TAG)        return;

	Test_assembly_ask_all_children_occs(part_occ, &num_children_occs, &children_occs);
	for (idx = 0; idx < num_children_occs; idx++) {
		instance = UF_ASSEM_ask_inst_of_part_occ(children_occs[idx]);
		jdx = 0;
		while (jdx < *num_children_insts && instance != (*children_insts)[jdx]) jdx++;
		if (jdx == *num_children_insts) {
			(*num_children_insts)++;
			*children_insts = (tag_t*)UF_reallocate_memory(*children_insts, (*num_children_insts * sizeof(tag_t)), &error);
			(*children_insts)[*num_children_insts - 1] = instance;
		}
	}
	UF_free(children_occs);
}

Test_assembly_ensure_children_fully_loaded

void Test_assembly_ensure_children_fully_loaded() { 
	tag_t 
		work_part_tag = NULL_TAG, 
		work_occ_tag = NULL_TAG,
		root_part_tag = NULL_TAG ,
		root_occ_tag = NULL_TAG;
	int 
		idx = 0 , 
		num_children_insts = 0, 
		result = 0;
	tag_t* children_insts = NULL;
	result = Test_assembly_ask_root(&work_part_tag, &work_occ_tag, &root_part_tag, &root_occ_tag);
	if (result == 0 || result == 1) { 
		Test_assembly_ask_all_children_insts(root_occ_tag, &num_children_insts, &children_insts);
		for (idx = 0; idx < num_children_insts; idx++) { UF_PART_load_status_t  load_status = { 0 };
		UF_ASSEM_ensure_child_loaded(children_insts[idx], &load_status);
		UF_free(load_status.statuses);
		UF_free_string_array(load_status.n_parts, load_status.file_names); }
		UF_free(children_insts); 
	} 
}

返回

Returns :  
0 - work part is root part
1 - work part is child part
2 - No assembly part
3 - No active part

部件对象间的访问

  • 一棵装配树中仅允许一个装配根节点存在，因此根节点的原型与事件成一一对应关系，可以通过函数相互访问。如果装配树中仅有一个节点，即装配件为单个零件，则该节点的事件为空，即 tPrtOccRoot = NULL_TAG。注意，根节点中不存在部件实例对象，即 tPrtInsRoot = NULL_TAG。

    tPrtOcc_1 = UF_ASSEM_ask_root_part_occ(tPrtPro_1);
tPrtPro_1 = UF_ASSEM_ask_prototype_of_occ(tPrtOcc_1);

  • 从装配树中可以看出，父节点与子节点成一对多的映射关系，它们之间的访问可以通过函数[1][2][3]来实现。函数[1]访问该节点下一级子节点的事件列表；函数[2]实现的功能与函数[1]相同，但其获得的列表中包括抑制的子节点事件，并且只有NX及以上版本才提供该函数；函数[3]访问某个子节点的父节点事件。

    1. UF_ASSEM_ask_part_occ_children
    2. UF_ASSEM_ask_all_part_occ_children
    3. UF_ASSEM_ask_part_occurrence

  • 同一个部件可以多次装入装配体，形成不同的装配节点。因此，在一个装配树中，部件原型与部件事件成一对多的映射关系，它们之间的访问通过函数[1][2]来实现。函数[1]访问某部件原型在装配体中的节点事件；函数[2]访问装配体中某个节点事件的原型。

    1. UF_ASSEM_ask_occs_of_part
    2. UF_ASSEM_ask_prototype_of_occ

  • Ø相同的部件实例可能对应着不同的子节点事件。因此，部件实例与子节点事件是一对多的映射关系，它们之间的访问通过函数[1][2][3]来实现。函数[1]访问父节点下某个部件实例所对应的子节点事件；函数[2]访问某个部件实例所对应的所有子节点事件；函数[3]访问子节点事件的实例。

    1. UF_ASSEM_ask_part_occ_of_inst
    2. UF_ASSEM_ask_part_occs_of_inst
    3. UF_ASSEM_ask_inst_of_part_occ

  • 通过部件实例访问部件原型的情况分为两种：访问子部件和访问父部件。它们之间的访问通过函数[1][ 2][3]来实现。函数[1]访问部件实例的子部件原型；函数[2]访问部件实例的父部件原型；函数[3]访问父部件原型下的部件实例。通过子部件原型访问父部件可以使用函数[4]实现。

    1. UF_ASSEM_ask_child_of_instance
    2. UF_ASSEM_ask_parent_of_instance
    3. UF_ASSEM_cycle_inst_of_part
    4. UF_ASSEM_where_is_part_used

装配体中的几何对象

  • 装配体中的几何对象包括实体（ solid ）、表面（ face ）、边界（ edge）和顶点（ point )等。几何对象在装配中具有两种形式：对象事件（object occurrence ）和对象原型（ object prototype ）。不同的几何对象具有不同的对象事件和对象原型，如表面对象事件与原型、边界对象事件与原型。几何对象中的事件和原型的关系与部件中的基本相同，对象原型是指位于部件原型中真实存在的几何对象，对象事件是装配环境下对对象原型的一种引用。
  • 获取几何对象事件的原型 UF_ASSEM_ask_prototype_of_occ()
  • 获取包含某几何对象的部件事件 UF_ASSEM_ask_part_occurrence()
  • 根据几何对象原型获取指定装配节点中所包含的对象事件 UF_ASSEM_find_occurrence()
  • 在部件事件中遍历所有几何对象的事件 UF_ASSEM_ask_occ_of_entity()
  • 判断该对象是否是对象实例 UF_ASSEM_is_occurrence()

部件的装入

  • ØUG中一个完整的装配过程分为两部分：部件的装入与部件间配合关系的创建。
  • Ø一般使用UF函数UF_ASSEM_add_part_to_assembly()来实现在装配体中装入一个部件的功能。在一个装配过程中，装配部件以指定的位置和姿态装入到工作部件的指定层中，从而实现了装配部件与工作部件的上下级装配关系。

添加组件

将part添加到装配

int UF_ASSEM_add_part_to_assembly ( 
    tag_t parent_part, 
    const char * part, 
    const char * refset_name, 
    const char * instance_name,
    double origin[ 3 ], 
    double csys_matrix[ 6 ], 
    int layer, 
    tag_t * instance, 
    UF_PART_load_status_t * error_status
);

获得组件数据

int UF_ASSEM_ask_component_data ( 
    tag_t component, 
    char part_name[256+1],
    char refset_name[30+1],
    char instance_name[30+1], 
    double origin[ 3 ], 
    double csys_matrix[ 9 ], 
    double transform[ 4 ][ 4 ] 
);

Test_assembly_add_component

void Test_assembly_add_component (
    char *component_file_name, 
    char *instance_name, double origin[3], 
    double x_vec[3], 
    double y_vec[3],
    int layer,/* -1 - original layers; 0 - work layer; 1~256 - layer */ 
    tag_t *instance_tag ){
    tag_t work_part = UF_ASSEM_ask_work_part();
    char refset_name[] = "";
    double csys_matrix[6];
    UF_PART_load_status_t error_status;
    csys_matrix[0] = x_vec[0]; csys_matrix[1] = x_vec[1]; csys_matrix[2] = x_vec[2]; 
    csys_matrix[3] = y_vec[0]; csys_matrix[4] = y_vec[1]; csys_matrix[5] = y_vec[2];
    UF_ASSEM_add_part_to_assembly (
        work_part, component_file_name, refset_name,instance_name, origin, csys_matrix, layer, instance_tag, &error_status 
    );
}

编辑部件

int UF_ASSEM_reposition_instance ( tag_t instance, double new_origin[ 3 ], double new_csys_matrix[ 6 ] ); 
int UF_ASSEM_remove_instance ( tag_t instance );
int UF_ASSEM_rename_instance ( tag_t instance, const char *new_name ); 
int UF_ASSEM_suppress_instances ( int n_instances, tag_t instances[ ], int failures[ ] ); 
int UF_ASSEM_unsuppress_instances ( int n_instances, tag_t instances[ ], int failures[ ] );
int UF_ASSEM_ask_suppress_state( tag_t instance, logical * suppressed ); 
int UF_ASSEM_set_suppression_exp( tag_t instance,const char * exp_string, tag_t * exp_tag ); 
int UF_ASSEM_unset_suppression_exp( tag_t instance ); 
int UF_ASSEM_ask_suppression_exp( tag_t instance, tag_t * exp ); 
int UF_ASSEM_create_explosion ( tag_t display_part_tag, char * explosion_name, tag_p_t explosion_tag );
int UF_ASSEM_explode_component ( tag_t explosion, tag_t part_occurrence, double transform[ 4 ][ 4 ] );

配合关系的创建与编辑

装配中各部件间的配合关系是通过装配约束关系来实现的。装配约束是指一个部件到另一个部件的约束，即部件A配合到部件B，则部件A称为主动件（ From )，部件B称为被动件（ To ）。在约束求解过程中，被动件在装配空间中的位置固定，而主动件将变换姿态到满足装配约束的位置上。需要注意的是，组成配合关系的约束之间不能存在几何关系上的矛盾，并且配合关系不能形成循环定义，即部件A配合到部件B上时，不能再定义部件B配合到部件A上。

配合关系的创建过程如下：

  1. 定义约束关系：填写结构UF_ASSEM_constraint_s
  2. 求解约束：使用函数UF_ASSEM_solve_mc()求解
  3. 应用约束到装配体：UF_ASSEM_apply_mc_data()
  4. 更新模型：使用函数UF_MODL_update
UF函数说明
UF_ASSEM_check_mc_structure()检查配对条件是否
UF_ASSEM_ask_mc_data_of_compnt()合法读取指定部件的配对条件
UF_ASSEM_suppress_mc()抑制或非抑制指定部件的配对条件
UF_ASSEM_delete_mc()删除指定部件的配对条件

组件集和引用集操作

  • Ø组件集（ Component Groups ）可以对装配树的部件进行统一操作。

  • Ø引用集（ Reference Sets ）是虚拟装配中的一个重要概念。通过定义引用集，用户可以方便地控制系统中显示的对象和部件装入内存的数据量。

    组件集

    int UF_ASSEM_create_cset ( tag_t part, char * name, tag_t * object );  
int UF_ASSEM_add_to_cset ( tag_t cset, tag_t component, logical level ); 
int UF_ASSEM_is_member_of_cset ( tag_t cset, tag_t component, logical * result ); 
int UF_ASSEM_remove_from_cset ( tag_t cset, tag_t component );

    Test_assembly_create_component_set

    void Test_assembly_create_component_set (
    int num_comp_occs, 
    tag_t * comp_occs, 
    char *component_set_name, 
    tag_t *component_set_tag ){
    UF_OBJ_cycle_by_name_and_type( UF_ASSEM_ask_work_part(),   component_set_name, UF_component_set_type, false, component_set_tag );
    if ( *component_set_tag )
        UF_OBJ_delete_object( *component_set_tag );
    UF_ASSEM_create_cset( UF_ASSEM_ask_work_part(), component_set_name, component_set_tag );
    if ( *component_set_tag )  {
        for ( int idx = 0; idx < num_comp_occs; idx ++ )
            UF_ASSEM_add_to_cset( *component_set_tag, comp_occs[idx], false );
    }
}

    Test_assembly_create_component_set

    void Test_assembly_create_component_set ( 
    int num_comp_occs,
    tag_t * comp_occs, 
    char *component_set_name, 
    tag_t *component_set_tag 
){
    UF_OBJ_cycle_by_name_and_type( 
        UF_ASSEM_ask_work_part(),   
        component_set_name, 
        UF_component_set_type, 
        false, 
        component_set_tag );
    if ( *component_set_tag ) 
        UF_OBJ_delete_object( *component_set_tag );
    UF_ASSEM_create_cset( UF_ASSEM_ask_work_part(), component_set_name, component_set_tag );
    if ( *component_set_tag )  {
        for ( int idx = 0; idx < num_comp_occs; idx ++ )
            UF_ASSEM_add_to_cset( *component_set_tag, comp_occs[idx], false );
    }
}

    引用集

    int UF_ASSEM_create_ref_set ( const char * ref_set_name, double origin[ 3 ], double matrix[ 9 ], tag_t * ref_set_members, int members_count, tag_t * ref_set_tag ); 
int UF_ASSEM_add_ref_set_members ( tag_t ref_set_tag, int members_count, tag_t * ref_set_members ); 
int UF_ASSEM_edit_ref_set_data ( tag_t ref_set_tag, double origin[ 3 ], double matrix[ 9 ] ); 
int UF_ASSEM_remove_ref_set_members ( tag_t ref_set_tag, int members_count, tag_t * ref_set_members ); 
int UF_ASSEM_ask_ref_set_data ( tag_t ref_set_tag, char ref_set_name[ 30 + 1 ], double origin[ 3 ], double matrix[ 9 ], int * members_count, tag_p_t * ref_set_members ); 

int UF_ASSEM_ask_ref_set_members ( tag_t ref_set_tag, int * members_count, tag_p_t * ref_set_members ); 
int UF_ASSEM_ask_ref_sets ( tag_t ref_set_member, int * num_ref_sets, tag_p_t * ref_sets ); 
int UF_ASSEM_count_ref_sets_in ( tag_t object ); 
tag_t UF_ASSEM_get_ref_set_inst ( tag_t object, int number ); 
int UF_ASSEM_is_ref_set_member ( tag_t potential_member, logical * member_flag ); 
int UF_ASSEM_replace_refset ( int count, tag_t * target_tags, /* part instance tag or part occurrence tag*/ const char * new_refset_name );
    UF函数说明
    UF_OBJ_delete_object()删除引用集
    UF_OBJ_set_name()变更引用集名称

    Test_ref_set_is_exist

    void Test_ref_set_is_exist ( tag_t part_tag, char *ref_set_name, logical *is_exist, tag_t *ref_set_tag ){
    tag_t cycle_ref_set = NULL_TAG;
    *is_exist = FALSE;
    *ref_set_tag = NULL_TAG;
    do {  
        UF_OBJ_cycle_by_name_and_type ( part_tag, ref_set_name, UF_reference_set_type, FALSE, cycle_ref_set );
        if ( cycle_ref_set ) {
            *is_exist = TRUE;
            *ref_set_tag = cycle_ref_set;
            break;
        }
    } while ( cycle_ref_set );
}

装配复制操作

  • 装配复制操作是一个十分有用的功能。例如，在调用零件库或组合件库时必须复制一份库中的文件到用户路径下。通常情况下，装配复制方法有 3 种： Save As方法、COPYFILE方法和装配克隆方法。image-20230225225312781
  • 在 UG 操作中实现Save As方法的步骤如下：在 UG 界面打开一个装配文件，选择菜单命令 File → Save As 激活 Save Part File As 对话框，在对话框中输入新文件名，则装配根节点文件被复制了一份。此时，新创建的装配根节点指向原装配体中的叶节点，通常使用函数 UF_PART_save_as()复制单个零件。
  • Save As 方法一次只能复制一个文件，无法复制整个装配树。
  • Ø如果需要复制整个装配树可以采用 COPYFILE 方法。 COPYFILE 方法是采用 MFC 库提供的 COPYFILE 函数实现装配文件的复制。
  • ØCOPYFILE 方法虽然可以实现装配树复制的功能，但存在两个问题：一是装配树中的零部件不在同一个路径下时该方法失效；二是不能对复制后的文件更名，否则将丢失部件间的装配关系。
  • Ø为了解决这些问题，可以采用装配克隆方法。装配克隆保持新装配中的零部件相互关系不发生变化，对新模型的修改不影响原装配部件。

装配克隆操作的过程大致需要以下几个步骤：

  1. 选择菜单命令 Assemblies → Cloning → Create Clone Assembly，弹出 Clone Assembly 对话框。
  2. 添加原装配部件到克隆装配中，有 Add Assembly 和 Add Part两种方法。
  3. 指定默认的克隆方式，有 Retain 和 Clone 两种方法。
  4. 指定默认文件名的方法，有 User Name 和 Define Naming Rule 两种方法。
  5. 定义新装配的克隆命名规则，有 Add Prefix、 Add Suffix、 Replace 和 Rename 4种方法。
  6. 定义克隆部件的存储目录。
  7. 产生克隆报告。
  8. 执行克隆操作。
int UF_CLONE_initialise( UF_CLONE_operation_class_t operation_class );
/* UF_CLONE_clone_operation/UF_CLONE_edit_operation/UF_CLONE_import_operation/UF_CLONE_export_operation */
int UF_CLONE_terminate ( );
int UF_CLONE_set_def_action( UF_CLONE_action_t action );
/* UF_CLONE_clone/UF_CLONE_retain/UF_CLONE_replace …*/
int UF_CLONE_set_def_naming( UF_CLONE_naming_technique_t naming_technique );
/* UF_CLONE_autogen/UF_CLONE_autotranslate/UF_CLONE_naming_rule/UF_CLONE_user_name */
int UF_CLONE_set_def_nm_copy( UF_CLONE_copy_nm_opt_p_t copy_nonmaster_opts );
/* set the nonmaster copy option: simulation …  */
int UF_CLONE_set_name_rule ( UF_CLONE_name_rule_def_p_t name_rule, UF_CLONE_naming_failures_p_t naming_failures ); 
int UF_CLONE_set_naming ( 
    const char * input_part_name, UF_CLONE_naming_technique_t naming_technique, const char * output_part_name ); 
int UF_CLONE_set_dryrun ( logical dryrun ); 
int UF_CLONE_set_logfile ( const char * log_file_name ); 
int UF_CLONE_add_assembly( const char * part_name,UF_PART_load_status_p_t load_status ); 
int UF_CLONE_add_part( const char * part_name ); 
int UF_CLONE_perform_clone( UF_CLONE_naming_failures_p_t naming_failures );

WAVE

int UF_WAVE_create_linked_body ( 
    const tag_t body, const tag_t xform, const tag_t object_in_part, const logical update_at_timestamp, tag_t * linked_feature ); 
int UF_WAVE_create_linked_face ( 
    const tag_t face, const tag_t xform, const tag_t object_in_part, const logical update_at_timestamp, tag_t * linked_feature ); 
int UF_WAVE_create_linked_region ( 
    const int n_seed_faces, 
    const tag_t * seed_faces, 
    const int n_boundary_faces, 
    const tag_t * boundary_faces,
    const tag_t xform, 
    const tag_t object_in_part,
    const logical update_at_timestamp, 
    const logical traverse_interior_edges, 
    const logical delete_openings, tag_t *linked_feature ); 
int UF_WAVE_create_linked_sketch ( 
    const tag_t sketch, 
    const tag_t xform, 
    const tag_t object_in_part, 
    tag_t * linked_feature 
); 
int UF_WAVE_create_linked_curve ( 
    const tag_t curve, 
    const tag_t xform, 
    const tag_t object_in_part,
    const logical update_at_timestamp, 
    tag_t * linked_feature 
); 

int UF_WAVE_create_linked_datum ( 
    const tag_t datum, const tag_t xform, const tag_t object_in_part, tag_t * linked_feature ); 
int UF_WAVE_ask_link_source ( const tag_t linked_feature, const logical allow_load, tag_t * source_entity ); 
int UF_WAVE_ask_linked_feature_geom ( const tag_t linked_feature, tag_t * linked_geom ); 
int UF_WAVE_ask_link_xform ( const tag_t linked_feature, tag_t * xform ); 
int UF_WAVE_is_link_broken ( const tag_t linked_feature, logical * is_broken ); 
int UF_WAVE_set_link_data ( const tag_t linked_feature, const tag_t source_entity, const tag_t xform, const logical update_at_timestamp );
2
装配 assem

  1. 支付宝打赏

    qrcode alipay

  2. 微信打赏

    qrcode weixin
版权归属： 已删除用户
本文链接： https://augs.cn/archives/zhuang-pei-she-ji
许可协议： 本文使用《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》协议授权

评论区