geardesignutils.c

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

  Return :      PRO_TK_NO_ERROR if succsessfull, an error otherwise
\*=============================================================*/
ProError ProUtilCreateSketchedFeature(
    GearParam *g_ptr,	    /* In : */    
    FeatureDef *feat_def,   /* In : Feature definition */
    ProFeature *feature)    /* Out: created feature */
{
    static ElemTreeData sketch[]={
	{1, PRO_E_SKETCHER, {PRO_VALUE_TYPE_POINTER}}
    };

    static ProElempathItem path_items[] = {
	{PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_STD_SECTION},
	{PRO_ELEM_PATH_ITEM_TYPE_ID, PRO_E_SKETCHER}
    };
    
    ProElement elem_tree, elem_sec;
    ProElement created_elemtree, sketch_element;

    ProError err;
    ProModelitem model_item;
    ProSelection model_sel;
    
    ProFeatureCreateOptions opts[1];
    ProErrorlist errs;
    ProElempath path;
    ProValue value;
    ProValueData value_data;
    ProSection section;
    int brk = 0;

    do /* Used for exit from middle of block */
    {
/*----------------------------------------------------------*\
    Create Element Tree
\*----------------------------------------------------------*/
	err = ProUtilElemtreeCreate(feat_def->tree, feat_def->sizeof_tree, NULL, 
				    &elem_tree);
	if (err != PRO_TK_NO_ERROR)
	    break;

/*----------------------------------------------------------*\
    Create the incomplete protrusion in the current model
\*----------------------------------------------------------*/
	err = ProMdlToModelitem(g_ptr->model, &model_item);
	err = ProSelectionAlloc(NULL, &model_item, &model_sel);
	opts[0] = PRO_FEAT_CR_INCOMPLETE_FEAT;
	err = ProFeatureCreate(model_sel, elem_tree, opts, 1, feature, &errs);
	if (err != PRO_TK_NO_ERROR)
	{
	    ProUtilFeatErrsWrite("ProFeatureCreate", err, elem_tree, &errs);
	    break;
	}
	err = ProSelectionFree(&model_sel);

/*----------------------------------------------------------*\
    Get the initialized section element from the database
\*----------------------------------------------------------*/
	err = ProElempathAlloc(&path);
	err = ProElempathDataSet(path, path_items, 2);

	err = ProFeatureElemtreeCreate (feature, &created_elemtree);
	err = ProElemtreeElementGet (created_elemtree, path, &sketch_element);
	err = ProElementValueGet (sketch_element, &value);

	err = ProValueDataGet(value, &value_data);
	section =  (ProSection)value_data.v.p;
	err = ProElempathFree(&path);
/*----------------------------------------------------------*\
    Create a section
\*----------------------------------------------------------*/
	err = feat_def->section_create_func(section, feat_def->params);
	if (err != PRO_TK_NO_ERROR)
	    break;

/*------------------------------------------------------------*\
    Set section-dependent element values
\*------------------------------------------------------------*/

	ProUtilFeatureSetSectionDependentValues (created_elemtree,
						 feat_def->tree,
						 feat_def->sizeof_tree);

	opts[0] = PRO_FEAT_CR_INCOMPLETE_FEAT;
	err = ProFeatureRedefine(NULL, feature, created_elemtree, opts, 1, &errs);
	if (err != PRO_TK_NO_ERROR)
	{
	    ProUtilFeatErrsWrite("ProFeatureRedefine", err, elem_tree, &errs);
	    break;
	}
	err = ProElementFree(&elem_tree);

/*----------------------------------------------------------*\
    Set feature name
\*----------------------------------------------------------*/
	ProUtilModelitemNameSet(feature, feat_def->feat_name);
    } while (brk);

    return (err);
}

