utilintfdata.c

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

/*================================================================*\
    FILE:	UtilIntfData.c
    PURPOSE:	Printf content of IntfData to file

    HISTORY:
17-Nov-98   I-01-27   Pavel   $$1  Created 
17-Dec-98   I-01-27   Alexey  $$2  ProUtilDoubleArrayPrint: Get rid of 
					"negative" zero values in output
01-Jun-99   I-03-12   mka     $$3  More includes                                        
29-Jan-03   J-03-41   ALS     $$4  fix for the bug1000034. 
14-Oct-03   K-01-17   JCN     $$5  Fix for 1033544
\*================================================================*/

/*----------------------------------------------------------*\
    Headers
\*----------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProObjects.h>
#include <ProEdgedata.h>
#include <ProFeatType.h>
#include <ProFeature.h>
#include <ProIntfData.h>
#include <ProImportfeat.h>
#include <ProQuiltdata.h>
#include <ProSolid.h>
#include <ProSurfacedata.h>
#include <ProMenu.h>
#include <ProMessage.h>
#include <ProUtil.h>

#include <UtilMath.h>
#include <TestError.h>
/*----------------------------------------------------------*\
    Macros
\*----------------------------------------------------------*/
#define VECTOR(a) a[0], a[1], a[2]

/*=========================================================================*\
    Function:	ProUtilDoubleArrayPrint()
    Purpose:	Prints double array to file
\*=========================================================================*/

void ProUtilDoubleArrayPrint(
    FILE    *file,          /* In : file */
    char    *str,           /* In : the line prefix */
    double  *p_double,      /* In : the double array */
    int	    n_double)       /* In : the number of values in the array */
{
    int i;
    ProCharLine buf, line;

    strcpy(line, str);
    for (i=0; i<n_double; i++)
    {
	/* This trick in sprintf is necessary because on some platforms
	   close-to-zero values could be printfed out as -0.000 */
	sprintf(buf, "%.5f", fabs(p_double[i])<EPSM6 ? 0.0 : p_double[i]);
	if (i <  n_double -1)
	    strcat(buf, ",");
	strcat(line, buf);
	if (strlen(line) > 70 || (i == n_double -1))
	{
	    fprintf(file, "%s\n", line);
	    strcpy(line, str);
	}
	else
	{
	    strcat(line, " ");
	}
    }
}

