geardesign.c

Pro.TOOLKIT.Wildfire插件设计.配套光盘-141M.zip

	    
	    switch (i)
	      {
	      case 0:
		offset = g_ptr->datum_x_offset;
		break;
	      case 1:
		offset = g_ptr->datum_y_offset;
		break;
	      case 2:
		offset = g_ptr->datum_z_offset;
		break;
	      }
	    
	    offs_tree[6].data.v.d = offset;
	    
	    
	    /*-----------------------------------------------------------------*\
	      Create Element Tree
	      \*-----------------------------------------------------------------*/
	    def_tree[4].data.v.i = axes[i];
	    err = ProUtilElemtreeCreate(def_tree, SIZEOFARR(def_tree), NULL, &elem_tree);
	    
	    /*-----------------------------------------------------------------*\
	      Create Default Datum
	      \*-----------------------------------------------------------------*/
	    err = ProMdlToModelitem(g_ptr->model, &modelitem);
	    err = ProSelectionAlloc(NULL, &modelitem, &featsel);
	    err = ProFeatureCreate(featsel, elem_tree, NULL, 0, &f, &errs);
	    if (err != PRO_TK_NO_ERROR)
	      {
		ProUtilFeatErrsWrite("ProFeatureCreate", err, elem_tree, &errs);
		return (-1);
	      }
	    
	  /*-----------------------------------------------------------------*\
	    Find surface ID for datum plane feature
	    \*-----------------------------------------------------------------*/
	    ProUtilFeatFirstGeomitem(&f, PRO_SURFACE, id[i]);
	    
	    err = ProUtilSelectionFromSurfaceId(g_ptr->model, 
						*id [i], 
						&offs_tree[5].data.v.r);
	    
	    err = ProUtilElemtreeCreate(offs_tree, SIZEOFARR(offs_tree), NULL, &elem_tree);
	    
	    err = ProFeatureCreate(featsel, elem_tree, NULL, 0, &f, &errs);
	    if (err != PRO_TK_NO_ERROR)
	      {
		ProUtilFeatErrsWrite("ProFeatureCreate", err, elem_tree, &errs);
		return (-1);
	      }
	    
	    err = ProModelitemNameSet((ProModelitem*)&f, names[i]);
	    if (err != PRO_TK_NO_ERROR)
	      return (-1);
	    
	    ProSelectionFree(&featsel);
	    
	    
	    ProUtilFeatFirstGeomitem(&f, PRO_SURFACE, id[i]);
	    ProUtilFeatFirstDimension(&f, dim_id[i]);
	  }
      }
    else 
      {
	ProDimension dx, dy, dz;
	
	ProModelitemInit (g_ptr->model, g_ptr->datum_x_offset_dim_id,
			  PRO_DIMENSION, &dx);
	ProDimensionValueSet (&dx, g_ptr->datum_x_offset);
	
	
	ProModelitemInit (g_ptr->model, g_ptr->datum_y_offset_dim_id,
			  PRO_DIMENSION, &dy);
	ProDimensionValueSet (&dy, g_ptr->datum_y_offset);
	
	ProModelitemInit (g_ptr->model, g_ptr->datum_z_offset_dim_id,
			  PRO_DIMENSION, &dz);
	ProDimensionValueSet (&dz, g_ptr->datum_z_offset);
	
	ProSolidRegenerate (g_ptr->model, 0);

	ProWindowRepaint (-1);
      }

    g_ptr->datum_created = PRO_B_TRUE;

    return (0);
}