/*=============================================================*\
  Function: 	ProUtilFeatureSetSectionDependentValues
  Purpose:	Assign necessary elements (direction, material side) from 
                original value table (special for Extrude, Revolve element 
	        tree, these elements must be set along with or after 
		PRO_E_SEKTCHER)
\*=============================================================*/
ProError ProUtilFeatureSetSectionDependentValues (ProElement elemtree,
						  ElemTreeData* elemarr,
						  int n_elem)
{
  ElemTreeData* needed_elems = NULL;
  int i_elem, i_value;
  int size;
  
  ProElempath elem_path;
  ProElempathItem path_item;
  ProElement element;
  ProValue value;


  for (i_elem = 0; i_elem < n_elem; i_elem ++)
    {
      switch (elemarr [i_elem].elem_id)
	{
	case PRO_E_EXT_SURF_CUT_SOLID_TYPE:
	  {
	    ProArrayAlloc (0, sizeof (ElemTreeData), 1, (ProArray*)&needed_elems);
	    break;
	  }
	case PRO_E_STD_DIRECTION:
	case PRO_E_STD_MATRLSIDE:
	  {
	    if (needed_elems != NULL)
	      {
		ProArrayObjectAdd ((ProArray*)&needed_elems, -1, 1, &elemarr[i_elem]);
	      }
	    break;
	  }
	default:
	  break;
	}
    }
  if (needed_elems == NULL)
    return PRO_TK_NO_ERROR;

  status = ProArraySizeGet (needed_elems, &size);
  if (status != PRO_TK_NO_ERROR)
    return PRO_TK_NO_ERROR;
  if (size == 0)
    {
      ProArrayFree ((ProArray*)&needed_elems);
      return PRO_TK_NO_ERROR;
    }


  for (i_value = 0; i_value < size; i_value ++)
    {
      switch (needed_elems [i_value].elem_id)
	{
	  case PRO_E_STD_DIRECTION:
	  case PRO_E_STD_MATRLSIDE:
	    {
              ProElempathAlloc (&elem_path);
	      path_item.type = PRO_ELEM_PATH_ITEM_TYPE_ID;
	      path_item.path_item.elem_id = needed_elems [i_value].elem_id;
	    
	      ProElempathDataSet (elem_path, &path_item, 1);

	      ProElemtreeElementGet (elemtree, elem_path, &element);
	      
	      /*----------------------------------------------------------*\
		Add Element value
	      \*----------------------------------------------------------*/
              ProValueAlloc(&value);
            
              ProValueDataSet(value, &needed_elems[i_value].data);
            
              ProElementValueSet(element, value);
              ProElempathFree (&elem_path);
	       
	      break;
	    }
	}
    }

  ProArrayFree ((ProArray*) &needed_elems);

  return PRO_TK_NO_ERROR;
}

/*=============================================================*\
  Function: 	ProUtilModelitemNameSet
  Purpose:	Set new name for the model item
  Return :      as ProModelitemNameSet
\*=============================================================*/
ProError ProUtilModelitemNameSet(ProModelitem *modelitem, char *name)
{
    ProName w_name;
    ProError status;

    ProStringToWstring(w_name, name);
    status = ProModelitemNameSet(modelitem, w_name);
    return (status);
}

/*=============================================================*\
  Function: 	ProUtilFeatByNameVisit
  Purpose:	visiting fucntion for ProSolidFeatVisit
  Return :      1 if feature with required name found, 0 otherwise
\*=============================================================*/
static ProError ProUtilModelitemByNameVisit(
    ProModelitem *modelitem, 
    ProError status, 
    ProAppData app_data)
{
    FeatByNameFind *feat_by_name = (FeatByNameFind *)app_data;
    ProName   name;	
    int i;
    ProBoolean vis;

    if (modelitem->type == PRO_FEATURE)
    {
	status = ProFeatureVisibilityGet((ProFeature*)modelitem, &vis);
	if (status!=PRO_TK_NO_ERROR || vis == PRO_B_FALSE)
	    return (PRO_TK_NO_ERROR);
    }
    
    status = ProModelitemNameGet(modelitem, name);
    if (status != PRO_TK_NO_ERROR)
	return (PRO_TK_NO_ERROR);

    for (i=0; i<feat_by_name->num_feats; i++)
    {
	if (ProUtilStrwscmp(feat_by_name->feats[i].name, name)==0)
	    feat_by_name->feats[i].id = modelitem->id;
    }
    return (PRO_TK_NO_ERROR);
}


