/*================================================================*\
    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                                        
\*================================================================*/

/*----------------------------------------------------------*\
    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 Line\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,"%svec1 ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(v1));
	fprintf(file,"%svec2 ( %.5f, %.5f, %.5f)\n", next_line, VECTOR(v2));
	fprintf(file,"%smajor_axis_len %.5f\n", next_line, d1);
	fprintf(file,"%sminor_axis_len %.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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
	break;
    case PRO_SRF_CYL:
        err = ProCylinderdataGet( &s_shapedata, e1, e2, e3, origin, &rad1);
        TEST_CALL_REPORT("ProCylinderdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
	fprintf(file,"%sType Cylinder\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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
	fprintf(file,"%sradius %.5f\n", str, rad1);
	break;
    case PRO_SRF_CONE:
        err = ProConedataGet( &s_shapedata, e1, e2, e3, origin, &alpha);
        TEST_CALL_REPORT("ProConedataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Cone\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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
	fprintf(file,"%salpha %.5f\n", str, alpha);
	break;
    case PRO_SRF_TORUS:
        err = ProTorusdataGet( &s_shapedata, e1, e2, e3, origin, &rad1, &rad2);
        TEST_CALL_REPORT("ProTorusdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Torus\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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
	fprintf(file,"%sradius1 %.5f\n", str, rad1);
	fprintf(file,"%sradius2 %.5f\n", str, rad2);
	break;
    case PRO_SRF_FIL:
        err = ProFilsrfdataGet( &s_shapedata, &pnt_spline, &ctr_spline,
	    &tan_spline);
        TEST_CALL_REPORT("ProFilsrfdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Fillet\n", str);
 	fprintf(file,"%sPnt Spline\n", str);
	ProUtilCurvedataPrint(file, next_line, (ProCurvedata*)&pnt_spline);
 	fprintf(file,"%sCtr Spline\n", str);
	ProUtilCurvedataPrint(file, next_line, (ProCurvedata*)&ctr_spline);
 	fprintf(file,"%sTan Spline\n", str);
	ProUtilCurvedataPrint(file, next_line, (ProCurvedata*)&tan_spline);
	break;
    case PRO_SRF_RUL:
        err = ProRulsrfdataGet( &s_shapedata, e1, e2, e3, origin, &cur1,
	    &cur2);
        TEST_CALL_REPORT("ProRulsrfdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Ruled\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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
 	fprintf(file,"%sCurve_1\n", str);
	ProUtilCurvedataPrint(file, next_line, &cur1);
 	fprintf(file,"%sCurve_2\n", str);
	ProUtilCurvedataPrint(file, next_line, &cur2);
    case PRO_SRF_REV:
        err = ProSrfrevdataGet( &s_shapedata, e1, e2, e3, origin, &cur1);
        TEST_CALL_REPORT("ProSrfrevdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Rev\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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
 	fprintf(file,"%sCurve\n", str);
	ProUtilCurvedataPrint(file, next_line, &cur1);
	break;
    case PRO_SRF_TABCYL:
        err = ProTabcyldataGet( &s_shapedata, e1, e2, e3, origin, &cur1);
        TEST_CALL_REPORT("ProTabcyldataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Tabcyl\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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
 	fprintf(file,"%sCurve\n", str);
	ProUtilCurvedataPrint(file, next_line, &cur1);
	break;
    case PRO_SRF_B_SPL:
        err = ProBsplinesrfdataGet( &s_shapedata, deg, &p_u_arr, &p_v_arr,
	    &p_wg_arr, &p_arr, &num_u, &num_v, &num_point);
        TEST_CALL_REPORT("ProBsplinesrfdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType B_spline\n", str);
 	fprintf(file,"%sdegree %d, %d\n", str, deg[0], deg[1]);
 	fprintf(file,"%sU Param Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, p_u_arr, num_u);
 	fprintf(file,"%sV Param Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, p_v_arr, num_v);
	if (p_wg_arr != NULL)
	{
 	    fprintf(file,"%sWeights Array\n", str);
	    ProUtilDoubleArrayPrint(file, next_line, p_wg_arr, num_point);
	}
 	fprintf(file,"%sPoint Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line,  (double*)p_arr,
	    num_point * 3);
	break;
    case PRO_SRF_CYL_SPL:
        err = ProCylsplsrfdataGet( &s_shapedata, e1, e2, e3, origin, &splsrf);
        TEST_CALL_REPORT("ProCylsplsrfdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Cyl Spl\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));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str, VECTOR(origin));
	fprintf(file,"%sSpline Srf\n", str);

        err = ProSplinesrfdataGet( (ProSurfaceshapedata*)&splsrf, &p_u_arr,
	    &p_v_arr, &p_arr, &p_u_t_arr, &p_v_t_arr, &p_uvd_arr, &num_u,
	    &num_v);
        TEST_CALL_REPORT("ProSplinesrfdataGet()", 
	    "ProUtilSurfaceshapedataCopy()", err, err != PRO_TK_NO_ERROR);

 	fprintf(file,"%sU Param Array\n", str);
	num_point = num_u * num_v;
	ProUtilDoubleArrayPrint(file, next_line, p_u_arr, num_u);
 	fprintf(file,"%sV Param Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, p_v_arr, num_v);
 	fprintf(file,"%sPoint Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_arr,
	    num_point * 3);
 	fprintf(file,"%sU Der Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_u_t_arr,
	    num_point * 3);
 	fprintf(file,"%sV Der Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_v_t_arr,
	    num_point * 3);
 	fprintf(file,"%sUV Der Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_uvd_arr,
	    num_point * 3);
	break;
    case PRO_SRF_SPL:
        err = ProSplinesrfdataGet( &s_shapedata, &p_u_arr, &p_v_arr, &p_arr,
	    &p_u_t_arr, &p_v_t_arr, &p_uvd_arr, &num_u, &num_v);
        TEST_CALL_REPORT("ProSplinesrfdataGet()", 
	           "ProUtilSurfacedataPrint()", err, err != PRO_TK_NO_ERROR);
 	fprintf(file,"%sType Spline\n", str);
 	fprintf(file,"%sU Param Array\n", str);
	num_point = num_u * num_v;
	ProUtilDoubleArrayPrint(file, next_line, p_u_arr, num_u);
 	fprintf(file,"%sV Param Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, p_v_arr, num_v);
 	fprintf(file,"%sPoint Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_arr,
	    num_point * 3);
 	fprintf(file,"%sU Der Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_u_t_arr,
	    num_point * 3);
 	fprintf(file,"%sV Der Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_v_t_arr,
	    num_point * 3);
 	fprintf(file,"%sUV Der Array\n", str);
	ProUtilDoubleArrayPrint(file, next_line, (double*)p_uvd_arr,
	    num_point * 3);
	break;
    case PRO_SRF_FOREIGN :
 	fprintf(file,"%sType Foreign\n", str);
	fprintf(file,"%se1 ( %.5f, %.5f, %.5f)\n", str,
	    VECTOR(s_shapedata.frgnsrf.e1));
	fprintf(file,"%se2 ( %.5f, %.5f, %.5f)\n", str,
	    VECTOR(s_shapedata.frgnsrf.e2));
	fprintf(file,"%se3 ( %.5f, %.5f, %.5f)\n", str,
	    VECTOR(s_shapedata.frgnsrf.e3));
	fprintf(file,"%sorigin ( %.5f, %.5f, %.5f)\n", str,
	    VECTOR(s_shapedata.frgnsrf.origin));
	fprintf(file,"%sForein Id %d\n", str, s_shapedata.frgnsrf.foreign_id);
	break;
    default:
 	fprintf(file,"%sType Unsupported (%d)\n", str, srftype);
	break;	
    }
    return (PRO_TK_NO_ERROR);
}

/*=========================================================================*\
    Function:	ProUtilIntfDataPrint()
    Purpose:	Prints intf data to file
\*=========================================================================*/
ProError ProUtilIntfDataPrint(
    FILE *file,
    ProIntfData *p_intf_data)
{
    ProAccuracytype accuracy_type;
    ProOutline outline;
    double accuracy;
    int i, j, n_edges, n_surfaces, id, edge_surf_id[2], n_uv_points;
    int n_quilts;
    ProError err;
    ProEdgeDir	edge_dirs[2];
    ProUvParam	(*p_edge_uv_point_arr)[2];
    ProEdgedata *p_edge_data;
    ProSurfacedata *p_surface_data, **p_surf_arr;	
    ProCurvedata edge_curve_data, *p_edge_uv_curve_data[2];
    ProCurvedata edge_uv_curve_0, edge_uv_curve_1;
    ProQuiltdata *p_quilt_data;

    p_edge_uv_curve_data[0] = &edge_uv_curve_0;
    p_edge_uv_curve_data[1] = &edge_uv_curve_1;

    err = ProIntfDataAccuracyGet(p_intf_data, &accuracy);
    err = ProIntfDataAccuracytypeGet(p_intf_data, &accuracy_type);
    err = ProIntfDataOutlineGet(p_intf_data, outline);

    fprintf(file, "Accuracy %.5f\n", accuracy);
    fprintf(file, "Accuracy type %d\n", accuracy_type);;
    fprintf(file, "Outline ( %.5f, %.5f, %.5f) - ( %.5f, %.5f, %.5f)\n", 
	outline[0][0], outline[0][1], outline[0][2], 
	outline[1][0], outline[1][1], outline[1][2]);

    err = ProIntfDataSurfaceCount(p_intf_data, &n_surfaces);
    fprintf(file, "Surfaces [%d]\n", n_surfaces);
    for (i=0; i<n_surfaces; i++)
    {
	err = ProIntfDataSurfaceGet(p_intf_data, i, &p_surface_data);
	fprintf(file, "Surface  %d\n", i + 1);
	ProUtilSurfacedataPrint(file, "    ", p_surface_data);
	err = ProSurfacedataMemoryFree(p_surface_data);
    }

    err = ProIntfDataEdgeCount(p_intf_data, &n_edges);
    fprintf(file, "Edges [%d]\n", n_edges);
    for (i=0; i<n_edges; i++)
    {
	
	err = ProIntfDataEdgeGet(p_intf_data, i, &p_edge_data);
	err = ProEdgedataGet(p_edge_data, &id, edge_surf_id, edge_dirs,
	    &p_edge_uv_point_arr, p_edge_uv_curve_data, &edge_curve_data);

	fprintf(file, "Edge %d\n", i + 1);
	fprintf(file, "    Id %d\n", id);
	fprintf(file, "    Surfaces Ids %d %d\n", edge_surf_id[0],
	    edge_surf_id[1]);
	fprintf(file, "    Edge dirs %d %d\n", edge_dirs[0], edge_dirs[1]);
	fprintf(file, "    Edge curve\n");
	ProUtilCurvedataPrint(file, "    ", &edge_curve_data);
	
	fprintf(file, "    Edge uv curve[0]\n");
	ProUtilCurvedataPrint(file, "        ", p_edge_uv_curve_data[0]);
	
	fprintf(file, "    Edge uv curve[1]\n");
	ProUtilCurvedataPrint(file, "        ", p_edge_uv_curve_data[1]);

	fprintf(file, "    Edge uv point array\n");
	err = ProArraySizeGet((ProArray)p_edge_uv_point_arr, &n_uv_points);
	ProUtilDoubleArrayPrint(file, "        ",
            (double*)p_edge_uv_point_arr, n_uv_points * 4);
    }

    err = ProIntfDataQuiltCount(p_intf_data, &n_quilts);
    fprintf(file, "Quits [%d]\n", n_quilts);
    for (i=0; i<n_quilts; i++)
    {
	err = ProIntfDataQuiltGet(p_intf_data, i, &p_quilt_data);
	fprintf(file, "Quit %d\n", i + 1);
	err = ProQuiltdataGet(p_quilt_data, &id);
	fprintf(file, "    Id %d\n", id);
	err = ProQuiltdataSurfArrayGet(p_quilt_data, &p_surf_arr);
	err = ProArraySizeGet((ProArray)p_surf_arr, &n_surfaces);

	fprintf(file, "    Quit surfaces %d\n", n_surfaces);
	for (j=0; j<n_surfaces; j++)
	{
	    fprintf(file, "    Quit surface  %d\n", i + 1);
	    ProUtilSurfacedataPrint(file, "        ", p_surf_arr[j]);
	}
	err = ProQuiltdataMemoryFree(p_quilt_data);
    }
    return ( PRO_TK_NO_ERROR);
}

#undef VECTOR