template<> SEXP wrap<RcppDate>(const RcppDate& date) {
Rcpp::NumericVector value(1);
value[0] = date.getJulian();
Rcpp::RObject robj((SEXP)value);
robj.attr("class") = "Date";
return value;
}
template<> SEXP wrap<RcppDatetime>(const RcppDatetime& date) {
Rcpp::NumericVector value(1);
Rcpp::CharacterVector classname(2);
value[0] = date.getFractionalTimestamp();
Rcpp::RObject robj((SEXP)value);
classname[0] = Rcpp::datetimeClass[0];
classname[1] = Rcpp::datetimeClass[1];
robj.attr("class") = classname;
return value;
}
void NativeFunctionInfo::call(JSContext* cx, JS::CallArgs args) {
auto holder = getHolder(args);
if (!holder) {
// Calling the prototype
args.rval().setUndefined();
return;
}
JS::RootedObject robj(cx, JS_NewArrayObject(cx, args));
if (!robj) {
uasserted(ErrorCodes::JSInterpreterFailure, "Failed to JS_NewArrayObject");
}
BSONObj out = holder->_func(ObjectWrapper(cx, robj).toBSON(), holder->_ctx);
ValueReader(cx, args.rval()).fromBSONElement(out.firstElement(), out, false);
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
// *** Example body.
try {
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
RealT V_th = parlist->get("Thermal Voltage", 0.02585);
RealT lo_Vsrc = parlist->get("Source Voltage Lower Bound", 0.0);
RealT up_Vsrc = parlist->get("Source Voltage Upper Bound", 1.0);
RealT step_Vsrc = parlist->get("Source Voltage Step", 1.e-2);
RealT true_Is = parlist->get("True Saturation Current", 1.e-12);
RealT true_Rs = parlist->get("True Saturation Resistance", 0.25);
RealT init_Is = parlist->get("Initial Saturation Current", 1.e-12);
RealT init_Rs = parlist->get("Initial Saturation Resistance", 0.25);
RealT lo_Is = parlist->get("Saturation Current Lower Bound", 1.e-16);
RealT up_Is = parlist->get("Saturation Current Upper Bound", 1.e-1);
RealT lo_Rs = parlist->get("Saturation Resistance Lower Bound", 1.e-2);
RealT up_Rs = parlist->get("Saturation Resistance Upper Bound", 30.0);
// bool use_lambertw = parlist->get("Use Analytical Solution",true);
bool use_scale = parlist->get("Use Scaling For Epsilon-Active Sets",true);
bool use_sqp = parlist->get("Use SQP", true);
// bool use_linesearch = parlist->get("Use Line Search", true);
// bool datatype = parlist->get("Get Data From Input File",false);
// bool use_adjoint = parlist->get("Use Adjoint Gradient Computation",false);
// int use_hessvec = parlist->get("Use Hessian-Vector Implementation",1); // 0 - FD, 1 - exact, 2 - GN
// bool plot = parlist->get("Generate Plot Data",false);
// RealT noise = parlist->get("Measurement Noise",0.0);
EqualityConstraint_DiodeCircuit<RealT> con(V_th,lo_Vsrc,up_Vsrc,step_Vsrc);
RealT alpha = 1.e-4; // regularization parameter (unused)
int ns = 101; // number of Vsrc components
int nz = 2; // number of optimization variables
Objective_DiodeCircuit<RealT> obj(alpha,ns,nz);
// Initialize iteration vectors.
Teuchos::RCP<std::vector<RealT> > z_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
Teuchos::RCP<std::vector<RealT> > yz_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
Teuchos::RCP<std::vector<RealT> > soln_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
(*z_rcp)[0] = init_Is;
(*z_rcp)[1] = init_Rs;
(*yz_rcp)[0] = init_Is;
(*yz_rcp)[1] = init_Rs;
(*soln_rcp)[0] = true_Is;
(*soln_rcp)[1] = true_Rs;
ROL::StdVector<RealT> z(z_rcp);
ROL::StdVector<RealT> yz(yz_rcp);
ROL::StdVector<RealT> soln(soln_rcp);
Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(&z,false);
Teuchos::RCP<ROL::Vector<RealT> > yzp = Teuchos::rcp(&yz,false);
Teuchos::RCP<std::vector<RealT> > u_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
Teuchos::RCP<std::vector<RealT> > yu_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
std::ifstream input_file("measurements.dat");
RealT temp, temp_scale;
for (int i=0; i<ns; i++) {
input_file >> temp;
input_file >> temp;
temp_scale = pow(10,int(log10(temp)));
(*u_rcp)[i] = temp_scale*(RealT)rand()/(RealT)RAND_MAX;
(*yu_rcp)[i] = temp_scale*(RealT)rand()/(RealT)RAND_MAX;
}
input_file.close();
ROL::StdVector<RealT> u(u_rcp);
ROL::StdVector<RealT> yu(yu_rcp);
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(&u,false);
Teuchos::RCP<ROL::Vector<RealT> > yup = Teuchos::rcp(&yu,false);
Teuchos::RCP<std::vector<RealT> > jv_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 1.0) );
ROL::StdVector<RealT> jv(jv_rcp);
Teuchos::RCP<ROL::Vector<RealT> > jvp = Teuchos::rcp(&jv,false);
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> y(yup,yzp);
// Check derivatives
obj.checkGradient(x,x,y,true,*outStream);
obj.checkHessVec(x,x,y,true,*outStream);
con.checkApplyJacobian(x,y,jv,true,*outStream);
con.checkApplyAdjointJacobian(x,yu,jv,x,true,*outStream);
con.checkApplyAdjointHessian(x,yu,y,x,true,*outStream);
// Check consistency of Jacobians and adjoint Jacobians.
con.checkAdjointConsistencyJacobian_1(jv,yu,u,z,true,*outStream);
con.checkAdjointConsistencyJacobian_2(jv,yz,u,z,true,*outStream);
// Check consistency of solves.
con.checkSolve(u,z,jv,true,*outStream);
con.checkInverseJacobian_1(jv,yu,u,z,true,*outStream);
con.checkInverseAdjointJacobian_1(yu,jv,u,z,true,*outStream);
// Initialize reduced objective function.
Teuchos::RCP<std::vector<RealT> > p_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
ROL::StdVector<RealT> p(p_rcp);
Teuchos::RCP<ROL::Vector<RealT> > pp = Teuchos::rcp(&p,false);
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > pobj = Teuchos::rcp(&obj,false);
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > pcon = Teuchos::rcp(&con,false);
ROL::Reduced_Objective_SimOpt<RealT> robj(pobj,pcon,up,pp);
// Check derivatives.
*outStream << "Derivatives of reduced objective" << std::endl;
robj.checkGradient(z,z,yz,true,*outStream);
robj.checkHessVec(z,z,yz,true,*outStream);
// Bound constraints
RealT tol = 1.e-12;
Teuchos::RCP<std::vector<RealT> > g0_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );;
ROL::StdVector<RealT> g0p(g0_rcp);
robj.gradient(g0p,z,tol);
*outStream << std::scientific << "Initial gradient = " << (*g0_rcp)[0] << " " << (*g0_rcp)[1] << "\n";
*outStream << std::scientific << "Norm of Gradient = " << g0p.norm() << "\n";
// Define scaling for epsilon-active sets (used in inequality constraints)
RealT scale;
if(use_scale){ scale = 1.0e-2/g0p.norm();}
else{ scale = 1.0;}
*outStream << std::scientific << "Scaling: " << scale << "\n";
/// Define constraints on Is and Rs
BoundConstraint_DiodeCircuit<RealT> bcon(scale,lo_Is,up_Is,lo_Rs,up_Rs);
//bcon.deactivate();
// Optimization
*outStream << "\n Initial guess " << (*z_rcp)[0] << " " << (*z_rcp)[1] << std::endl;
if (!use_sqp){
// Trust Region
ROL::Algorithm<RealT> algo_tr("Trust Region",*parlist);
std::clock_t timer_tr = std::clock();
algo_tr.run(z,robj,bcon,true,*outStream);
*outStream << "\n Solution " << (*z_rcp)[0] << " " << (*z_rcp)[1] << "\n" << std::endl;
*outStream << "Trust-Region required " << (std::clock()-timer_tr)/(RealT)CLOCKS_PER_SEC
<< " seconds.\n";
}
else{
// SQP.
//Teuchos::RCP<std::vector<RealT> > gz_rcp = Teuchos::rcp( new std::vector<RealT> (nz, 0.0) );
//ROL::StdVector<RealT> gz(gz_rcp);
//Teuchos::RCP<ROL::Vector<RealT> > gzp = Teuchos::rcp(&gz,false);
Teuchos::RCP<std::vector<RealT> > gu_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
ROL::StdVector<RealT> gu(gu_rcp);
Teuchos::RCP<ROL::Vector<RealT> > gup = Teuchos::rcp(&gu,false);
//ROL::Vector_SimOpt<RealT> g(gup,gzp);
ROL::Vector_SimOpt<RealT> g(gup,zp);
Teuchos::RCP<std::vector<RealT> > c_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
Teuchos::RCP<std::vector<RealT> > l_rcp = Teuchos::rcp( new std::vector<RealT> (ns, 0.0) );
ROL::StdVector<RealT> c(c_rcp);
ROL::StdVector<RealT> l(l_rcp);
ROL::Algorithm<RealT> algo_cs("Composite Step",*parlist);
//x.zero();
std::clock_t timer_cs = std::clock();
algo_cs.run(x,g,l,c,obj,con,true,*outStream);
*outStream << "\n Solution " << (*z_rcp)[0] << " " << (*z_rcp)[1] << "\n" << std::endl;
*outStream << "Composite Step required " << (std::clock()-timer_cs)/(RealT)CLOCKS_PER_SEC
<< " seconds.\n";
}
soln.axpy(-1.0, z);
*outStream << "Norm of error: " << soln.norm() << std::endl;
if (soln.norm() > 1e4*ROL::ROL_EPSILON) {
errorFlag = 1;
}
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
// *** Example body.
try {
// Initialize full objective function.
int nx = 256; // Set spatial discretization.
RealT alpha = 1.e-3; // Set penalty parameter.
RealT nu = 1e-2; // Viscosity parameter.
Objective_BurgersControl<RealT> obj(alpha,nx);
// Initialize equality constraints
EqualityConstraint_BurgersControl<RealT> con(nx,nu);
Teuchos::ParameterList list;
list.sublist("SimOpt").sublist("Solve").set("Residual Tolerance",1.e2*ROL::ROL_EPSILON);
con.setSolveParameters(list);
// Initialize iteration vectors.
Teuchos::RCP<std::vector<RealT> > z_rcp = Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
Teuchos::RCP<std::vector<RealT> > gz_rcp = Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
Teuchos::RCP<std::vector<RealT> > yz_rcp = Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
for (int i=0; i<nx+2; i++) {
(*z_rcp)[i] = (RealT)rand()/(RealT)RAND_MAX;
(*yz_rcp)[i] = (RealT)rand()/(RealT)RAND_MAX;
}
ROL::StdVector<RealT> z(z_rcp);
ROL::StdVector<RealT> gz(gz_rcp);
ROL::StdVector<RealT> yz(yz_rcp);
Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(&z,false);
Teuchos::RCP<ROL::Vector<RealT> > gzp = Teuchos::rcp(&z,false);
Teuchos::RCP<ROL::Vector<RealT> > yzp = Teuchos::rcp(&yz,false);
Teuchos::RCP<std::vector<RealT> > u_rcp = Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<std::vector<RealT> > gu_rcp = Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<std::vector<RealT> > yu_rcp = Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
for (int i=0; i<nx; i++) {
(*u_rcp)[i] = (RealT)rand()/(RealT)RAND_MAX;
(*yu_rcp)[i] = (RealT)rand()/(RealT)RAND_MAX;
}
ROL::StdVector<RealT> u(u_rcp);
ROL::StdVector<RealT> gu(gu_rcp);
ROL::StdVector<RealT> yu(yu_rcp);
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(&u,false);
Teuchos::RCP<ROL::Vector<RealT> > gup = Teuchos::rcp(&u,false);
Teuchos::RCP<ROL::Vector<RealT> > yup = Teuchos::rcp(&yu,false);
Teuchos::RCP<std::vector<RealT> > c_rcp = Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<std::vector<RealT> > l_rcp = Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
ROL::StdVector<RealT> c(c_rcp);
ROL::StdVector<RealT> l(l_rcp);
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> g(gup,gzp);
ROL::Vector_SimOpt<RealT> y(yup,yzp);
// Check derivatives.
obj.checkGradient(x,x,y,true,*outStream);
obj.checkHessVec(x,x,y,true,*outStream);
con.checkApplyJacobian(x,y,c,true,*outStream);
con.checkApplyAdjointJacobian(x,yu,c,x,true,*outStream);
con.checkApplyAdjointHessian(x,yu,y,x,true,*outStream);
// Initialize reduced objective function.
Teuchos::RCP<std::vector<RealT> > p_rcp = Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
ROL::StdVector<RealT> p(p_rcp);
Teuchos::RCP<ROL::Vector<RealT> > pp = Teuchos::rcp(&p,false);
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > pobj = Teuchos::rcp(&obj,false);
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > pcon = Teuchos::rcp(&con,false);
ROL::Reduced_Objective_SimOpt<RealT> robj(pobj,pcon,up,pp);
// Check derivatives.
robj.checkGradient(z,z,yz,true,*outStream);
robj.checkHessVec(z,z,yz,true,*outStream);
// Get parameter list.
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
parlist->sublist("Status Test").set("Gradient Tolerance",1.e-14);
parlist->sublist("Status Test").set("Constraint Tolerance",1.e-14);
parlist->sublist("Status Test").set("Step Tolerance",1.e-16);
parlist->sublist("Status Test").set("Iteration Limit",1000);
// Declare ROL algorithm pointer.
Teuchos::RCP<ROL::Algorithm<RealT> > algo;
// Run optimization with Composite Step.
algo = Teuchos::rcp(new ROL::Algorithm<RealT>("Composite Step",*parlist,false));
RealT zerotol = std::sqrt(ROL::ROL_EPSILON);
z.zero();
con.solve(c,u,z,zerotol);
c.zero(); l.zero();
algo->run(x, g, l, c, obj, con, true, *outStream);
Teuchos::RCP<ROL::Vector<RealT> > zCS = z.clone();
zCS->set(z);
// Run Optimization with Trust-Region algorithm.
algo = Teuchos::rcp(new ROL::Algorithm<RealT>("Trust Region",*parlist,false));
z.zero();
algo->run(z,robj,true,*outStream);
// Check solutions.
Teuchos::RCP<ROL::Vector<RealT> > err = z.clone();
err->set(*zCS); err->axpy(-1.,z);
errorFlag += ((err->norm()) > 1.e-8) ? 1 : 0;
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
try {
char* conffile = mxArrayToString(prhs[0]);
char* robotname = mxArrayToString(prhs[1]);
//mexPrintf("conffile = %s", conffile);
Robot robj(conffile, robotname);
// Create link structure
mxArray *links = mxCreateStructMatrix(robj.get_dof(), 1, NUM_LINK_FIELDS, link_field_names);
double *ptr = NULL;
Link *rlinks = robj.links;
std::vector<double> immobileID;
for (int i=1; i <= robj.get_dof(); ++i)
{
// Return the joint type.
mxSetField(links, i-1, "joint_type", mxCreateDoubleScalar( rlinks[i].get_joint_type() ));
// Return theta.
mxSetField(links, i-1, "theta", mxCreateDoubleScalar( rlinks[i].get_theta() ));
//!< Return d.
mxSetField(links, i-1, "d", mxCreateDoubleScalar( rlinks[i].get_d() ));
// Return a.
mxSetField(links, i-1, "a", mxCreateDoubleScalar( rlinks[i].get_a() ));
// Return alpha.
mxSetField(links, i-1, "alpha", mxCreateDoubleScalar( rlinks[i].get_alpha() ));
//!< Return q
mxSetField(links, i-1, "q", mxCreateDoubleScalar( rlinks[i].get_q() ));
// Return theta_min.
mxSetField(links, i-1, "theta_min", mxCreateDoubleScalar( rlinks[i].get_theta_min() ));
// Return theta_max.
mxSetField(links, i-1, "theta_max", mxCreateDoubleScalar( rlinks[i].get_theta_max() ));
// Return joint_offset.
mxSetField(links, i-1, "joint_offset", mxCreateDoubleScalar( rlinks[i].get_joint_offset() ));
// Return r.
mxArray *mr = mxArrayFromNMArray( rlinks[i].get_r() );
//mxArray *mr = mxCreateDoubleMatrix(1,3,mxREAL); ptr = mxGetPr(mr);
//ColumnVector r = rlinks[i].get_r();
//for (int n=0; n < 3; ++n) ptr[n] = r(n+1);
mxSetField(links, i-1, "r", mr);
// Return p.
mxArray *mp = mxArrayFromNMArray( rlinks[i].get_p() );
//mxArray *mp = mxCreateDoubleMatrix(1,3,mxREAL); ptr = mxGetPr(mp);
//ColumnVector p = rlinks[i].get_p();
//for (int n=0; n < 3; ++n) ptr[n] = p(n+1);
mxSetField(links, i-1, "p", mp);
// Return m.
mxSetField(links, i-1, "m", mxCreateDoubleScalar( rlinks[i].get_m() ));
// Return Im.
mxSetField(links, i-1, "Im", mxCreateDoubleScalar( rlinks[i].get_Im() ));
// Return Gr.
mxSetField(links, i-1, "Gr", mxCreateDoubleScalar( rlinks[i].get_Gr() ));
// Return B.
mxSetField(links, i-1, "B", mxCreateDoubleScalar( rlinks[i].get_B() ));
// Return Cf.
mxSetField(links, i-1, "Cf", mxCreateDoubleScalar( rlinks[i].get_Cf() ));
// Return I.
mxArray *mI = mxArrayFromNMArray( rlinks[i].get_I() );
//mxArray *mI = mxCreateDoubleMatrix(3,3,mxREAL);
//Matrix I = rlinks[i].get_I();
//NMMatrixToMxArray(mxGetPr(mI), I, 3, 3);
mxSetField(links, i-1, "I", mI);
// Return immobile.
mxSetField(links, i-1, "immobile", mxCreateLogicalScalar( rlinks[i].get_immobile() ));
if ( rlinks[i].get_immobile() )
{
immobileID.push_back((double)i);
}
}
// Create robot structure
LHS_ARG_1 = mxCreateStructMatrix(1, 1, NUM_ROBOT_FIELDS, robot_field_names);
// Set name
mxSetField(LHS_ARG_1, 0, "name", mxCreateString(robotname) );
// Set gravity
mxSetField(LHS_ARG_1, 0, "gravity", mxArrayFromNMArray( robj.gravity ) );
// Return DH type
mxSetField(LHS_ARG_1, 0, "DH", mxCreateLogicalScalar( robj.get_DH() ));
// Return DOF
mxSetField(LHS_ARG_1, 0, "dof", mxCreateDoubleScalar( (double)robj.get_dof() ));
// Return available DOF
mxSetField(LHS_ARG_1, 0, "available_dof", mxCreateDoubleScalar( robj.get_available_dof() ));
// Return IDs of immobile joints
int nImmobileJnts = (int)immobileID.size();
if ( nImmobileJnts > 0 )
{
mxArray *tempArray = mxCreateDoubleMatrix(1,nImmobileJnts,mxREAL);
memcpy( mxGetPr(tempArray), &immobileID[0], nImmobileJnts*sizeof(double) );
mxSetField(LHS_ARG_1, 0, "immobile_joints", tempArray);
} else {
mxSetField(LHS_ARG_1, 0, "immobile_joints", mxCreateDoubleMatrix(0,0, mxREAL));
}
// Return links
mxSetField(LHS_ARG_1, 0, "links", links);
// Free allocated stuff
mxFree( conffile );
mxFree( robotname );
} catch(Exception) {
std::ostringstream msg;
msg << mexFunctionName() << ":: " << Exception::what();
mexErrMsgTxt(msg.str().c_str());
} catch (const std::runtime_error& e) {
std::ostringstream msg;
msg << mexFunctionName() << ":: " << e.what();
mexErrMsgTxt(msg.str().c_str());
} catch (...) {
std::ostringstream msg;
msg << mexFunctionName() << ":: Unknown failure during operation";
mexErrMsgTxt(msg.str().c_str());
}
}
void GL_model::load_obj(string fil)
{
ifstream obj(fil, ios::in);
string s;
stringstream ss;
int tri_num[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int all_ver_num = 0;
int all_nor_num = 0;
while(getline(obj, s))
{
switch(s[0])
{
case('v'):
{
switch(s[1])
{
case(' '):
{
all_ver_num++;
break;
}
case('n'):
{
all_nor_num++;
break;
}
default:
break;
}
break;
}
case('f'):
{
tri_num[group_num]++;
break;
}
case('g'):
{
group_num++;
break;
}
default:
break;
}
}
ver = new float[all_ver_num * 3 + 3];
nor = new float[all_nor_num * 3 + 3];
ver_num = all_ver_num;
nor_num = all_nor_num;
group_name = new string[group_num];
material = new GL_model_material[group_num];
group = new GL_model_group[group_num];
for(int c = 0; c < group_num; ++c)
{
group[c].triangle_num = tri_num[c + 1];
group[c].triangle = new GL_model_triangle[tri_num[c + 1]];
}
obj.close();
ifstream robj(fil, ios::in);
int all_ver_pos = 1, all_nor_pos = 1;
int pos_group = -1;
int pos_triangle = 0;
while(getline(robj, s))
{
switch(s[0])
{
case('v'):
{
switch(s[1])
{
case(' '):
{
stringstream ss(s);
ss >> s >> ver[3 * all_ver_pos] >> ver[3 * all_ver_pos + 1] >> ver[3 * all_ver_pos + 2];
all_ver_pos++;
break;
}
case('n'):
{
stringstream ss(s);
ss >> s >> nor[3 * all_nor_pos] >> nor[3 * all_nor_pos + 1] >> nor[3 * all_nor_pos + 2];
all_nor_pos++;
break;
}
default:
break;
}
break;
}
case('f'):
{
stringstream ss(s);
char ch;
int vn, nn;
ss >> s;
for(int cv = 0; cv < 3; ++cv)
{
ss >> vn >> ch >> nn >> ch >> nn;
group[pos_group].triangle[pos_triangle].ver_pos[cv] = vn;
group[pos_group].triangle[pos_triangle].ver_nor[cv] = nn;
}
pos_triangle++;
break;
}
case('g'):
{
pos_group++;
stringstream ss(s);
while(ss >> group_name[pos_group])
;
pos_triangle = 0;
break;
}
default:
break;
}
}
}