/*=============================================================*\
  Function: 	ProUtilFeatsByName
  Purpose:	to find solid features by name
  Return :      PRO_TK_NO_ERROR if successfull,
\*=============================================================*/
ProError ProUtilFeatsByName(
    ProSolid model,
    FeatByName *feats,
    int num_feats)
{
    FeatByNameFind feat_by_name;
    ProError   status;
    int i;

    feat_by_name.feats = feats;
    feat_by_name.num_feats = num_feats;
    for (i=0; i<num_feats; i++)
	feats[i].id = -1;
    
    status = ProSolidFeatVisit((ProSolid)model, 
	(ProFeatureVisitAction)ProUtilModelitemByNameVisit, NULL, 
	(ProAppData)&feat_by_name);
    return (status);
}

/*=============================================================*\
  Function: 	ProUtilSelectionFromSurfaceId
  Purpose:	transformation from surface id to ProSelection
  Return :      PRO_TK_NO_ERROR if successfull,
\*=============================================================*/
ProError ProUtilSelectionFromSurfaceId(
    ProMdl model,	/* In : model */
    int surf_id,	/* In : surface id */
    ProSelection *sel)	/* Out: selection, to free use ProSelectionFree() */
{
    ProError err;
    ProSurface surf;
    ProModelitem modelitem;
    
    err=ProSurfaceInit(model, surf_id, &surf);
    if (err!=PRO_TK_NO_ERROR) 
	return (err);
    err = ProSurfaceToGeomitem((ProSolid)model, surf, (ProGeomitem*)&modelitem);
    ProSelectionAlloc(NULL, &modelitem, sel);
    return (PRO_TK_NO_ERROR);
}

/*=============================================================*\
  Function: 	ProUtilGeometryAtPointFind
  Purpose:	to find surface at point
  Return :      PRO_TK_NO_ERROR if successfull,
		PRO_TK_E_NOT_FOUND otherwise
\*=============================================================*/
ProError ProUtilGeometryAtPointFind(
    ProPart part, 
    Pro3dPnt point, 
    ProModelitem *modelitem)
{
    int n_sel, i;
    ProSelection *p_sel;
    ProType type;
    ProError err;

    err = ProGeometryAtPointFind(part, point, &p_sel, &n_sel);
    
    if (err != PRO_TK_NO_ERROR)
	return (PRO_TK_E_NOT_FOUND);

    err = ProSelectionModelitemGet(p_sel[0], modelitem);
    
    /* Free memory allocated by ProGeometryAtPointFind */
    for (i = 0; i < n_sel; i++)
        ProSelectionFree( &p_sel[i]);

    ProArrayFree((ProArray *) &p_sel);
    return (PRO_TK_NO_ERROR);
}



/*=============================================================*\
  Function: 	ProUtilFeatFirstGeomitemVisit
  Purpose:	Visit function for the ProFeatureGeomitemVisit
  Return :      1 (only first geom item visited)
\*=============================================================*/
ProError ProUtilFeatFirstGeomitemVisit(
    ProGeomitem *geom_item,
    ProError status,
    ProAppData app_data)
{
    ProGeomitem *surf =  (ProGeomitem*)app_data;
    surf[0] = geom_item[0];
    return ((ProError)1);
}