/*=============================================================*\
  Function: 	ProUserCreateDisk
  Purpose:	create gear disk
\*=============================================================*/
int ProUserCreateDisk(GearParam *g_ptr)
{
    static ElemTreeData tree[]={
     	{0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}},
	{1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_PROTRUSION}},
	{1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}},
	{1, PRO_E_EXT_SURF_CUT_SOLID_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_FEAT_TYPE_SOLID}},
	{1, PRO_E_REMOVE_MATERIAL, {PRO_VALUE_TYPE_INT, PRO_EXT_MATERIAL_ADD}},
	{1, PRO_E_STD_SECTION,  {(ProValueDataType)-1}},
	{2, PRO_E_STD_SEC_SETUP_PLANE, {(ProValueDataType)-1}},
	{3, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}},
	{3, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_ONE}},
	{3, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}},
	{3, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}},
	{1, PRO_E_FEAT_FORM_IS_THIN, {PRO_VALUE_TYPE_INT, PRO_EXT_FEAT_FORM_NO_THIN}},
	{1, PRO_E_STD_DIRECTION, {PRO_VALUE_TYPE_INT, PRO_EXT_CR_IN_SIDE_TWO}},
	{1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}},
	{2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}},
	{3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_NONE}},
	{2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}},
	{3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_BLIND}},
	{3, PRO_E_EXT_DEPTH_TO_VALUE, {PRO_VALUE_TYPE_DOUBLE}},
    };
    ProElempathItem depth_path[] = {
	{PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_STD_EXT_DEPTH},
	{PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_EXT_DEPTH_FROM},
	{PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_EXT_DEPTH_FROM_VALUE}
    };
    ProError err;
    FeatureDef feat_def;
    ProFeature feature;
    ProModelitem modelitem;
    Pro3dPnt pnt;

    if (g_ptr->gear_depth == 0.0 || g_ptr->gear_diam == 0.0)
      return 1;

/*-----------------------------------------------------------------*\
    Preparation of feature data
\*-----------------------------------------------------------------*/
    memset(&feat_def, 0, sizeof(feat_def));
    err =ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, 
	&tree[7].data.v.r);
    err = ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, 
	&tree[10].data.v.r);
    
    tree[18].data.v.d = g_ptr->gear_depth; 

    feat_def.tree = tree;
    feat_def.sizeof_tree = SIZEOFARR(tree);

    feat_def.params[0].d = g_ptr->gear_diam;
    feat_def.params[1].r = tree[10].data.v.r;
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->bottom_surface_id, 
	&feat_def.params[2].r);
    feat_def.section_create_func = ProUtilCreateCircleSection;

    feat_def.feat_name  = "Gear_Disk";

/*-----------------------------------------------------------------*\
    Create new feature
\*-----------------------------------------------------------------*/
    err  = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feature);
    if (err == PRO_TK_NO_ERROR)
    {
	g_ptr->disk_created = 1;

/*-----------------------------------------------------------------*\
    Find and name required surfaces
\*-----------------------------------------------------------------*/

	pnt[0] = g_ptr->datum_x_offset;
	pnt[1] = g_ptr->datum_y_offset;
	pnt[2] = g_ptr->gear_depth + g_ptr->datum_z_offset;
	ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem);
	g_ptr->disk_front_surf_id = modelitem.id;
	ProUtilModelitemNameSet(&modelitem, "DISK_FRONT");

	pnt[0] = g_ptr->datum_x_offset;
	pnt[1] = g_ptr->gear_diam/2 + g_ptr->datum_y_offset; 
	pnt[2] = g_ptr->gear_depth/2 + g_ptr->datum_z_offset;
	ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem);
	g_ptr->disk_side_surf_id = modelitem.id;
	ProUtilModelitemNameSet(&modelitem, "DISK_SIDE");

	ProViewRefit (g_ptr->model, NULL);

    }
    
/*-----------------------------------------------------------------*\
    Free allocated memory
\*-----------------------------------------------------------------*/
    ProSelectionFree(&tree[7].data.v.r);
    ProSelectionFree(&tree[10].data.v.r);
    ProSelectionFree(&feat_def.params[2].r);
    return (err);
}

/*=============================================================*\
  Function: 	ProUserCreateHole
  Purpose:	create gear hole
\*=============================================================*/
int ProUserCreateHole(GearParam *g_ptr)
{
    static ElemTreeData tree[]={
/* 0*/ 	{0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}},
/* 1*/	{1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_HOLE}},
/* 2*/	{1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}},
/* 3*/	{1, PRO_E_HLE_COM, {(ProValueDataType)-1}},
/* 4*/ 	{2, PRO_E_HLE_TYPE_NEW, {PRO_VALUE_TYPE_INT, 16}},