/*=========================================================================*\
    Function:	ProUtilCurvedataPrint()
    Purpose:	Prints curve data to file
\*=========================================================================*/
ProError ProUtilCurvedataPrint(
    FILE *file,
    char *str,
    ProCurvedata *p_curve_data)
{
    ProError err;
    ProEnttype c_type;
    ProCharLine next_line, next_line2;
    int                     i, n_point, n_knots, degree, n_comp;
    double                  *p_par_arr, *p_weight_arr, st_a, en_a, rad;
    double                  d1, d2; 
    Pro3dPnt                p1, p2;
    ProVector               v1, v2;
    ProPoint3d              *p_pnt_arr, *p_tan_arr;
    ProComponentCurvedata   *p_comp_arr;
    ProCurvedata	    curve_data;
    ProCurveDir		    dir;

    strcpy(next_line, str);
    strcat(next_line, "    ");
    strcpy(next_line2, next_line);
    strcat(next_line2, "    ");

    err = ProCurvedataTypeGet(p_curve_data, &c_type);
    TEST_CALL_REPORT("ProCurvedataTypeGet()",
			"ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
    switch(c_type)
    {
    case PRO_ENT_POINT:
	err = ProPointdataGet(p_curve_data, p1);
    	TEST_CALL_REPORT("ProPointdataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file, "%sType Point\n", str);
	fprintf(file, "%spos ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(p1));
	break;
    case PRO_ENT_LINE:
	err = ProLinedataGet(p_curve_data, p1, p2);
    	TEST_CALL_REPORT("ProLinedataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file,"%sType Line \n", str);
	fprintf(file,"%send1 ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(p1));
	fprintf(file,"%send2 ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(p2));
	break;
    case PRO_ENT_ARC:
	err = ProArcdataGet(p_curve_data, v1, v2, p1, &st_a, &en_a, &rad);
    	TEST_CALL_REPORT("ProArcdataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file,"%sType Arc\n", str);
	fprintf(file,"%svec1 ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(v1));
	fprintf(file,"%svec2 ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(v2));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(p1));
	fprintf(file,"%sstart_angle %.5f\n", next_line, st_a);
	fprintf(file,"%send_angle %.5f\n", next_line, en_a);
	fprintf(file,"%sradius %.5f\n", next_line, rad);
	break;
    case PRO_ENT_SPLINE:
	err = ProSplinedataGet(p_curve_data, &p_par_arr, &p_pnt_arr,
	    &p_tan_arr, &n_point);
    	TEST_CALL_REPORT("ProSplinedataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file,"%sType Spline\n", str);
 	fprintf(file,"%sParameters\n", str);
	ProUtilDoubleArrayPrint(file, next_line, p_par_arr, n_point);
 	fprintf(file,"%sPoints\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_pnt_arr,
	    n_point * 3);
 	fprintf(file,"%sTangent Vectors\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_tan_arr,
	    n_point * 3);
	break;
    case PRO_ENT_B_SPLINE:
	err = ProBsplinedataGet(p_curve_data, &degree, &p_par_arr,
	    &p_weight_arr, &p_pnt_arr, &n_knots, &n_point);
    	TEST_CALL_REPORT("ProBsplinedataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file,"%sType B_spline\n", str);
	fprintf(file,"%sDegree %d\n", str, degree);
 	fprintf(file,"%sParameters\n", str);
	ProUtilDoubleArrayPrint(file, next_line, p_par_arr, n_knots);
	if (p_weight_arr != NULL)
	{
 	    fprintf(file,"%sWeights\n", str);
	    ProUtilDoubleArrayPrint(file, next_line, p_weight_arr, n_point);
	}
 	fprintf(file,"%sPoints\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_pnt_arr,
            n_point * 3);
	break;
    case PRO_ENT_CMP_CRV:
	err = ProCompositeCurvedataGet(p_curve_data, &p_comp_arr);
    	TEST_CALL_REPORT("ProCompositeCurvedataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	err = ProArraySizeGet((ProArray)p_comp_arr, &n_comp);    
	if (err != PRO_TK_NO_ERROR)
	    break;
	fprintf(file,"%sType Composite\n", str);
	fprintf(file,"%sComponents [%d]\n", str, n_comp);
	for (i=0; i<n_comp; i++)
	{
	    err = ProComponentCurvedataGet(p_comp_arr+i, &curve_data, &dir);
	    TEST_CALL_REPORT("ProComponentCurvedataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	    fprintf(file,"%sComponent %d\n", next_line, i);
	    fprintf(file,"%sDirection %d\n", next_line, dir);
	    ProUtilCurvedataPrint(file, next_line, &curve_data);
	}
	break;
    case PRO_ENT_ELLIPSE:
        err = ProEllipsedataGet (p_curve_data, p1, v1, v2, &d1, &d2, &st_a,
	    &en_a);
        TEST_CALL_REPORT("ProEllipsedataGet()", 
	           "ProUtilCurvedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file,"%sType Ellipse\n", str);
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(p1));
	fprintf(file,"%sx axis ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(v1));
	fprintf(file,"%sy axis ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(v2));
	fprintf(file,"%sx axis length %.5f\n", next_line, d1);
	fprintf(file,"%sy axis length %.5f\n", next_line, d2);
	fprintf(file,"%sstart_angle %.5f\n", next_line, st_a);
	fprintf(file,"%send_angle %.5f\n", next_line, en_a);
        break;
    default:
	fprintf(file,"%sType Unsupported (%d)\n", str, c_type);
 	break;
    }
    return (err);
}

/*=========================================================================*\
    Function:	ProUtilSurfacedataPrint()
    Purpose:	Prints surface data to file
\*=========================================================================*/
ProError ProUtilSurfacedataPrint(
    FILE *file,
    char *str,
    ProSurfacedata *p_surface_data)
{
    ProCharLine next_line, next_line2;
    ProError err;
    ProSrftype srftype;
    ProUvParam uv_min, uv_max;
    ProSurfaceOrient s_orient; 
    ProSurfaceshapedata s_shapedata;
    int i, j, s_id, num_u, num_v, num_point, n_conts, n_edges, deg[2];
    int  *p_edge_arr;
    double rad1, rad2, alpha, *p_u_arr, *p_v_arr, *p_wg_arr;
    ProContourdata *p_cont_arr;
    ProContourTraversal trav;
    ProVector e1, e2, e3, *p_u_t_arr, *p_v_t_arr, *p_uvd_arr;
    Pro3dPnt origin, *p_arr;
    ProCurvedata cur1, cur2;
    ProSplinedata pnt_spline, ctr_spline, tan_spline;
    ProSplinesrfdata  splsrf;
        
    strcpy(next_line, str);
    strcat(next_line, "    ");
    strcpy(next_line2, next_line);
    strcat(next_line2, "    ");
    err = ProSurfacedataGet(p_surface_data, &srftype, uv_min, uv_max,
	&s_orient, &s_shapedata, &s_id);
    TEST_CALL_REPORT("ProSurfacedataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
    fprintf(file,"%sId  %d\n", str, s_id);
    fprintf(file,"%sUv min ( %.5f, %.5f)\n", str, uv_min[0], uv_min[1]);
    fprintf(file,"%sUv max ( %.5f, %.5f)\n", str, uv_max[0], uv_max[1]);
    fprintf(file,"%sOrient %d\n", str, s_orient);

    err = ProSurfacedataContourArrayGet( p_surface_data, &p_cont_arr);
    TEST_CALL_REPORT("ProSurfacedataContourArrayGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
    err = ProArraySizeGet((ProArray)p_cont_arr, &n_conts);
    fprintf(file,"%sContours [%d]\n", str, n_conts);
    for (i=0; i<n_conts; i++)
    {
        err = ProContourdataGet(p_cont_arr+i, &trav);
    	TEST_CALL_REPORT("ProContourdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);

	err = ProContourdataEdgeIdArrayGet(p_cont_arr+i, &p_edge_arr);
    	TEST_CALL_REPORT("ProContourdataEdgeIdArrayGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);

	fprintf(file,"%sContour %d\n", str, i+1);
	fprintf(file,"%sTraversal %s\n", next_line, 
            trav == PRO_CONTOUR_TRAV_NONE ? "none" :
	    trav == PRO_CONTOUR_TRAV_INTERNAL ? "internal" : "external" );
	
	err = ProArraySizeGet((ProArray)p_edge_arr, &n_edges);
	fprintf(file,"%sEdge Id Array [%d]\n", next_line,  n_edges); 
	fprintf(file,"%s", next_line2); 
	for (j=0; j<n_edges; j++)
	{
	    fprintf(file,"%d", p_edge_arr[j]);
	    if (j < n_edges-1)
		fprintf(file, ",");
	}
	fprintf(file, "\n");
    }

    switch (srftype)
    {
    case  PRO_SRF_PLANE:
        err = ProPlanedataGet( &s_shapedata, e1, e2, e3, origin);
        TEST_CALL_REPORT("ProPlanedataGet()",
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file,"%sType Plane\n", str);
	fprintf(file,"%se1 ( %.5f, %.5f, %.5f)\n", str, VECTOR(e1));
	fprintf(file,"%se2 ( %.5f, %.5f, %.5f)\n", str, VECTOR(e2));
	fprintf(file,"%se3 ( %.5f, %.5f, %.5f)\n", str, VECTOR(e3));