utilintfdata.c

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

	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);
	break;
    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