/*=============================================================*\
  Function: 	ProUtilFeatFirstGeomitem
  Purpose:	Found first GeomItem for the feature
  Return :      PRO_TK_NO_ERROR if successful
\*=============================================================*/
ProError ProUtilFeatFirstGeomitem(
    ProFeature *feature,	    /* In: the feature */ 
    ProType type,		    /* In: Geomitem type */
    int  *item_id)		    /*Out: Geomitem id, user's memory */
{
    ProModelitem model_item;
    ProError status;

    status = ProFeatureGeomitemVisit(feature, type, 
	ProUtilFeatFirstGeomitemVisit, NULL, (ProAppData)&model_item);

    if (status==1)
    {
	item_id[0] = model_item.id;
	return (PRO_TK_NO_ERROR);
    }
    return (PRO_TK_E_NOT_FOUND);
}

/*=============================================================*\
  Function: 	ProUtilFeatFirstDimensionVisit
  Purpose:	Visit function for the ProFeatureDimensionVisit
  Return :      1 (only first dim visited)
\*=============================================================*/
ProError ProUtilFeatFirstDimensionVisit(
    ProDimension *dim,
    ProError status,
    ProAppData app_data)
{
    ProDimension *found =  (ProDimension*)app_data;
    found[0] = dim[0];
    return ((ProError)1);
}

/*=============================================================*\
  Function: 	ProUtilFeatFirstDimension
  Purpose:	Found first GeomItem for the feature
  Return :      PRO_TK_NO_ERROR if successful
\*=============================================================*/
ProError ProUtilFeatFirstDimension(
    ProFeature *feature,	    /* In: the feature */ 
    int  *item_id)		    /*Out: Dimension id, user's memory */
{
    ProModelitem model_item;
    ProError status;

    status = ProFeatureDimensionVisit(feature, 
	ProUtilFeatFirstDimensionVisit, NULL, (ProAppData)&model_item);

    if (status==1)
    {
	item_id[0] = model_item.id;
	return (PRO_TK_NO_ERROR);
    }
    return (PRO_TK_E_NOT_FOUND);
}

/*=============================================================*\
  Function: 	ProUtilFindTwoCircleIntersection
  Purpose:	Calculate intersection of two circles
  Return :      PRO_TK_NO_ERROR if successfull
		PRO_TK_GENERAL_ERROR - no intersection
\*=============================================================*/
ProError ProUtilTwoCircleIntersection(
    Pro2dCircledef *c1, 
    Pro2dCircledef *c2, 
    Pro2dPnt	    p1,
    Pro2dPnt	    p2)
{
    double d, x1, y1, sa, ca;

    d = sqrt(sqr(c1->center[0]-c2->center[0]) + 
             sqr(c1->center[1]-c2->center[1]));
    if ((d<EPSM6) || (d>c1->radius + c2->radius) || 
	(d + c1->radius < c2->radius) || (d + c2->radius < c1->radius))
	return (PRO_TK_GENERAL_ERROR);

    y1 = (sqr(c1->radius) + sqr(d) - sqr(c2->radius)) / 2 /d;
    x1 = sqrt(sqr(c1->radius) - sqr(y1));

    sa = (c2->center[0]-c1->center[0]) / d;
    ca = (c2->center[1]-c1->center[1]) / d;

    p1[0] = y1 * sa + x1 * ca + c1->center[0];
    p1[1] = y1 * ca - x1 * sa + c1->center[1];
    p2[0] = y1 * sa - x1 * ca + c1->center[0];
    p2[1] = y1 * ca + x1 * sa + c1->center[1];
    
    return (PRO_TK_NO_ERROR);
}


/*=============================================================*\
  Function: 	ProUtilFeatErrsWrite
  Purpose:	Debug function. Print elem tree and errors af feature 
                creation or redefenition failed
*=============================================================*/
void ProUtilFeatErrsWrite(
    char *function,
    ProError err,
    ProElement tree,
    ProErrorlist *err_list)
{
    fprintf(stderr, "Function %s returned %d\n", function, err);
    ProUtilElementtreePrint(tree, (UtilTreeprintWindow)2, 0);
    ProUtilFeatErrsPrint(err_list);
}