geardesign.c

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

    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->bottom_surface_id, 
	&feat_def.params[2].r);
    feat_def.section_create_func = ProUtilCreateCircleSection;

    feat_def.feat_name  = "Tooth_Surf";

    

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

/*-----------------------------------------------------------------*\
    Find and name required surfaces
\*-----------------------------------------------------------------*/
	pnt[0] = g_ptr -> datum_x_offset;
	pnt[1] = g_ptr -> datum_y_offset + diam/2;  /* point on surface */
	pnt[2] = g_ptr -> datum_z_offset + g_ptr->gear_depth/2;
	ProUtilGeometryAtPointFind((ProPart)g_ptr->model, pnt, &modelitem);
	g_ptr->tooth_surf_side_surf_id = modelitem.id;
	ProUtilModelitemNameSet(&modelitem, "TOOTH_SURF_SIDE");
    }
/*-----------------------------------------------------------------*\
    Free allocated memory
\*-----------------------------------------------------------------*/
    ProSelectionFree(&tree[7].data.v.r);
    ProSelectionFree(&tree[10].data.v.r);
    ProSelectionFree(&feat_def.params[2].r);
    return (0);
}

/*=============================================================*\
  Function: 	ProUserCreateTooth
  Purpose:	create first gear tooth
\*=============================================================*/
int ProUserCreateTooth(GearParam *g_ptr)
{
    static ElemTreeData dtm_tree[]={
	{0, PRO_E_FEATURE_TREE, {(ProValueDataType)-1}},
	{1, PRO_E_FEATURE_TYPE, {PRO_VALUE_TYPE_INT, PRO_FEAT_DATUM}},
	{1, PRO_E_DTMPLN_CONSTRAINTS, {(ProValueDataType)-1}},
	{2, PRO_E_DTMPLN_CONSTRAINT, {(ProValueDataType)-1}},
	{3, PRO_E_DTMPLN_CONSTR_TYPE, {PRO_VALUE_TYPE_INT, PRO_DTMPLN_THRU}},
	{3, PRO_E_DTMPLN_CONSTR_REF, {PRO_VALUE_TYPE_SELECTION}},
	{2, PRO_E_DTMPLN_CONSTRAINT, {(ProValueDataType)-1}},
	{3, PRO_E_DTMPLN_CONSTR_TYPE, {PRO_VALUE_TYPE_INT, PRO_DTMPLN_ANG}},
	{3, PRO_E_DTMPLN_CONSTR_REF, {PRO_VALUE_TYPE_SELECTION}},
	{3, PRO_E_DTMPLN_CONSTR_REF_ANGLE, {PRO_VALUE_TYPE_DOUBLE}},
    };

    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}}
    };

    static FeatByName feat_disk[] = {
	{"GEAR_DISK"}
    };

    ProError err;
    FeatureDef feat_def;
    ProFeature feature, feat_tooth;
    ProModelitem modelitem;
    int axis_id, surface_id, *feats_ids, ret, n_dims, *p_dim_ids;
    ProErrorlist errs;
    ProElement elem_tree;
    ProSelection featsel;
    ProLayer layer;
    ProLayerItem layer_item;
    ProGroup group;
    ProName w_name;
    PRODIMENSION dim;
    
    if (g_ptr->Pressure_angle == 0.0 || g_ptr->tooth_par1 == 0.0 
	|| g_ptr->n_of_teeth == 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, &dtm_tree[5].data.v.r);
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->side_surface_id, 
	&dtm_tree[8].data.v.r);

    memset(&feat_def, 0, sizeof(feat_def));
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->front_surface_id, 
	&tree[7].data.v.r);

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

    feat_def.params[0].d = g_ptr->tooth_par1;
    feat_def.params[1].i = g_ptr->n_of_teeth;
    feat_def.params[2].d = g_ptr->Pressure_angle;
    feat_def.params[3].d = g_ptr->tooth_par2;
    ProUtilSelectionFromSurfaceId(g_ptr->model, g_ptr->gear_type ?
	g_ptr->tooth_surf_side_surf_id : g_ptr->disk_side_surf_id, 
	&feat_def.params[4].r);
    feat_def.params[5].r = tree[10].data.v.r;

    feat_def.section_create_func = ProUtilCreateToothSection;

/*-----------------------------------------------------------------*\
    Create new feature
\*-----------------------------------------------------------------*/

