void Material::read( xmlNodePtr root )
{
int i;
double tmp[4];
xmlNodePtr node;
char* str = xmlFindString( root, "Name", "Default_Name" );
name = str; // name is a stringc
node = xmlGetNode( root, "Ambient", 0 );
xmlExtractDoubleArray( node, ',', tmp, 4 );
for ( i = 0 ; i < 4 ; i++ )
amb[i] = (float)tmp[i];
node = xmlGetNode( root, "Diffuse", 0 );
xmlExtractDoubleArray( node, ',', tmp, 4 );
for ( i = 0 ; i < 4 ; i++ )
diff[i] = (float)tmp[i];
node = xmlGetNode( root, "Specular", 0 );
xmlExtractDoubleArray( node, ',', tmp, 4 );
for ( i = 0 ; i < 4 ; i++ )
spec[i] = (float)tmp[i];
node = xmlGetNode( root, "Emission", 0 );
xmlExtractDoubleArray( node, ',', tmp, 4 );
for ( i = 0 ; i < 4 ; i++ )
emiss[i] = (float)tmp[i];
node = xmlGetNode( root, "Shininess", 0 );
shine = (float)xmlExtractDouble( node );
}
void ParmLinkMgr::ReadLinks(xmlNodePtr root, vector< Geom* > & geomVec)
{
vector< Geom* > gVec = geomVec;
gVec.push_back( aircraftPtr->getUserGeom() );
xmlNodePtr node_list = xmlGetNode( root, "ParmLink_List", 0 );
if ( node_list )
{
int num_links = xmlGetNumNames( node_list, "Link" );
for ( int i = 0 ; i < num_links ; i++ )
{
xmlNodePtr link_node = xmlGetNode( node_list, "Link", i );
if ( link_node )
{
int geomA_id = xmlFindInt( link_node, "GeomA", 0 );
Stringc groupA_name = Stringc( xmlFindString( link_node, "GroupA", " " ) );
Stringc parmA_name = Stringc( xmlFindString( link_node, "ParmA", " " ) );
Parm* parmA = FindParm( gVec, geomA_id, groupA_name, parmA_name );
int geomB_id = xmlFindInt( link_node, "GeomB", 0 );
Stringc groupB_name = Stringc( xmlFindString( link_node, "GroupB", " " ) );
Stringc parmB_name = Stringc( xmlFindString( link_node, "ParmB", " " ) );
Parm* parmB = FindParm( gVec, geomB_id, groupB_name, parmB_name );
if ( parmA && parmB )
{
ParmLink* pl = new ParmLink();
pl->SetParmA( parmA );
pl->SetParmB( parmB );
pl->SetOffsetFlag( !!xmlFindInt( link_node, "OffsetFlag", 0 ) );
pl->SetOffset( xmlFindDouble( link_node, "Offset", 0.0 ) );
pl->SetScaleFlag( !!xmlFindInt( link_node, "ScaleFlag", 0 ) );
pl->SetScale( xmlFindDouble( link_node, "Scale", 1.0 ) );
pl->SetLowerLimitFlag( !!xmlFindInt( link_node, "LowerLimitFlag", 0 ) );
pl->SetLowerLimit( xmlFindDouble( link_node, "LowerLimit", 0.0 ) );
pl->SetUpperLimitFlag( !!xmlFindInt( link_node, "UpperLimitFlag", 0 ) );
pl->SetUpperLimit( xmlFindDouble( link_node, "UpperLimit", 0.0 ) );
pl->GetParmA()->set_linked_flag( true );
pl->GetParmB()->set_linked_flag( true );
m_ParmLinkVec.push_back( pl );
m_CurrParmLinkIndex = (int)m_ParmLinkVec.size() - 1;
}
}
}
}
}
void VspGlWindow::readFile(xmlNodePtr root)
{
xmlNodePtr node_list = xmlGetNode( root, "VirtWindow_List", 0 );
if ( node_list )
{
int num_vwin = xmlGetNumNames( node_list, "VirtWindow" );
for ( int i = 0 ; i < num_vwin ; i++ )
{
xmlNodePtr vwin_node = xmlGetNode( node_list, "VirtWindow", i );
if ( vwin_node && i < NUM_V_WIN )
{
vWin[i]->readFile( vwin_node );
//vWin[i]->backImgScaleW = xmlFindDouble( vwin_node, "Back_Img_Scale_W", 1.0 );
//vWin[i]->backImgScaleH = xmlFindDouble( vwin_node, "Back_Img_Scale_H", 1.0 );
//vWin[i]->backImgOffsetX = xmlFindDouble( vwin_node, "Back_Img_Offset_X", 0.0 );
//vWin[i]->backImgOffsetY = xmlFindDouble( vwin_node, "Back_Img_Offset_Y", 0.0 );
}
}
}
}
void VirtGlWindow::readFile(xmlNodePtr node)
{
backImgScaleW = xmlFindDouble( node, "Back_Img_Scale_W", 1.0 );
backImgScaleH = xmlFindDouble( node, "Back_Img_Scale_H", 1.0 );
backImgOffsetX = xmlFindDouble( node, "Back_Img_Offset_X", 0.0 );
backImgOffsetY = xmlFindDouble( node, "Back_Img_Offset_Y", 0.0 );
xmlNodePtr user_view_list_node = xmlGetNode( node, "User_View_List", 0 );
if ( user_view_list_node )
{
int num_user_views = xmlGetNumNames( user_view_list_node, "User_View" );
for ( int i = 0 ; i < num_user_views ; i++ )
{
xmlNodePtr user_view_node = xmlGetNode( user_view_list_node, "User_View", i );
if ( i < NUM_USER_VIEWS )
{
savedUserViewFlag[i] = xmlFindInt( user_view_node, "Saved_User_View_Flag", 0 );
if ( savedUserViewFlag[i] )
{
savedRotationCenters[i].set_x( xmlFindDouble( user_view_node, "Saved_Rot_Center_X", 0.0 ) );
savedRotationCenters[i].set_y( xmlFindDouble( user_view_node, "Saved_Rot_Center_Y", 0.0 ) );
savedRotationCenters[i].set_z( xmlFindDouble( user_view_node, "Saved_Rot_Center_Z", 0.0 ) );
savedTrackVec[i].set_scale( xmlFindDouble( user_view_node, "Track_Scale", 1.0 ) );
double trans_x = xmlFindDouble( user_view_node, "Track_Trans_X", 0.0 );
double trans_y = xmlFindDouble( user_view_node, "Track_Trans_Y", 0.0 );
savedTrackVec[i].set_trans( trans_x, trans_y, 0.0 );
double rx = xmlFindDouble( user_view_node, "Track_Spin_Rot_X", 0.0 );
double ry = xmlFindDouble( user_view_node, "Track_Spin_Rot_Y", 0.0 );
double rz = xmlFindDouble( user_view_node, "Track_Spin_Rot_Z", 0.0 );
double rw = xmlFindDouble( user_view_node, "Track_Spin_Rot_W", 1.0 );
savedTrackVec[i].set_rvec( rx, ry, rz, rw );
}
}
}
}
}
void TextLabel::readTextLabel(Aircraft * airPtr, xmlNodePtr root)
{
xmlNodePtr text_node = xmlGetNode( root, "Text_Parms", 0 );
if ( text_node )
{
vertex1.read(airPtr, text_node, "Vertex1_Parms");
textOffset = xmlFindDouble(text_node, "TextOffset", textOffset);
fixedLabelFlag = xmlFindInt( text_node, "FixedLabelFlag", fixedLabelFlag ) != 0;
fixedPos[0] = xmlFindDouble(text_node, "FixedPosX", fixedPos[0] );
fixedPos[1] = xmlFindDouble(text_node, "FixedPosY", fixedPos[1] );
}
}
double xmlFindDouble( xmlNodePtr node, const char * name, double def )
{
xmlNodePtr n;
if ( node == NULL )
return def;
n = xmlGetNode( node, name, 0 );
if ( n )
return xmlExtractDouble( n );
return def;
}
int xmlFindInt( xmlNodePtr node, const char * name, int def )
{
xmlNodePtr n;
if ( node == NULL )
return def;
n = xmlGetNode( node, name, 0 );
if ( n )
return xmlExtractInt( n );
return def;
}
void VspPreferences::saveFile()
{
xmlNodePtr root = xmlDocGetRootElement(m_XmlDoc);
if (root == NULL)
return;
xmlNodePtr node = xmlGetNode( root, "DefaultComponentFileID", 0 );
// xmlAddIntNode( root, "DefaultComponentFileID", m_DefaultCompFileID );
char str[16];
sprintf(str, "%d", m_DefaultCompFileID );
xmlNodeSetContent( node, (const xmlChar *)str );
xmlSaveFormatFile("VspPreferences.xml", m_XmlDoc, 1);
}
void MaterialMgr::readFile(xmlNodePtr materialDefines)
{
//==== Read Materials ====//
int num_mats = xmlGetNumNames( materialDefines, "Material" );
for ( int i = 0 ; i < num_mats ; i++ )
{
xmlNodePtr mat_node = xmlGetNode( materialDefines, "Material", i );
Material* mat = new Material;
mat->read( mat_node );
matVec.push_back( mat );
}
}
const char* xmlFindString( xmlNodePtr node, const char * name, const char* def )
{
xmlNodePtr n;
if ( node == NULL )
return def;
n = xmlGetNode( node, name, 0 );
if ( n )
{
char* ret = xmlExtractString( n );
if ( ret )
return ret;
}
return def;
}
void RulerLabel::readRulerLabel(Aircraft * airPtr, xmlNodePtr root)
{
xmlNodePtr ruler_node = xmlGetNode( root, "Ruler_Parms", 0 );
if ( ruler_node )
{
vertex2.read(airPtr, ruler_node, "Vertex2_Parms");
rulerOffset = xmlFindDouble(ruler_node, "RulerOffset", rulerOffset);
attachState = xmlFindInt(ruler_node, "AttachState", attachState);
xLock = xmlFindInt(ruler_node, "XLock", xLock);
yLock = xmlFindInt(ruler_node, "YLock", yLock);
zLock = xmlFindInt(ruler_node, "ZLock", zLock);
rulerDistance = xmlFindDouble(ruler_node, "RulerDistance", rulerDistance);
precision = xmlFindInt(ruler_node, "Precision", precision);
unitString = xmlFindString(ruler_node, "UnitString", unitString.get_char_star());
}
}
void UserGeom::read(xmlNodePtr root)
{
xmlNodePtr node;
node = xmlGetNode( root, "User_Parms", 0 );
if ( node )
{
userParm1 = xmlFindDouble( node, "User1", userParm1() );
userParm2 = xmlFindDouble( node, "User2", userParm2() );
userParm3 = xmlFindDouble( node, "User3", userParm3() );
userParm4 = xmlFindDouble( node, "User4", userParm4() );
userParm5 = xmlFindDouble( node, "User5", userParm5() );
userParm6 = xmlFindDouble( node, "User6", userParm6() );
userParm7 = xmlFindDouble( node, "User7", userParm7() );
userParm8 = xmlFindDouble( node, "User8", userParm8() );
}
}
void LabelGeom::readLabelGeom(xmlNodePtr root)
{
xmlNodePtr label_node;
//===== Read Parameters =====//
label_node = xmlGetNode( root, "Label_Parms", 0 );
if ( label_node )
{
// type = xmlFindInt( label_node, "TypeInt", type );
// type_str = xmlFindString( label_node, "TypeStr", type_str.get_char_star());
name_str = xmlFindString( label_node, "NameStr", name_str.get_char_star());
color.set_x( xmlFindDouble( label_node, "ColorR", color.x() ) );
color.set_y( xmlFindDouble( label_node, "ColorG", color.y() ) );
color.set_z( xmlFindDouble( label_node, "ColorB", color.z() ) );
drawMode = xmlFindInt( label_node, "DrawMode", drawMode );
textSize = (float)xmlFindDouble( label_node, "TextSize", textSize );
viewScale = xmlFindDouble( label_node, "ViewScale", viewScale );
}
}
void PHolderListMgr::ReadPHolderListXDDM( char *newfile )
{
pHolderListMgrPtr->DelAllPHolders();
//==== Read Xml File ====//
xmlDocPtr doc;
xmlNodePtr node;
LIBXML_TEST_VERSION
xmlKeepBlanksDefault(0);
//==== Build an XML tree from a the file ====//
doc = xmlParseFile(newfile);
// if (doc == NULL) return 0;
xmlNodePtr root = xmlDocGetRootElement(doc);
if (root == NULL)
{
fprintf(stderr,"empty document\n");
xmlFreeDoc(doc);
// return 0;
}
vector< Geom* > gVec = aircraftPtr->getGeomVec();
gVec.push_back( aircraftPtr->getUserGeom() );
vector< xmlNodePtr > vlist;
int num_v = xmlGetNumNames( root, "Variable" );
for ( int i = 0 ; i < num_v ; i++ )
{
xmlNodePtr var_node = xmlGetNode( root, "Variable", i );
vlist.push_back( var_node );
}
int num_c = xmlGetNumNames( root, "Constant" );
for ( int i = 0 ; i < num_c ; i++ )
{
xmlNodePtr cst_node = xmlGetNode( root, "Constant", i );
vlist.push_back( cst_node );
}
int num_tot = num_v + num_c;
for ( int i = 0 ; i < num_tot ; i++ )
{
xmlNodePtr var_node = vlist[i];
if ( var_node )
{
Stringc varname = Stringc( xmlFindPropString( var_node, "VSPVarName", " " ) );
int istart = 0;
int iend = varname.search_for_substring(':');
int id = varname.get_range( istart, iend-1 ).convert_to_integer();
istart = iend + 1;
iend = varname.search_for_substring( istart, ':' );
istart = iend + 1;
iend = varname.search_for_substring( istart, ':' );
Stringc group = varname.get_range( istart, iend-1 );
istart = iend + 1;
iend = varname.get_length();
Stringc parm = varname.get_range( istart, iend-1 );
Parm* p = parmMgrPtr->FindParm( gVec, id, group, parm );
if ( p )
{
double val = xmlFindPropDouble( var_node, "Value", p->get() );
p->set_from_link( val );
p->get_geom()->parm_changed( p );
ParmHolder* ph = new ParmHolder();
ph->setParm( p );
const xmlChar* varstr = (xmlChar*) "Variable";
if( !xmlStrcmp(var_node->name, varstr ) )
ph->setDesType( XDDM_VAR );
else
ph->setDesType( XDDM_CONST );
m_PHolderVec.push_back( ph );
m_CurrPHolderIndex = (int)m_PHolderVec.size() - 1;
}
}
}
//===== Free Doc =====//
xmlFreeDoc( doc );
// return 1;
}
VspPreferences::VspPreferences()
{
outputNameVec.push_back( Stringc("No_Default") );
m_DefaultCompFileVec.clear();
DefaultCompFile dcf;
dcf.m_Name = Stringc("Default");
dcf.m_File = Stringc("");
m_DefaultCompFileVec.push_back( dcf );
// xmlDocPtr doc;
// LIBXML_TEST_VERSION
xmlKeepBlanksDefault(0);
//==== Build an XML tree from a the file ====//
m_XmlDoc = xmlParseFile("VspPreferences.xml");
if (m_XmlDoc == NULL) return;
xmlNodePtr root = xmlDocGetRootElement(m_XmlDoc);
if (root == NULL)
{
fprintf(stderr,"empty document\n");
xmlFreeDoc(m_XmlDoc);
return;
}
if ( xmlStrcmp( root->name, (const xmlChar *)"Vsp_Preferences" ) )
{
fprintf(stderr, "document of the wrong type, VSP Preferences Name list not found\n");
xmlFreeDoc(m_XmlDoc);
return;
}
m_DefaultCompFileID = xmlFindInt(root, "DefaultComponentFileID", 0);
xmlNodePtr defaultCompListNode = xmlGetNode(root, "DefaultComponentFileList", 0);
if (defaultCompListNode)
{
//==== Read Default Comp Files ====//
int num_def_files = xmlGetNumNames( defaultCompListNode, "DefaultComponentFile" );
for ( int i = 0 ; i < num_def_files ; i++ )
{
xmlNodePtr def_file_node = xmlGetNode( defaultCompListNode, "DefaultComponentFile", i );
if ( def_file_node )
{
dcf.m_Name = Stringc( xmlFindString( def_file_node, "Name", "Default_Name" ) );
dcf.m_File = Stringc( xmlFindString( def_file_node, "File", "Default_File" ) );
m_DefaultCompFileVec.push_back( dcf );
}
}
}
xmlNodePtr outputNames = xmlGetNode(root, "Vsp_OutputNames", 0);
if (outputNames)
{
//==== Read Names ====//
int num_names = xmlGetNumNames( outputNames, "OutputName" );
for ( int i = 0 ; i < num_names ; i++ )
{
xmlNodePtr name_node = xmlGetNode( outputNames, "OutputName", i );
char* str = xmlFindString( name_node, "Value", "Default_Name" );
outputNameVec.push_back( Stringc(str) );
}
}
xmlNodePtr materialDefines = xmlGetNode(root, "Vsp_Material_Defines", 0);
if (materialDefines)
{
matMgrPtr->readFile(materialDefines);
}
windowMgrStyle = xmlFindInt(root, "WindowManagerStyle", 0);
autoSaveInterval = xmlFindInt(root, "AutoSaveInterval", 180);
}
void Af::read(xmlNodePtr node)
{
int i;
int temp_type = xmlFindInt( node, "Type", 0 );
inverted_flag = xmlFindInt( node, "Inverted_Flag", inverted_flag );
camber = xmlFindDouble( node, "Camber", camber() );
camber_loc = xmlFindDouble( node, "Camber_Loc", camber_loc() );
thickness = xmlFindDouble( node, "Thickness", thickness() );
thickness_loc = xmlFindDouble( node, "Thickness_Loc", thickness_loc() );
radius_le = xmlFindDouble( node, "Radius_Le", radius_le() );
radius_te = xmlFindDouble( node, "Radius_Te", radius_te() );
sixser = xmlFindInt( node, "Six_Series", sixser );
ideal_cl = xmlFindDouble( node, "Ideal_Cl", ideal_cl() );
a = xmlFindDouble( node, "A", a() );
slat_flag = xmlFindInt( node, "Slat_Flag", slat_flag );
slat_shear_flag = xmlFindInt( node, "Slat_Shear_Flag", slat_shear_flag );
slat_chord = xmlFindDouble( node, "Slat_Chord", slat_chord() );
slat_angle = xmlFindDouble( node, "Slat_Angle", slat_angle() );
flap_flag = xmlFindInt( node, "Flap_Flag", flap_flag );
flap_shear_flag = xmlFindInt( node, "Flap_Shear_Flag", flap_shear_flag );
flap_chord = xmlFindDouble( node, "Flap_Chord", flap_chord() );
flap_angle = xmlFindDouble( node, "Flap_Angle", flap_angle() );
if ( temp_type == AIRFOIL_FILE )
{
vec3d pnt;
name = xmlFindString( node, "Name", name );
orig_af_thickness = (float)xmlFindDouble( node, "Original_AF_Thickness", orig_af_thickness );
radius_le_correction_factor = (float)xmlFindDouble( node, "Radius_LE_Correction_Factor", radius_le_correction_factor );
radius_te_correction_factor = (float)xmlFindDouble( node, "Radius_TE_Correction_Factor", radius_te_correction_factor );
xmlNodePtr upp_node = xmlGetNode( node, "Upper_Pnts", 0 );
if ( upp_node )
{
int num_arr = xmlGetNumArray( upp_node, ',' );
double* arr = (double*)malloc( num_arr*sizeof(double) );
xmlExtractDoubleArray( upp_node, ',', arr, num_arr );
int num_upper = num_arr/2;
upper_curve.init(num_upper);
for ( i = 0 ; i < num_arr ; i+=2)
{
pnt = vec3d(arr[i], 0.0, arr[i+1]);
upper_curve.load_pnt( i/2, pnt );
}
free(arr);
}
xmlNodePtr low_node = xmlGetNode( node, "Lower_Pnts", 0 );
if ( low_node )
{
int num_arr = xmlGetNumArray( low_node, ',' );
double* arr = (double*)malloc( num_arr*sizeof(double) );
xmlExtractDoubleArray( low_node, ',', arr, num_arr );
int num_lower = num_arr/2;
lower_curve.init(num_lower);
for ( i = 0 ; i < num_arr ; i+=2)
{
pnt = vec3d(arr[i], 0.0, arr[i+1]);
lower_curve.load_pnt( i/2, pnt );
}
free(arr);
}
}
set_type(temp_type);
}
//==== Read External File ====//
void PropGeom::read(xmlNodePtr root)
{
int i;
xmlNodePtr node;
//===== Read General Parameters =====//
node = xmlGetNode( root, "General_Parms", 0 );
if ( node )
read_general_parms( node );
//===== Read Fuse Parameters =====//
node = xmlGetNode( root, "Prop_Parms", 0 );
if ( node )
{
numBlades = xmlFindInt( node, "NumBlades", numBlades );
smoothFlag = xmlFindInt( node, "SmoothFlag", smoothFlag );
numU = xmlFindInt( node, "NumU", numU );
numW = xmlFindInt( node, "NumW", numW );
diameter = xmlFindDouble( node, "Diameter", diameter() );
cone_angle = xmlFindDouble( node, "ConeAngle", diameter() );
pitch = xmlFindDouble( node, "Pitch", diameter() );
int num_sects = xmlGetNumNames( node, "Sect_Parms" );
if ( num_sects >= 2 )
{
//==== Delete Old Sect Vec ====//
DeleteAllFoilsAndSects();
//for ( i = 0 ; i < (int)sectVec.size() ; i++ )
//{
// RemoveFoilParmReferences( sectVec[i].foil );
// delete sectVec[i].foil;
//}
sectVec.resize( num_sects );
for ( i = 0 ; i < (int)sectVec.size() ; i++ )
{
xmlNodePtr sect_node = xmlGetNode( node, "Sect_Parms", i );
sectVec[i].chord = xmlFindDouble( sect_node, "Chord", sectVec[i].chord() );
sectVec[i].x_off = xmlFindDouble( sect_node, "X_Off", sectVec[i].x_off() );
sectVec[i].y_off = xmlFindDouble( sect_node, "Y_Off", sectVec[i].y_off() );
sectVec[i].twist = xmlFindDouble( sect_node, "Twist", sectVec[i].twist() );
sectVec[i].foil = new Af(this);
sectVec[i].foil->init_script(Stringc("prop_foil"));
xmlNodePtr af_node = xmlGetNode( sect_node, "Airfoil", 0 );
if ( af_node )
sectVec[i].foil->read( af_node);
sectVec[i].foil->set_num_pnts( numPnts.iget() );
sectVec[i].foil->generate_airfoil();
sectVec[i].foil->load_name();
}
}
chord = sectVec[0].chord;
loc = sectVec[0].x_off;
offset = sectVec[0].y_off;
twist = sectVec[0].twist;
}
currSectID = 0;
generate();
parmLinkMgrPtr->RebuildAll();
}
//==== Read Fuse Cross Section File ====//
void FuselageXSec::read_parms(xmlNodePtr node)
{
int i;
xstype = xmlFindInt( node, "Type", xstype );
height = xmlFindDouble( node, "Height", height() );
width = xmlFindDouble( node, "Width", width() );
max_width_loc = xmlFindDouble( node, "Max_Width_Location", max_width_loc() );
corner_rad = xmlFindDouble( node, "Corner_Radius", corner_rad() );
top_tan_angle = xmlFindDouble( node, "Top_Tan_Angle", top_tan_angle());
bot_tan_angle = xmlFindDouble( node, "Bot_Tan_Angle", bot_tan_angle());
top_str = xmlFindDouble( node, "Top_Tan_Strength", top_str() );
upp_str = xmlFindDouble( node, "Upper_Tan_Strength", upp_str() );
low_str = xmlFindDouble( node, "Lower_Tan_Strength", low_str() );
bot_str = xmlFindDouble( node, "Bottom_Tan_Strength", bot_str() );
if ( xstype == FXS_FROM_FILE )
{
xstype = FXS_GENERAL; // If this fails fall back on something...
fileName = Stringc( xmlFindString( node, "File_Name", "File_Xsec" ) ); // fileName is a Stringc
xmlNodePtr yn = xmlGetNode( node, "File_Y_Pnts", 0 );
xmlNodePtr zn = xmlGetNode( node, "File_Z_Pnts", 0 );
if ( yn && zn )
{
int numy = xmlGetNumArray( yn, ',' );
int numz = xmlGetNumArray( zn, ',' );
if ( numy == numz )
{
int num_pnts = numy;
double* arry = (double*)malloc( num_pnts*sizeof(double) );
double* arrz = (double*)malloc( num_pnts*sizeof(double) );
xmlExtractDoubleArray( yn, ',', arry, num_pnts );
xmlExtractDoubleArray( zn, ',', arrz, num_pnts );
xstype = FXS_FROM_FILE;
file_crv.init( num_pnts );
for ( i = 0 ; i < num_pnts ; i++ )
{
file_crv.load_pnt( i, vec3d( 0.0, arry[i], arrz[i] ));
}
free( arry );
free( arrz );
file_crv.comp_tans();
vec3d top_tan = vec3d( 0.0, 1.0, 0.0 );
double tan_mag = file_crv.get_tan(0).mag();
file_crv.load_tan( 0, top_tan*tan_mag );
int last_id = file_crv.get_num_pnts() - 1;
vec3d bot_tan = vec3d( 0.0, -1.0, 0.0 );
tan_mag = file_crv.get_tan( last_id ).mag();
file_crv.load_tan( last_id, bot_tan*tan_mag );
}
}
}
else if ( xstype == FXS_EDIT_CRV )
{
edit_crv.read( node );
}
set_type(xstype);
}
