void ShaftsDriveline4WD::Create(const rapidjson::Document& d) {
// Read top-level data.
assert(d.HasMember("Type"));
assert(d.HasMember("Template"));
assert(d.HasMember("Name"));
SetName(d["Name"].GetString());
// Get shaft directions.
assert(d.HasMember("Shaft Direction"));
SetMotorBlockDirection(loadVector(d["Shaft Direction"]["Motor Block"]));
SetAxleDirection(loadVector(d["Shaft Direction"]["Axle"]));
// Read shaft inertias.
assert(d.HasMember("Shaft Inertia"));
m_driveshaft_inertia = d["Shaft Inertia"]["Driveshaft"].GetDouble();
m_frontshaft_inertia = d["Shaft Inertia"]["Front Driveshaft"].GetDouble();
m_rearshaft_inertia = d["Shaft Inertia"]["Rear Driveshaft"].GetDouble();
m_central_differentialbox_inertia = d["Shaft Inertia"]["Central Differential Box"].GetDouble();
m_front_differentialbox_inertia = d["Shaft Inertia"]["Front Differential Box"].GetDouble();
m_rear_differentialbox_inertia = d["Shaft Inertia"]["Rear Differential Box"].GetDouble();
// Read gear ratios.
assert(d.HasMember("Gear Ratio"));
m_front_conicalgear_ratio = d["Gear Ratio"]["Front Conical Gear"].GetDouble();
m_rear_conicalgear_ratio = d["Gear Ratio"]["Rear Conical Gear"].GetDouble();
m_central_differential_ratio = d["Gear Ratio"]["Central Differential"].GetDouble();
m_front_differential_ratio = d["Gear Ratio"]["Front Differential"].GetDouble();
m_rear_differential_ratio = d["Gear Ratio"]["Rear Differential"].GetDouble();
}
TEST(Gradient, DISABLED_testGradientColor)
{
std::ostringstream pathStream;
pathStream << AAM_TEST_DATA_PATH << "/object_pixels.bmp";
cv::Mat1b maskImage = cv::imread(pathStream.str(),
cv::IMREAD_GRAYSCALE);
EXPECT_FALSE(maskImage.empty());
pathStream.str(std::string());
pathStream << AAM_TEST_DATA_PATH << "/warped_image_color.bmp";
aam::ColorMatrix warpedImage = cv::imread(pathStream.str());
EXPECT_FALSE(warpedImage.empty());
aam::RealMatrix targetDi, targetDj;
pathStream.str(std::string());
pathStream << AAM_TEST_DATA_PATH << "/di_grad.raw";
EXPECT_TRUE(loadVector(pathStream.str(), 255, 255, targetDi));
pathStream.str(std::string());
pathStream << AAM_TEST_DATA_PATH << "/dj_grad.raw";
EXPECT_TRUE(loadVector(pathStream.str(), 255, 255, targetDj));
warpedImage /= 255.0;
aam::ColorMatrix di, dj;
aam::CommonFunctions::gradient2D(warpedImage, maskImage,
di, dj);
EXPECT_EQ(di.size, targetDi.size);
EXPECT_EQ(cv::countNonZero(cv::abs(di - targetDi) > 1e-8), 0);
EXPECT_EQ(dj.size, targetDj.size);
EXPECT_EQ(cv::countNonZero(cv::abs(dj - targetDj) > 1e-8), 0);
}
std::vector<CPfTeamPlayerContracts*>* CPfTeamPlayerContractsDAOSQLite::findByXFkTeam(const std::string &XFkTeam, const std::string ×tamp)
{
std::string sql("SELECT * FROM PF_TEAM_PLAYER_CONTRACTS WHERE ");
sql = sql+"X_FK_TEAM='"+XFkTeam+"'";
sql = sql+" AND D_BEGIN<='" + timestamp + "' AND (D_END IS NULL OR D_END>'" + timestamp + "')";
return loadVector(sql);
}
bool ParticleComponentLoader::loadInit(const TiXmlElement& initElement, ParticleComponentDefinitionProto& proto)
{
const TiXmlElement* pXmlElement = initElement.FirstChildElement("size");
if ( pXmlElement != NULL )
{
proto.initSize = loadValue(*pXmlElement, "value");
proto.initSizeRange = loadValueRange(*pXmlElement, "range");
}
pXmlElement = initElement.FirstChildElement("lifetime");
if ( pXmlElement != NULL )
{
proto.initLifeTime = loadValue(*pXmlElement, "value");
proto.initLifeTimeRange = loadValueRange(*pXmlElement, "range");
}
pXmlElement = initElement.FirstChildElement("velocity");
if ( pXmlElement != NULL )
{
proto.initVelocity = loadVector(*pXmlElement, "value");
proto.initVelocityRange = loadVectorRange(*pXmlElement, "range");
}
return true;
}
//------------------------------------------------------------------------------
// setVBreakpoints5() -- For Table5
//------------------------------------------------------------------------------
bool Table5::setVBreakpoints5(const List* const swb5obj)
{
if (swb5obj != nullptr) {
loadVector(*swb5obj, &vtable, &nv);
valid = isValid();
}
return true;
}
//------------------------------------------------------------------------------
// setXBreakpoints1() -- for Table1
//------------------------------------------------------------------------------
bool Table1::setXBreakpoints1(const List* const sxb1obj)
{
if (sxb1obj != nullptr) {
loadVector(*sxb1obj, &xtable, &nx);
valid = isValid();
}
return true;
}
//------------------------------------------------------------------------------
// setYBreakpoints2() -- for Table2
//------------------------------------------------------------------------------
bool Table2::setYBreakpoints2(const List* const syb2obj)
{
if (syb2obj != nullptr) {
loadVector(*syb2obj, &ytable, &ny);
valid = isValid();
}
return true;
}
//------------------------------------------------------------------------------
// setZBreakpoints3() -- for Table3
//------------------------------------------------------------------------------
bool Table3::setZBreakpoints3(const List* const szb3obj)
{
if (szb3obj != nullptr) {
loadVector(*szb3obj, &ztable, &nz);
valid = isValid();
}
return true;
}
//------------------------------------------------------------------------------
// setWBreakpoints4() -- For Table4
//------------------------------------------------------------------------------
bool Table4::setWBreakpoints4(const List* const swb4obj)
{
if (swb4obj != nullptr) {
loadVector(*swb4obj, &wtable, &nw);
valid = isValid();
}
return true;
}
std::vector<CPfTeams*>* CPfTeamsDAOSQLite::findTeamsByXCompetition(int XCompetition)
{
std::ostringstream stream;
stream << XCompetition;
std::string sql("SELECT * FROM PF_TEAMS WHERE X_TEAM IN ");
sql = sql + "(SELECT X_FK_TEAM FROM PF_REGISTERED_TEAMS WHERE X_FK_COMPETITION='"+stream.str()+"')";
sql = sql + " ORDER BY S_TEAM";
return loadVector(sql);
}
std::vector<CPfCompetitions*>* CPfCompetitionsDAOSQLite::findByXFkCountryAndXFKSeason(const std::string &XFkCountry, const std::string &XFKSeason)
{
std::string sql(
"SELECT DISTINCT CO.* "
"FROM PF_COMPETITIONS CO "
" JOIN PF_COMPETITION_PHASES CP ON CP.X_FK_COMPETITION=CO.X_COMPETITION "
" JOIN PF_COMPETITION_PHASES_BY_SEASON CPS ON CPS.X_FK_COMPETITION_PHASE=CP.X_COMPETITION_PHASE ");
sql += "WHERE CO.X_FK_COUNTRY='"+XFkCountry+"' AND CPS.X_FK_SEASON='"+XFKSeason+"' ";
return loadVector(sql);
}
int main(int argc, char **argv)
{
initRobot();
loadVector();
//print something from vector to check it was read correctly
//[timeInst][RX][Data 0-8: Rx X Y Sp Dir ObstN ObstW ObstE ObstS]
// printf("Check timeInst 1, R2 = %d\n", timeInstMatrix[40][1][0]);
return scheduler();
}
std::vector<CPfTeamPlayers*>* CPfTeamPlayersDAOSQLite::findActiveByXFkTeam(const std::string &XFkTeam)
{
std::string sql("SELECT TP.* "
"FROM PF_TEAM_PLAYERS TP "
" JOIN PF_TEAM_PLAYER_CONTRACTS TPC ON TPC.X_FK_TEAM_PLAYER=TP.X_TEAM_PLAYER "
" JOIN PF_TEAMS T ON T.X_TEAM=TPC.X_FK_TEAM ");
sql += "WHERE X_TEAM='"+XFkTeam+"' "
" AND D_BEGIN<=CURRENT_TIMESTAMP "
" AND (D_END IS NULL OR D_END>CURRENT_TIMESTAMP)";
return loadVector(sql);
}
int main(int argc, char *argv[])
{
time_t now = time(0);
printf("chisq p = 0.05 cutoff = %f",chidist(3.84, 1.0));
printf("Start analysis at %s \n", ctime(&now));
/*
Matrix a(2,2);
a[0][0] = 1.0;
a[1][1] = 1.0;
a[0][1] = a[1][0] = 0.5;
SVD svd;
svd.InvertInPlace(a);
for (int i = 0; i < a.rows; i ++) {
for (int j = 0; j < a.cols; j ++) {
std::cout << "a[" << i << "]" << "[" << j << "]" << a[i][j] << "\t";
}
std::cout << "\n";
}
return 0;
*/
Matrix X;
String Xinput = "ExampleX.test";
Vector Y;
String Yinput = "ExampleY.test";
if (loadMatrix(X,Xinput) || loadVector(Y, Yinput)) {
fprintf(stderr, "Data loading problem!\n");
exit(1);
}
LogisticRegression lr;
if (lr.FitLogisticModel(X, Y, 30) ) {
printf("fit all right!\n");
} else {
printf("fit failed\n");
}
now = time(0);
printf("Finsihed analysis at %s \n", ctime(&now));
LogisticRegressionScoreTest lrst;
int Xcol = 1;
lrst.FitLogisticModel(X,Y,Xcol,30);
printf("score p-value is: %lf \n", lrst.getPvalue());
Vector& pvalue = lr.GetAsyPvalue();
printf("wald p-value is: %lf \n", pvalue[Xcol]);
return 0;
}
PetscErrorCode loadInputs(Mat * A, Vec * b, Vec * x){
PetscErrorCode ierr;
PetscInt sizex,sizey;
char bfile[]="-bfile";
char xfile[]="-xfile";
//load data files
ierr=loadMatrix(A);CHKERRQ(ierr);
ierr=loadVector(bfile,b);CHKERRQ(ierr);
if(*b==NULL) {
PetscPrintf(PETSC_COMM_WORLD,"]> Creating vector b\n");
ierr=MatGetSize(*A,&sizex,&sizey);CHKERRQ(ierr);
ierr=generateVectorRandom(sizex,b);CHKERRQ(ierr);
}
ierr=loadVector(xfile,x);CHKERRQ(ierr);
if(*x==NULL) {
PetscPrintf(PETSC_COMM_WORLD,"]> Creating vector x\n");
ierr=MatGetSize(*A,&sizex,&sizey);CHKERRQ(ierr);
ierr=generateVectorRandom(sizex,x);CHKERRQ(ierr);
}
return 0;
}
DirectionalLight loadDirectionalLight(
const Scene& scene,
const tinyxml2::XMLElement& elt) {
auto pExitantPower = elt.FirstChildElement("ExitantPower");
if(pExitantPower) {
Vec3f wi(0, 1, 0);
getChildAttribute(elt, "IncidentDirection", wi);
Vec3f exitantPower = zero<Vec3f>();
getChildAttribute(elt, "ExitantPower", exitantPower);
return DirectionalLight(wi, exitantPower, scene);
}
return { normalize(loadVector(elt)), loadColor(elt) };
}
std::vector<CPfCoachContracts*>* CPfCoachContractsDAOSQLite::findByXFkCoachAndXSeason(const std::string &XFkCoach, const std::string &XSeason)
{
std::string sql("SELECT * FROM PF_COACH_CONTRACTS WHERE ");
sql = sql+" X_FK_COACH='"+XFkCoach+"'";
sql = sql+" AND D_BEGIN <= (SELECT MAX(D_END_COMPETITION_PHASE) ";
sql = sql+ "FROM PF_COMPETITION_PHASES_BY_SEASON CS ";
sql = sql+ "JOIN PF_SEASONS S ON S.X_SEASON = CS.X_FK_SEASON ";
sql = sql+ "WHERE S.X_SEASON = "+XSeason+")";
sql = sql+" AND (D_END >= (SELECT MIN(D_BEGIN_COMPETITION_PHASE) ";
sql = sql+ "FROM PF_COMPETITION_PHASES_BY_SEASON CS ";
sql = sql+ "JOIN PF_SEASONS S ON S.X_SEASON = CS.X_FK_SEASON ";
sql = sql+ "WHERE S.X_SEASON = "+XSeason+")";
sql = sql+" OR D_END IS NULL) ";
return loadVector(sql);
}
void DoubleRoller::Create(const rapidjson::Document& d) {
// Read top-level data
assert(d.HasMember("Type"));
assert(d.HasMember("Template"));
assert(d.HasMember("Name"));
SetName(d["Name"].GetString());
// Read wheel geometry and mass properties
assert(d.HasMember("Roller"));
m_roller_radius = d["Roller"]["Radius"].GetDouble();
m_roller_width = d["Roller"]["Width"].GetDouble();
m_roller_gap = d["Roller"]["Gap"].GetDouble();
m_roller_mass = d["Roller"]["Mass"].GetDouble();
m_roller_inertia = loadVector(d["Roller"]["Inertia"]);
// Read contact material data
assert(d.HasMember("Contact Material"));
float mu = d["Contact Material"]["Coefficient of Friction"].GetFloat();
float cr = d["Contact Material"]["Coefficient of Restitution"].GetFloat();
SetContactFrictionCoefficient(mu);
SetContactRestitutionCoefficient(cr);
if (d["Contact Material"].HasMember("Properties")) {
float ym = d["Contact Material"]["Properties"]["Young Modulus"].GetFloat();
float pr = d["Contact Material"]["Properties"]["Poisson Ratio"].GetFloat();
SetContactMaterialProperties(ym, pr);
}
if (d["Contact Material"].HasMember("Coefficients")) {
float kn = d["Contact Material"]["Coefficients"]["Normal Stiffness"].GetFloat();
float gn = d["Contact Material"]["Coefficients"]["Normal Damping"].GetFloat();
float kt = d["Contact Material"]["Coefficients"]["Tangential Stiffness"].GetFloat();
float gt = d["Contact Material"]["Coefficients"]["Tangential Damping"].GetFloat();
SetContactMaterialCoefficients(kn, gn, kt, gt);
}
// Read wheel visualization
if (d.HasMember("Visualization")) {
assert(d["Visualization"].HasMember("Mesh Filename"));
assert(d["Visualization"].HasMember("Mesh Name"));
m_meshFile = d["Visualization"]["Mesh Filename"].GetString();
m_meshName = d["Visualization"]["Mesh Name"].GetString();
m_has_mesh = true;
}
}
void StaticShader::loadLights(std::vector<LightPtr> lights) {
for (int i = 0; i < number_of_lights; i++) {
if (i < lights.size()) {
loadVector(this->lightPosition[i], lights[i]->position);
loadVector(this->lightColor[i], lights[i]->color);
loadVector(this->attenuation[i], lights[i]->attenuation);
} else {
loadVector(this->lightPosition[i], glm::vec3(0.0f));
loadVector(this->lightColor[i], glm::vec3(0.0f));
loadVector(this->attenuation[i], glm::vec3(1.0f, 0.0f, 0.0f));
}
}
}
std::vector<CPfTeamPlayerContracts*>* CPfTeamPlayerContractsDAOSQLite::findByXFkTeamPlayer(const std::string &XFkTeamPlayer)
{
std::string sql("SELECT * FROM PF_TEAM_PLAYER_CONTRACTS WHERE ");
sql = sql+"X_FK_TEAM_PLAYER='"+XFkTeamPlayer+"'";
return loadVector(sql);
}
void testTrainICAAMGray()
{
std::cout << "trainICTest testTrainICAAMGray" << std::endl;
aam::AppearanceDataIC model;
aam::TrainModelLoader loader;
loader.useGrayImages(true);
for (int i = 0; i < TRIANGLES_COUNT; i++)
{
model.triangles.push_back(cv::Vec3i(trianglesData[i * 3],
trianglesData[i * 3 + 1], trianglesData[i * 3 + 2]));
}
try
{
std::vector<std::string> fileNames =
boost::assign::list_of<std::string>
("107_0764.bmp") /*("107_0766.bmp")*/ ("107_0779.bmp")
("107_0780.bmp") ("107_0781.bmp") ("107_0782.bmp")
("107_0783.bmp") ("107_0784.bmp") ("107_0785.bmp")
("107_0786.bmp") ("107_0787.bmp") ("107_0788.bmp")
("107_0789.bmp") ("107_0790.bmp") ("107_0791.bmp")
("107_0792.bmp") ("107_0793.bmp") ("107_0794.bmp")
("107_0795.bmp") ("107_0798.bmp") ("107_0799.bmp")
("107_0800.bmp") ("108_0801.bmp") ("108_0802.bmp")
("108_0803.bmp") ("108_0804.bmp");
for (int i = 0; i < fileNames.size(); i++)
{
std::ostringstream stream;
stream << "data/cootes/" << fileNames[i] << ".mat.dat";
std::string markupFile = stream.str();
stream.str(std::string());
stream << "data/cootes/" << fileNames[i];
std::string imageFile = stream.str();
loader.load(markupFile, imageFile);
}
std::vector<aam::TrainModelInfo> trainData = loader.getModels();
aam::AAMFunctions2D::trainModelIC(0.95, trainData, model);
if (!boost::filesystem::exists("output"))
{
boost::filesystem::create_directory("output");
}
cv::FileStorage storage("output/aam_ic_test.xml",
cv::FileStorage::WRITE);
storage << "R" << model.R;
storage << "s" << model.s;
storage << "s_star" << model.sStar;
storage << "s0" << model.s0;
storage << "A0" << model.A0;
storage << "mask" << model.mask;
storage << "triangles" << model.triangles;
cv::Mat1i tmp(2, 1);
tmp(0, 0) = model.textureSize.width;
tmp(1, 0) = model.textureSize.height;
storage << "texture_size" << tmp;
storage.release();
aam::RealMatrix targetR;
if (!loadVector("data/aam_r_vectors.raw", model.nPixels, 20,
targetR))
{
std::cout << "%TEST_FAILED% time=0 testname=testTrainICAAMGray (trainICTest) message=Can't reference R matrix" << std::endl;
return;
}
aam::RealMatrix targetA;
if (!loadVector("data/aam_a_vectors.raw", model.nPixels, 22,
targetA))
{
std::cout << "%TEST_FAILED% time=0 testname=testTrainICAAMGray (trainICTest) message=Can't reference A matrix" << std::endl;
return;
}
cv::Mat m, s;
cv::meanStdDev(model.A, m, s);
std::cout << m << std::endl;
std::cout << s << std::endl;
cv::meanStdDev(targetA, m, s);
std::cout << m << std::endl;
std::cout << s << std::endl;
aam::RealMatrix Rsum, Rsum2;
cv::reduce(model.R.t(), Rsum, 1, CV_REDUCE_SUM);
cv::reduce(targetR, Rsum2, 1, CV_REDUCE_SUM);
cv::Mat img, img2;
aam::AAMFunctions2D::vector2Appearance(Rsum,
model.mask,
model.textureSize, img);
aam::AAMFunctions2D::vector2Appearance(Rsum2,
model.mask,
model.textureSize, img2);
cv::normalize(img2, img, 1, 0, cv::NORM_MINMAX);
cv::imshow("test", img);
cv::waitKey(0);
}
catch (std::exception& e)
{
std::cout << "%TEST_FAILED% time=0 testname=testTrainICAAMGray (trainICTest) message=Exception occured: " <<
e.what() << std::endl;
}
}
void StaticShader::loadSkyColor(glm::vec3 skyColor) {
loadVector(this->skyColor, skyColor);
}
std::vector<CPfTeams*>* CPfTeamsDAOSQLite::findTeams()
{
std::string sql("SELECT * FROM PF_TEAMS");
return loadVector(sql);
}
// -----------------------------------------------------------------------------
// Worker function for creating a DoubleWishboneReduced suspension using data in
// the specified RapidJSON document.
// -----------------------------------------------------------------------------
void DoubleWishboneReduced::Create(const rapidjson::Document& d) {
// Read top-level data
assert(d.HasMember("Type"));
assert(d.HasMember("Template"));
assert(d.HasMember("Name"));
SetName(d["Name"].GetString());
// Read Spindle data
assert(d.HasMember("Spindle"));
assert(d["Spindle"].IsObject());
m_spindleMass = d["Spindle"]["Mass"].GetDouble();
m_points[SPINDLE] = loadVector(d["Spindle"]["COM"]);
m_spindleInertia = loadVector(d["Spindle"]["Inertia"]);
m_spindleRadius = d["Spindle"]["Radius"].GetDouble();
m_spindleWidth = d["Spindle"]["Width"].GetDouble();
// Read Upright data
assert(d.HasMember("Upright"));
assert(d["Upright"].IsObject());
m_uprightMass = d["Upright"]["Mass"].GetDouble();
m_points[UPRIGHT] = loadVector(d["Upright"]["COM"]);
m_uprightInertia = loadVector(d["Upright"]["Inertia"]);
m_uprightRadius = d["Upright"]["Radius"].GetDouble();
// Read UCA data
assert(d.HasMember("Upper Control Arm"));
assert(d["Upper Control Arm"].IsObject());
m_points[UCA_F] = loadVector(d["Upper Control Arm"]["Location Chassis Front"]);
m_points[UCA_B] = loadVector(d["Upper Control Arm"]["Location Chassis Back"]);
m_points[UCA_U] = loadVector(d["Upper Control Arm"]["Location Upright"]);
// Read LCA data
assert(d.HasMember("Lower Control Arm"));
assert(d["Lower Control Arm"].IsObject());
m_points[LCA_F] = loadVector(d["Lower Control Arm"]["Location Chassis Front"]);
m_points[LCA_B] = loadVector(d["Lower Control Arm"]["Location Chassis Back"]);
m_points[LCA_U] = loadVector(d["Lower Control Arm"]["Location Upright"]);
// Read Tierod data
assert(d.HasMember("Tierod"));
assert(d["Tierod"].IsObject());
m_points[TIEROD_C] = loadVector(d["Tierod"]["Location Chassis"]);
m_points[TIEROD_U] = loadVector(d["Tierod"]["Location Upright"]);
// Read spring-damper data and create force callback
assert(d.HasMember("Shock"));
assert(d["Shock"].IsObject());
m_points[SHOCK_C] = loadVector(d["Shock"]["Location Chassis"]);
m_points[SHOCK_U] = loadVector(d["Shock"]["Location Upright"]);
m_springRestLength = d["Shock"]["Free Length"].GetDouble();
m_shockForceCB = new LinearSpringDamperForce(d["Shock"]["Spring Coefficient"].GetDouble(),
d["Shock"]["Damping Coefficient"].GetDouble());
// Read axle inertia
assert(d.HasMember("Axle"));
assert(d["Axle"].IsObject());
m_axleInertia = d["Axle"]["Inertia"].GetDouble();
}
// -----------------------------------------------------------------------------
// Worker function for creating a DoubleWishbone suspension using data in the
// specified RapidJSON document.
// -----------------------------------------------------------------------------
void DoubleWishbone::Create(const rapidjson::Document& d) {
// Read top-level data
assert(d.HasMember("Type"));
assert(d.HasMember("Template"));
assert(d.HasMember("Name"));
SetName(d["Name"].GetString());
// Read flag indicating that inertia matrices are expressed in
// vehicle-aligned centroidal frame.
if (d.HasMember("Vehicle-Frame Inertia")) {
bool flag = d["Vehicle-Frame Inertia"].GetBool();
SetVehicleFrameInertiaFlag(flag);
}
// Read Spindle data
assert(d.HasMember("Spindle"));
assert(d["Spindle"].IsObject());
m_spindleMass = d["Spindle"]["Mass"].GetDouble();
m_points[SPINDLE] = loadVector(d["Spindle"]["COM"]);
m_spindleInertia = loadVector(d["Spindle"]["Inertia"]);
m_spindleRadius = d["Spindle"]["Radius"].GetDouble();
m_spindleWidth = d["Spindle"]["Width"].GetDouble();
// Read Upright data
assert(d.HasMember("Upright"));
assert(d["Upright"].IsObject());
m_uprightMass = d["Upright"]["Mass"].GetDouble();
m_points[UPRIGHT] = loadVector(d["Upright"]["COM"]);
m_uprightInertiaMoments = loadVector(d["Upright"]["Moments of Inertia"]);
m_uprightInertiaProducts = loadVector(d["Upright"]["Products of Inertia"]);
m_uprightRadius = d["Upright"]["Radius"].GetDouble();
// Read UCA data
assert(d.HasMember("Upper Control Arm"));
assert(d["Upper Control Arm"].IsObject());
m_UCAMass = d["Upper Control Arm"]["Mass"].GetDouble();
m_points[UCA_CM] = loadVector(d["Upper Control Arm"]["COM"]);
m_UCAInertiaMoments = loadVector(d["Upper Control Arm"]["Moments of Inertia"]);
m_UCAInertiaProducts = loadVector(d["Upper Control Arm"]["Products of Inertia"]);
m_UCARadius = d["Upper Control Arm"]["Radius"].GetDouble();
m_points[UCA_F] = loadVector(d["Upper Control Arm"]["Location Chassis Front"]);
m_points[UCA_B] = loadVector(d["Upper Control Arm"]["Location Chassis Back"]);
m_points[UCA_U] = loadVector(d["Upper Control Arm"]["Location Upright"]);
// Read LCA data
assert(d.HasMember("Lower Control Arm"));
assert(d["Lower Control Arm"].IsObject());
m_LCAMass = d["Lower Control Arm"]["Mass"].GetDouble();
m_points[LCA_CM] = loadVector(d["Lower Control Arm"]["COM"]);
m_LCAInertiaMoments = loadVector(d["Lower Control Arm"]["Moments of Inertia"]);
m_LCAInertiaProducts = loadVector(d["Lower Control Arm"]["Products of Inertia"]);
m_LCARadius = d["Lower Control Arm"]["Radius"].GetDouble();
m_points[LCA_F] = loadVector(d["Lower Control Arm"]["Location Chassis Front"]);
m_points[LCA_B] = loadVector(d["Lower Control Arm"]["Location Chassis Back"]);
m_points[LCA_U] = loadVector(d["Lower Control Arm"]["Location Upright"]);
// Read Tierod data
assert(d.HasMember("Tierod"));
assert(d["Tierod"].IsObject());
m_points[TIEROD_C] = loadVector(d["Tierod"]["Location Chassis"]);
m_points[TIEROD_U] = loadVector(d["Tierod"]["Location Upright"]);
// Read spring data and create force callback
assert(d.HasMember("Spring"));
assert(d["Spring"].IsObject());
m_points[SPRING_C] = loadVector(d["Spring"]["Location Chassis"]);
m_points[SPRING_A] = loadVector(d["Spring"]["Location Arm"]);
m_springRestLength = d["Spring"]["Free Length"].GetDouble();
if (d["Spring"].HasMember("Spring Coefficient")) {
m_springForceCB = new LinearSpringForce(d["Spring"]["Spring Coefficient"].GetDouble());
} else if (d["Spring"].HasMember("Curve Data")) {
int num_points = d["Spring"]["Curve Data"].Size();
MapSpringForce* springForceCB = new MapSpringForce();
for (int i = 0; i < num_points; i++) {
springForceCB->add_point(d["Spring"]["Curve Data"][i][0u].GetDouble(),
d["Spring"]["Curve Data"][i][1u].GetDouble());
}
m_springForceCB = springForceCB;
}
// Read shock data and create force callback
assert(d.HasMember("Shock"));
assert(d["Shock"].IsObject());
m_points[SHOCK_C] = loadVector(d["Shock"]["Location Chassis"]);
m_points[SHOCK_A] = loadVector(d["Shock"]["Location Arm"]);
if (d["Shock"].HasMember("Damping Coefficient")) {
m_shockForceCB = new LinearDamperForce(d["Shock"]["Damping Coefficient"].GetDouble());
} else if (d["Shock"].HasMember("Curve Data")) {
int num_points = d["Shock"]["Curve Data"].Size();
MapDamperForce* shockForceCB = new MapDamperForce();
for (int i = 0; i < num_points; i++) {
shockForceCB->add_point(d["Shock"]["Curve Data"][i][0u].GetDouble(),
d["Shock"]["Curve Data"][i][1u].GetDouble());
}
m_shockForceCB = shockForceCB;
}
// Read axle inertia
assert(d.HasMember("Axle"));
assert(d["Axle"].IsObject());
m_axleInertia = d["Axle"]["Inertia"].GetDouble();
}
std::vector<CPfSeasons*>* CPfSeasonsDAOSQLite::findAll()
{
std::string sql("SELECT * FROM PF_SEASONS ORDER BY N_YEAR ASC");
return loadVector(sql);
}
int main(int argc, char **argv) {
/*
**Primeiro Teste
** Alocando dinamicamente e mostrando as distancias.
**Liberando memória depois
*/
/*
Point *a;
Point *b;
a = cria(3.0, 0.0);
b = cria(0.0, 0.0);;
double distancia;
printf("\nPonto A: \n");
showPoint(a);
printf("\nPonto B: \n");
showPoint(b);
distancia = calculaDistanciaEntrePontos(a, b);
printf("\n\n\nDistância entre os pontos é de: %.2f\n\n\n", distancia);
free(a);
free(b);
*/
/*
**Segundo teste.
**Puxando todos os pontos do arquivo para a memória e mostrando todos.
*/
int numeroDeBytes;
int dimensaoDoVetor;
Point *vetorDePontos;
numeroDeBytes = identificaNumeroDeBytesDeArquivo("points01.bin");
printf("O vetor do arquivo possui %d bytes /n/n/n", numeroDeBytes);
dimensaoDoVetor = numeroDeBytes/sizeof(Point);
printf("\nLogo a dimensão é de: %d pontos \n", dimensaoDoVetor);
//Faço uma alocação dinâmica para a quantidade de vetorres que quero.
vetorDePontos = (Point *)calloc(dimensaoDoVetor, sizeof(Point));
if(vetorDePontos == NULL){
exit(1);
}
if(!loadVector("points01.bin", vetorDePontos, dimensaoDoVetor)){
printf("AAAAAAA que pena. ");
exit(1);
}
showVector(vetorDePontos, dimensaoDoVetor);
/*
**Terceiro teste
** O ponto mais distante da origem.
*/
/*
int numeroDeBytes;
int dimensaoDoVetor;
Point *vetorDePontos;
Point *maisDistante;
numeroDeBytes = identificaNumeroDeBytesDeArquivo("points01.bin");
printf("O vetor do arquivo possui %d bytes /n/n/n", numeroDeBytes);
dimensaoDoVetor = numeroDeBytes/sizeof(Point);
printf("\nLogo a dimensão é de: %d pontos \n", dimensaoDoVetor);
//Faço uma alocação dinâmica para a quantidade de vetorres que quero.
vetorDePontos = (Point *)calloc(dimensaoDoVetor, sizeof(Point));
if(vetorDePontos == NULL){
exit(1);
}
if(!loadVector("points01.bin", vetorDePontos, dimensaoDoVetor)){
printf("AAAAAAA que pena. ");
exit(1);
}
maisDistante = retornaEnderecoDoMaisDistanteDaOrigem(vetorDePontos, dimensaoDoVetor);
printf("O mais distante da origem é o seguinte ponto: ");
showPoint(maisDistante);
*/
return 0;
}
void SkyboxShader::loadFogColor(glm::vec3 color) {
loadVector(this->fogColor, color);
}
std::vector<CPfGames*>* CPfGamesDAOSQLite::findByXFkUserAndSGameType(const std::string &XFkUser, const std::string &SGameType)
{
std::string sql("SELECT * FROM PF_GAMES WHERE ");
sql = sql+"X_FK_USER='******' AND S_GAME_TYPE='"+SGameType+"' ORDER BY D_LAST_SAVED DESC";
return loadVector(sql);
}
std::vector<CPfGames*>* CPfGamesDAOSQLite::findBySGameType(const std::string &SGameType)
{
std::string sql("SELECT * FROM PF_GAMES WHERE ");
sql = sql+"S_GAME_TYPE='"+SGameType+"'";
return loadVector(sql);
}