/* 5*/ 	{2, PRO_E_DIAMETER, {PRO_VALUE_TYPE_DOUBLE, 4}},		

/* 6*/ 	{2, PRO_E_HOLE_STD_DEPTH, {(ProValueDataType)-1}},

/* 7*/ 	{3, PRO_E_HOLE_DEPTH_TO, {(ProValueDataType)-1}},
/* 8*/ 	{4, PRO_E_HOLE_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, 3}},

/* 9*/	{3, PRO_E_HOLE_DEPTH_FROM, {(ProValueDataType)-1}},
/* 10*/	{4, PRO_E_HOLE_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, 3}},

/* 11*/	{1, PRO_E_HLE_PLACEMENT, {(ProValueDataType)-1}},
/* 12*/	{2, PRO_E_HLE_PRIM_REF, {PRO_VALUE_TYPE_SELECTION}},		
/* 13*/	{2, PRO_E_HLE_PL_TYPE, {PRO_VALUE_TYPE_INT, 5}},
/* 14*/	{2, PRO_E_HLE_PLCMNT_PLANE, {PRO_VALUE_TYPE_SELECTION}},	
	};


	ProError err;
    int axis_id;
    ProFeature feature, f;
    ProErrorlist errs;
    Pro3dPnt pnt;
    ProModelitem modelitem;
    ProElement elem_tree;
    ProSelection featsel;
    static FeatByName feat_disk[] = {
	{"GEAR_DISK"}
    };

    if (g_ptr->inner_diam == 0.0)
	 return 1;
/*-----------------------------------------------------------------*\
    Preparation of feature data
\*-----------------------------------------------------------------*/
    err = ProUtilFeatsByName(g_ptr->model, feat_disk, 1);
    if (err != PRO_TK_NO_ERROR || feat_disk[0].id == -1)
	return (err);

    ProFeatureInit(g_ptr->model, feat_disk[0].id, &feature);
    err = ProUtilFeatFirstGeomitem(&feature, PRO_AXIS, &axis_id);    
    if (err != PRO_TK_NO_ERROR)
	return (err);

    err=ProModelitemInit(g_ptr->model, axis_id, PRO_AXIS, &modelitem);
    if (err!=PRO_TK_NO_ERROR) 
	return (err);

    ProSelectionAlloc(NULL, &modelitem, &tree[12].data.v.r);
 
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, 
	&tree[14].data.v.r);
    tree[5].data.v.d = g_ptr->inner_diam;

/*-----------------------------------------------------------------*\
    Create new feature
\*-----------------------------------------------------------------*/
    err = ProUtilElemtreeCreate(tree, SIZEOFARR(tree), NULL, &elem_tree);
    err = ProMdlToModelitem(g_ptr->model, &modelitem);
    err = ProSelectionAlloc(NULL, &modelitem, &featsel);
    err = ProFeatureCreate(featsel, elem_tree, NULL, 0, &f, &errs);
    ProSelectionFree(&featsel);
    if (err != PRO_TK_NO_ERROR)
    {
	ProUtilFeatErrsWrite("ProFeatureCreate", err, elem_tree, &errs);
	return (-1);
    }
    else
    {

/*-----------------------------------------------------------------*\
    Set feature name
\*-----------------------------------------------------------------*/
        err = ProUtilModelitemNameSet((ProModelitem*)&f, "GEAR_HOLE");
        if (err != PRO_TK_NO_ERROR)
            return (-1);

	g_ptr->hole_created = 1;

/*-----------------------------------------------------------------*\
    Find and name required surfaces
\*-----------------------------------------------------------------*/
	pnt[0] = g_ptr->datum_x_offset;
	pnt[1] = g_ptr->datum_y_offset + g_ptr->inner_diam/2;  /* point on surface */
	if (g_ptr->gear_type == SPUR_GEAR)
	    pnt[2] = g_ptr->datum_z_offset + g_ptr->gear_depth/2;
	else
	    pnt[2] = g_ptr->datum_z_offset - g_ptr->backplate_depth/2;
	ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem);
	g_ptr->hole_side_surf_id = modelitem.id;
	ProUtilModelitemNameSet(&modelitem, "HOLE_SIDE");
    }