/*-----------------------------------------------------------------*\
    Create Datum Plane first
\*-----------------------------------------------------------------*/
    dtm_tree[9].data.v.d = 0;
    err = ProUtilElemtreeCreate(dtm_tree, SIZEOFARR(dtm_tree), NULL, 
	 &elem_tree);

    err = ProMdlToModelitem(g_ptr->model, &modelitem);
    err = ProSelectionAlloc(NULL, &modelitem, &featsel);
    err = ProFeatureCreate(featsel, elem_tree, NULL, 0, &feature, &errs);
    if (err != PRO_TK_NO_ERROR)
    {
	ProUtilFeatErrsWrite("ProFeatureCreate", err, elem_tree, &errs);
        return (-1);
    }
    ProSelectionFree(&featsel);

/*-----------------------------------------------------------------*\
    Set datum plane name
\*-----------------------------------------------------------------*/
    err = ProUtilModelitemNameSet((ProModelitem*)&feature, "DTM_TOOTH_1");
    if (err != PRO_TK_NO_ERROR)
        return (-1);
           
/*-----------------------------------------------------------------------*\
    Make trik - rename last dimension, to use in pattern
\*-----------------------------------------------------------------------*/
    n_dims = prodim_get_dim_ids((Prohandle)g_ptr->model, PRO_DIM_PARAM,
        -1, &p_dim_ids);
    
    ret = prodim_get_dimension((Prohandle)g_ptr->model, p_dim_ids[n_dims-1],
        PRO_DIM_PARAM, &dim);
    
    ProStringToWstring(dim.symbol, "tooth_angle");
    ret = prodim_set_dim((Prohandle)g_ptr->model, p_dim_ids[n_dims-1],
        &dim);        

/*-----------------------------------------------------------------*\
    Create a hidden layer and add datim plane to the layer
\*-----------------------------------------------------------------*/
    ProStringToWstring(w_name, "BLANK");

    err = ProLayerCreate(g_ptr->model, w_name, &layer);
    err = ProLayerDisplaystatusSet(&layer, PRO_LAYER_TYPE_BLANK);
    err = ProLayerDisplaystatusSave(g_ptr->model);
	
    err = ProLayerItemInit(PRO_LAYER_FEAT, feature.id, g_ptr->model,
	&layer_item);

    err = ProLayerItemAdd(&layer, &layer_item);
    
    err = ProUtilFeatFirstGeomitem(&feature, PRO_SURFACE, &surface_id);
    if (err != PRO_TK_NO_ERROR)
	return (-1);

    ProUtilSelectionFromSurfaceId(g_ptr->model, surface_id, 
	&tree[10].data.v.r);

    feat_def.feat_name = "TOOTH_1";
    feat_def.params[3].d = 0;
    err  = ProUtilCreateSketchedFeature(g_ptr, &feat_def, &feat_tooth);
    if (err!=PRO_TK_NO_ERROR)
	    return (-1);
    ProSelectionFree(&tree[10].data.v.r);

/*-----------------------------------------------------------------------*\
	Create Local Group
\*-----------------------------------------------------------------------*/
    ProStringToWstring(w_name, "TOOTH");
    ProArrayAlloc(0, sizeof(int), 2, (ProArray*)&feats_ids);
    ProArrayObjectAdd((ProArray*)&feats_ids, -1, 1, &feature.id);
    ProArrayObjectAdd((ProArray*)&feats_ids, -1, 1, &feat_tooth.id);

    err = ProLocalGroupCreate(g_ptr->model, feats_ids, 2, w_name, &group);
    ProArrayFree((ProArray*)&feats_ids);

    if (err == PRO_TK_NO_ERROR)
    {
	g_ptr->tooth_created = 1;
    }
/*-----------------------------------------------------------------*\
    Free allocated memory
\*-----------------------------------------------------------------*/
    ProSelectionFree(&tree[7].data.v.r);
    ProSelectionFree(&dtm_tree[5].data.v.r);
    ProSelectionFree(&dtm_tree[8].data.v.r);
    ProSelectionFree(&feat_def.params[4].r);
    return (0);
}