/*-----------------------------------------------------------------*\
    Free allocated memory
\*-----------------------------------------------------------------*/
    ProSelectionFree(&tree[12].data.v.r);
    ProSelectionFree(&tree[14].data.v.r);

    return (err);
}


/*=============================================================*\
  Function: 	ProUserCreateToothSurf
  Purpose:	create all gear tooth surface locator hole (ring gear)
\*=============================================================*/
int ProUserCreateToothSurf(GearParam *g_ptr)
{
    static ElemTreeData tree[]={
	{0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}},
	{1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_CUT}},
	{1, PRO_E_FEATURE_FORM, {PRO_VALUE_TYPE_INT, PRO_EXTRUDE}},
	{1, PRO_E_EXT_SURF_CUT_SOLID_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_FEAT_TYPE_SOLID}},
	{1, PRO_E_REMOVE_MATERIAL, {PRO_VALUE_TYPE_INT, PRO_EXT_MATERIAL_REMOVE}},
	{1, PRO_E_STD_SECTION,  {(ProValueDataType)-1}},
	{2, PRO_E_STD_SEC_SETUP_PLANE,  {(ProValueDataType)-1}},
	{3, PRO_E_STD_SEC_PLANE, {PRO_VALUE_TYPE_SELECTION}},
	{3, PRO_E_STD_SEC_PLANE_VIEW_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_VIEW_DIR_SIDE_TWO}},
	{3, PRO_E_STD_SEC_PLANE_ORIENT_DIR, {PRO_VALUE_TYPE_INT, PRO_SEC_ORIENT_DIR_LEFT}},
	{3, PRO_E_STD_SEC_PLANE_ORIENT_REF, {PRO_VALUE_TYPE_SELECTION}},
	{1, PRO_E_FEAT_FORM_IS_THIN, {PRO_VALUE_TYPE_INT, PRO_EXT_FEAT_FORM_NO_THIN}},
	{1, PRO_E_STD_DIRECTION, {PRO_VALUE_TYPE_INT, PRO_EXT_CR_IN_SIDE_ONE}},
	{1, PRO_E_STD_MATRLSIDE, {PRO_VALUE_TYPE_INT, PRO_EXT_MATERIAL_SIDE_TWO}},
	{1, PRO_E_STD_EXT_DEPTH, {(ProValueDataType)-1}},
	{2, PRO_E_EXT_DEPTH_FROM, {(ProValueDataType)-1}},
	{3, PRO_E_EXT_DEPTH_FROM_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_FROM_NONE}},
	{2, PRO_E_EXT_DEPTH_TO, {(ProValueDataType)-1}},
	{3, PRO_E_EXT_DEPTH_TO_TYPE, {PRO_VALUE_TYPE_INT, PRO_EXT_DEPTH_TO_NEXT}}
    };
    ProError err;
    FeatureDef feat_def;
    ProFeature feature;
    Pro3dPnt pnt;
    ProModelitem modelitem;
    double diam;
    

/*-----------------------------------------------------------------*\
    Preparation of feature data
\*-----------------------------------------------------------------*/
    memset(&feat_def, 0, sizeof(feat_def));
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, 
	&tree[7].data.v.r);
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, 
	&tree[10].data.v.r);

    feat_def.tree = tree;
    feat_def.sizeof_tree = SIZEOFARR(tree);

    diam = (g_ptr->n_of_teeth - 2) * g_ptr->tooth_par1;
    feat_def.params[0].d = diam;
    feat_def.params[1].r = tree[10].data.v.r;