/*=============================================================*\
  Function: 	ProUserCreateTeeth
  Purpose:	create gear teeth
\*=============================================================*/
int ProUserCreateTeeth(GearParam *g_ptr)
{
    static FeatByName tooth_datum[] = {
	{"DTM_TOOTH_1"},
    };
    static ElemTreeData tree[]={
	{0, PRO_E_PATTERN_ROOT, {(ProValueDataType)-1}},
	{1, PRO_E_PAT_TYPE, {PRO_VALUE_TYPE_INT, PRO_PAT_DIM_DRIVEN}},
	{1, PRO_E_PAT_FIRST_DIR, {(ProValueDataType)-1}},
	{2, PRO_E_PAT_DIR_DIM_COMPOUND,  {(ProValueDataType)-1}},
	{3, PRO_E_PAT_DIR_DIMENSION, {PRO_VALUE_TYPE_SELECTION}},
	{3, PRO_E_PAT_DIR_VAR_TYPE, {PRO_VALUE_TYPE_INT, PRO_PAT_VALUE_DRIVEN}},
	{3, PRO_E_PAT_DIR_VAR_VALUE, {PRO_VALUE_TYPE_DOUBLE}},
	{1, PRO_E_PAT_FIRST_DIR_NUM_INST,  {PRO_VALUE_TYPE_INT}}
    };    
    int n_dims, ret, *p_dim_ids, *p_feat_ids, *p_tooth_ids, i, n_feats;
    int n_tooth_feats;
    PRODIMENSION dim;
    ProFeature feature, feat_plane, feat_tooth;
    ProLayerItem layer_item;
    ProLayer layer;
    ProCharName str;
    ProName     w_str;
    ProElement elem_tree;
    ProModelitem modelitem;
    ProError err;
    
    if (!g_ptr->tooth_created)
      return (-1);

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

    ProFeatureInit(g_ptr->model, tooth_datum[0].id, &feature);
 
/*-----------------------------------------------------------------*\
    Find tooth_angle dimension for reference 
\*-----------------------------------------------------------------*/
    n_dims = prodim_get_dim_ids((Prohandle)g_ptr->model, PRO_DIM_PARAM,
        -1, &p_dim_ids);
   
    for (i=0; i<n_dims; i++)
    { 
        ret = prodim_get_dimension((Prohandle)g_ptr->model,
            p_dim_ids[i], PRO_DIM_PARAM, &dim);
        if (!ProUtilStrwscmp("tooth_angle", dim.symbol))
        {
            err = ProModelitemInit(g_ptr->model, p_dim_ids[i], 
                PRO_DIMENSION, &modelitem);
            err = ProSelectionAlloc(NULL, &modelitem, &tree[4].data.v.r);
            break;
        }
        if  (i == n_dims)
            return (-1);
    }
    
    tree[6].data.v.d = 360./g_ptr->n_of_teeth;
    tree[7].data.v.i = g_ptr->n_of_teeth;
 
    err = ProUtilElemtreeCreate(tree, SIZEOFARR(tree), NULL, &elem_tree);
    err = ProPatternCreate(&feature, PRO_GROUP_PATTERN, elem_tree);
    
    if (err == PRO_TK_NO_ERROR)
    {
        g_ptr->teeth_created = 1;
	ProWindowRepaint (-1);
    
        err = ProFeatureChildrenGet(&feature, &p_feat_ids, &n_feats);
        for (i=1; i<n_feats; i++ )
        {
            err = ProFeatureInit((ProSolid)g_ptr->model, p_feat_ids[i],
                &feat_plane);
            
            /* Rename datum plane and put it into hidden layen */
            sprintf(str, "DTM_TOOTH_%d", i+1);
            ProStringToWstring(w_str, str);
            err = ProModelitemNameSet((ProModelitem*)&feat_plane, w_str);
            
            ProStringToWstring(w_str, "BLANK");
            err = ProMdlLayerGet(g_ptr->model, w_str, &layer);
            
            err = ProLayerItemInit(PRO_LAYER_FEAT, feat_plane.id,
                g_ptr->model, &layer_item);

            err = ProLayerItemAdd(&layer, &layer_item);
            
            err = ProFeatureChildrenGet(&feat_plane, &p_tooth_ids,
                &n_tooth_feats);
            
            err = ProFeatureInit((ProSolid)g_ptr->model, p_tooth_ids[0],
                &feat_tooth);
            
            /* Rename datum plane and put it into hidden layen */
            sprintf(str, "TOOTH_%d", i+1);
            ProStringToWstring(w_str, str);
            err = ProModelitemNameSet((ProModelitem*)&feat_tooth, w_str);
            
            err = ProArrayFree((ProArray*)&p_tooth_ids);
        }
        err = ProArrayFree((ProArray*)&p_feat_ids);
    }
    err = ProSelectionFree(&tree[4].data.v.r);

    return(0);
}

/*=============================================================*\
  Function: 	ProUserCreateHub
  Purpose:	create inner support hub
\*=============================================================*/
int ProUserCreateHub(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}},