int ConfigurationParserTest::checkDoublesChoice( const ConfigurationChoice *doublesChoice ){ int retval = 0; const ConfigurationValue *doublesValue = 0; const VectorConfigurationValue *doublesVectorValue = 0; const vector<const ConfigurationValue *> *values = 0; CHECK( doublesChoice != 0 ); doublesValue = doublesChoice->getConfigurationValue(); CHECK( doublesValue != 0 ); doublesVectorValue = dynamic_cast<const VectorConfigurationValue *>(doublesValue); CHECK( doublesVectorValue != 0 ); values = doublesVectorValue->getVectorValue(); CHECK( values != 0 ); CHECK( values->size() == 2 ); CHECK( closeEnough( (*values)[0]->getDoubleValue(), 2.71 ) ); CHECK( closeEnough( (*values)[1]->getDoubleValue(), -2.17 ) ); end: return retval; }
bool ConicalViewFrustum::isVerySimilar(const ConicalViewFrustum& other) const { const float MIN_POSITION_SLOP_SQUARED = 25.0f; // 5 meters squared const float MIN_ANGLE_BETWEEN = 0.174533f; // radian angle between 2 vectors 10 degrees apart const float MIN_RELATIVE_ERROR = 0.01f; // 1% return glm::distance2(_position, other._position) < MIN_POSITION_SLOP_SQUARED && angleBetween(_direction, other._direction) < MIN_ANGLE_BETWEEN && closeEnough(_angle, other._angle, MIN_RELATIVE_ERROR) && closeEnough(_farClip, other._farClip, MIN_RELATIVE_ERROR) && closeEnough(_radius, other._radius, MIN_RELATIVE_ERROR); }
void OrientationMath::MatToEuler(float g[3][3], float &phi1, float &Phi, float &phi2) { if(closeEnough(g[2][2], 1.0) || closeEnough(g[2][2], -1.0)) { phi1 = atan(g[0][1]/g[0][0]) / 2.0f; Phi = 0.0; phi2 = phi1; } else { Phi = acos(g[2][2]); double s = sin(Phi); phi1 = atan2(g[2][0] / s, -g[2][1] / s ); phi2 = atan2(g[0][2] / s, g[1][2] / s ); } }
void paralellWall() { int rearSensor = SensorValue[S4] -2; bool aligned = false; while (!aligned) { rearSensor = SensorValue[S4] -2; nxtDisplayTextLine(3, "s4: %d s3:%d", rearSensor, SensorValue[S3]); if (closeEnough(rearSensor, SensorValue[S3])) { //Already close enough, we're done. aligned = true; } else if (SensorValue[S3] > rearSensor) { //Front of robot is futher from the wall then back, small turn. turnTime(25, "left", 150); wait1Msec(100); } else if (SensorValue[S3] < rearSensor) { //Back of robot is further, small turn. turnTime(25, "right", 150); wait1Msec(100); } else { //Odd situation, no matches of the case list. Exit.; aligned = true; } //next part, moving walk. } }
//////////////////////////////////////////////////////////////////////////////// // Locate task by uuid, which may be a partial UUID. bool TF2::get (const std::string& uuid, Task& task) { if (! _loaded_tasks) load_tasks (); if (_tasks_map.size () > 0 && uuid.size () == 36) { // Fast lookup, same result as below. Only used during "task import". auto i = _tasks_map.find (uuid); if (i != _tasks_map.end ()) { task = i->second; return true; } } else { // Slow lookup, same result as above. for (auto& i : _tasks) { if (closeEnough (i.get ("uuid"), uuid, uuid.length ())) { task = i; return true; } } } return false; }
int Origami::getClosestVertexAlongDirection(dvec2 pt, double angle) const { dvec2 o = pt; dvec2 dir = dvec2(cos(angle), sin(angle)); double bestT = 4; int ret = -1; for (size_t i = 0; i < verts.size(); ++i) { vertex v = verts[i]; dvec2 VrelO = v.pt - o; double t = dot(VrelO, dir); dvec2 closestOnLine = o + dir * t; if (t < epsilon) continue; if (closeEnough(closestOnLine, v.pt)) { if (bestT > t) { bestT = t; ret = i; } } } return ret; }
int Origami::getClosestVertexAlongDirection(dvec2 pt, double angle, vector<int>& path) const { dvec2 o = pt; dvec2 dir = dvec2(cos(angle), sin(angle)); double bestT = 4; int ret = -1; for (size_t i = 0; i < path.size(); ++i) { vertex v = verts[path[i]]; dvec2 VrelO = v.pt - o; double t = dot(VrelO, dir); dvec2 closestOnLine = o + dir * t; if (t < epsilon) continue; if (closeEnough(closestOnLine, v.pt)) { if (bestT > t) { bestT = t; ret = i; } } } //ASSERT(false, "getClosestVertexAlongDirection didn't return anything"); return ret; }
void TestStatistics::testAll() { std::vector<double> data; data.push_back(20.48); data.push_back(20.32); data.push_back(20.57); data.push_back(19.73); _test( closeEnough(Statistics::sum(data), 81.1, 0.0001)); _test( closeEnough(Statistics::average(data), 20.275, 0.0001)); _test( closeEnough(Statistics::sumOfSquares(data,20.275), 0.4281, 0.0001)); std::cout << Statistics::sumOfSquares(data, 20.275) << std::endl; _test( closeEnough(Statistics::variance(data), 0.1427, 0.0001)); }
AtomList AtomList::neighborhood(Atomo *a) { AtomList al = AtomList(); for (int i = 0; i < _size; i++) { Atomo *b = &contents[i]; if (closeEnough(a, b)) al.add(*b); } return al; }
void Camera::updatePosition(const glm::vec3 &direction, float elapsedTimeSec) { // Moves the camera using Newton's second law of motion. Unit mass is // assumed here to somewhat simplify the calculations. The direction vector // is in the range [-1,1]. float length2 = glm::dot( m_currentVelocity,m_currentVelocity ); if ( length2 < 1e-10 ) { // Only move the camera if the velocity vector is not of zero length. // Doing this guards against the camera slowly creeping around due to // floating point rounding errors. glm::vec3 displacement = (m_currentVelocity * elapsedTimeSec) + (0.5f * m_acceleration * elapsedTimeSec * elapsedTimeSec); // Floating point rounding errors will slowly accumulate and cause the // camera to move along each axis. To prevent any unintended movement // the displacement vector is clamped to zero for each direction that // the camera isn't moving in. Note that the updateVelocity() method // will slowly decelerate the camera's velocity back to a stationary // state when the camera is no longer moving along that direction. To // account for this the camera's current velocity is also checked. if (direction.x == 0.0f && closeEnough(m_currentVelocity.x, 0.0f)) displacement.x = 0.0f; if (direction.y == 0.0f && closeEnough(m_currentVelocity.y, 0.0f)) displacement.y = 0.0f; if (direction.z == 0.0f && closeEnough(m_currentVelocity.z, 0.0f)) displacement.z = 0.0f; move( displacement.x, displacement.y, displacement.z ); } // Continuously update the camera's velocity vector even if the camera // hasn't moved during this call. When the camera is no longer being moved // the camera is decelerating back to its stationary state. updateVelocity(direction, elapsedTimeSec); }
std::array<float,3> eulerAngles(const double4x4& R) { //check for gimbal lock if (closeEnough(R[2][0], -1.0f) || closeEnough(R[2][0], 1.0f)) { float x, y; float z = 0; if (closeEnough(R[2][0], -1.0f)) { float d = atan2(R[0][1], R[0][2]); y = M_PI/2; x = d; } else { float d = atan2(-R[0][1], -R[0][2]); y = -M_PI/2; x = d; } return { x, y, z }; } else { //two solutions exist float y1 = -asin(R[2][0]); float y2 = M_PI - y1; float x1 = atan2(R[2][1] / cos(y1), R[2][2] / cos(y1)); float x2 = atan2(R[2][1] / cos(y2), R[2][2] / cos(y2)); float z1 = atan2(R[1][0] / cos(y1), R[0][0] / cos(y1)); float z2 = atan2(R[1][0] / cos(y2), R[0][0] / cos(y2)); //choose one solution to return //for example the "shortest" rotation if ((fabs(x1) + fabs(y1) + fabs(z1)) <= (fabs(x2) + fabs(y2) + fabs(z2))) { return { x1, y1, z1 }; } else { return { x2, y2, z2 }; } } }
std::string TransformMatrix::toString() { std::stringstream str; for (int x=0; x<4; x++) { for (int y=0; y<4; y++) { if (closeEnough(values[x][y], 0.0f)) { str << "0 "; } else { str << values[x][y] << " "; } } str << std::endl; } return str.str(); }
double getDistortionScaleForRadius(double rTarget) { double max = rTarget * 2; double min = 0; double distortionScale; while (true) { double rSource = ((max - min) / 2.0) + min; distortionScale = getUndistortionScaleForRadiusSquared(rSource * rSource); double rResult = distortionScale * rSource; if (closeEnough(rResult, rTarget)) { break; } if (rResult < rTarget) { min = rSource; } else { max = rSource; } } return 1.0 / distortionScale; }
void FrogShip::update(double deltaTime, PlayerShip* player, vector<Bullet*>& liveBullets) { GameObject::updateDebug(deltaTime); timeAlive += deltaTime; double percent = timeAlive / TIME_TO_CLIMAX; percent = 1 - cos(percent*XM_PIDIV2); double rt = 1 - percent; position = camera.screenToWorld(float(rt*rt)*startPos + 2 * float(rt*percent)*controlPoint + float(percent*percent)*climaxPos); if (percent > .25) { // start aiming at player Vector2 dirToPlayer = player->getCenter() - position; dirToPlayer.Normalize(); float angleToPlayer = atan2(dirToPlayer.y, dirToPlayer.x) + XM_PIDIV2; dirToPlayer = Vector2(cos(angleToPlayer), sin(angleToPlayer)); //dirToPlayer += Vector2(cos(XM_PIDIV2), sin(XM_PIDIV2)); Vector2 currentRot(cos(rotation), sin(rotation)); currentRot += (dirToPlayer - currentRot) * float(deltaTime * rotationSpeed); setRotation(atan2(currentRot.y, currentRot.x)); if (timeAlive >= TIME_TO_FIRE && closeEnough(dirToPlayer, currentRot)) { for (auto const& weapon : weaponSystems) { weapon->timeSinceFired += deltaTime; weapon->updatePosition(position); if (weapon->ready()) { weapon->fired = true; Bullet* bullet = weapon->launchBullet(player->getCenter()); liveBullets.push_back(bullet); } } } } if (position.y > camera.screenToWorld(Vector2(0, float(camera.viewportHeight + 120))).y) { reset(); } }
int UpdateBoard () { if (clients.size() > 0) { Client *it = NULL; for (int i=0;i<clients.size();i++) { if (clients[i]->it) { it = clients[i]; break; } } assert(it); for (int i=0;i<clients.size();i++) { if (clients[i] != it && closeEnough(clients[i], it)) { clients[i]->it = true; it->it = false; teleport(clients[i]); return 0; } } } return 0; }
int CmdColor::execute (std::string& output) { int rc = 0; #ifdef FEATURE_COLOR // Get the non-attribute, non-fancy command line arguments. bool legend = false; std::vector <std::string> words = context.a3.extract_words (); std::vector <std::string>::iterator word; for (word = words.begin (); word != words.end (); ++word) if (closeEnough ("legend", *word)) legend = true; std::stringstream out; if (context.color ()) { // If the description contains 'legend', show all the colors currently in // use. if (legend) { out << "\n" << STRING_CMD_COLOR_HERE << "\n"; ViewText view; view.width (context.getWidth ()); view.add (Column::factory ("string", STRING_CMD_COLOR_COLOR)); view.add (Column::factory ("string", STRING_CMD_COLOR_DEFINITION)); Config::const_iterator item; for (item = context.config.begin (); item != context.config.end (); ++item) { // Skip items with 'color' in their name, that are not referring to // actual colors. if (item->first != "_forcecolor" && item->first != "color" && item->first.find ("color") == 0) { Color color (context.config.get (item->first)); int row = view.addRow (); view.set (row, 0, item->first, color); view.set (row, 1, item->second, color); } } out << view.render () << "\n"; } // If there is something in the description, then assume that is a color, // and display it as a sample. else if (words.size ()) { Color one ("black on bright yellow"); Color two ("underline cyan on bright blue"); Color three ("color214 on color202"); Color four ("rgb150 on rgb020"); Color five ("underline grey10 on grey3"); Color six ("red on color173"); std::string swatch; for (word = words.begin (); word != words.end (); ++word) { if (word != words.begin ()) swatch += " "; swatch += *word; } Color sample (swatch); out << "\n" << STRING_CMD_COLOR_EXPLANATION << "\n" << "\n\n" << STRING_CMD_COLOR_16 << "\n" << " " << one.colorize ("task color black on bright yellow") << "\n" << " " << two.colorize ("task color underline cyan on bright blue") << "\n" << "\n" << STRING_CMD_COLOR_256 << "\n" << " " << three.colorize ("task color color214 on color202") << "\n" << " " << four.colorize ("task color rgb150 on rgb020") << "\n" << " " << five.colorize ("task color underline grey10 on grey3") << "\n" << " " << six.colorize ("task color red on color173") << "\n" << "\n" << STRING_CMD_COLOR_YOURS << "\n\n" << " " << sample.colorize ("task color " + swatch) << "\n\n"; } // Show all supported colors. Possibly show some unsupported ones too. else { out << "\n" << STRING_CMD_COLOR_BASIC << "\n" << " " << Color::colorize (" black ", "black") << " " << Color::colorize (" red ", "red") << " " << Color::colorize (" blue ", "blue") << " " << Color::colorize (" green ", "green") << " " << Color::colorize (" magenta ", "magenta") << " " << Color::colorize (" cyan ", "cyan") << " " << Color::colorize (" yellow ", "yellow") << " " << Color::colorize (" white ", "white") << "\n" << " " << Color::colorize (" black ", "white on black") << " " << Color::colorize (" red ", "white on red") << " " << Color::colorize (" blue ", "white on blue") << " " << Color::colorize (" green ", "black on green") << " " << Color::colorize (" magenta ", "black on magenta") << " " << Color::colorize (" cyan ", "black on cyan") << " " << Color::colorize (" yellow ", "black on yellow") << " " << Color::colorize (" white ", "black on white") << "\n\n"; out << STRING_CMD_COLOR_EFFECTS << "\n" << " " << Color::colorize (" red ", "red") << " " << Color::colorize (" bold red ", "bold red") << " " << Color::colorize (" underline on blue ", "underline on blue") << " " << Color::colorize (" on green ", "black on green") << " " << Color::colorize (" on bright green ", "black on bright green") << " " << Color::colorize (" inverse ", "inverse") << "\n\n"; // 16 system colors. out << "color0 - color15" << "\n" << " 0 1 2 . . .\n"; for (int r = 0; r < 2; ++r) { out << " "; for (int c = 0; c < 8; ++c) { std::stringstream s; s << "on color" << (r*8 + c); out << Color::colorize (" ", s.str ()); } out << "\n"; } out << " . . . 15\n\n"; // Color cube. out << STRING_CMD_COLOR_CUBE << Color::colorize ("0", "bold red") << Color::colorize ("0", "bold green") << Color::colorize ("0", "bold blue") << " - rgb" << Color::colorize ("5", "bold red") << Color::colorize ("5", "bold green") << Color::colorize ("5", "bold blue") << " (also color16 - color231)" << "\n" << " " << Color::colorize ("0 " "1 " "2 " "3 " "4 " "5", "bold red") << "\n" << " " << Color::colorize ("0 1 2 3 4 5 " "0 1 2 3 4 5 " "0 1 2 3 4 5 " "0 1 2 3 4 5 " "0 1 2 3 4 5 " "0 1 2 3 4 5", "bold blue") << "\n"; char label [12]; for (int g = 0; g < 6; ++g) { sprintf (label, " %d", g); out << Color::colorize (label, "bold green"); for (int r = 0; r < 6; ++r) { for (int b = 0; b < 6; ++b) { std::stringstream s; s << "on rgb" << r << g << b; out << Color::colorize (" ", s.str ()); } out << " "; } out << "\n"; } out << "\n"; // Grey ramp. out << STRING_CMD_COLOR_RAMP << " gray0 - gray23 (also color232 - color255)\n" << " 0 1 2 . . . . . . 23\n" << " "; for (int g = 0; g < 24; ++g) { std::stringstream s; s << "on gray" << g; out << Color::colorize (" ", s.str ()); } out << "\n\n" << format (STRING_CMD_COLOR_TRY, "task color white on red") << "\n\n"; } } else { out << STRING_CMD_COLOR_OFF << "\n"; rc = 1; } output = out.str (); #else output = "Color not supported.\n"; #endif return rc; }
int main (int argc, const char** argv) { int status = 0; // Create a vector of args. std::vector <std::string> args; for (int i = 1; i < argc; ++i) args.push_back (argv[i]); Config config; config.set ("verbose", "1"); // Some options are hard-coded. if (args.size ()) { if (args[0] == "-h" || closeEnough ("--help", args[0], 3)) command_help (args); else if (args[0] == "-v" || closeEnough ("--version", args[0], 3)) { Color bold ("bold"); std::cout << "\n" << bold.colorize (PACKAGE_STRING) #ifdef HAVE_COMMIT << " " << COMMIT #endif << " built for " #if defined (DARWIN) << "darwin" #elif defined (SOLARIS) << "solaris" #elif defined (CYGWIN) << "cygwin" #elif defined (HAIKU) << "haiku" #elif defined (OPENBSD) << "openbsd" #elif defined (FREEBSD) << "freebsd" #elif defined (NETBSD) << "netbsd" #elif defined (LINUX) << "linux" #elif defined (KFREEBSD) << "GNU/kFreeBSD" #elif defined (GNUHURD) << "GNU/Hurd" #else << "unknown" #endif << "\n" << "Copyright (C) 2010 - 2015 Göteborg Bit Factory." << "\n" << "\n" << "Taskd may be copied only under the terms of the MIT license, " << "which may be found in the taskd source kit." << "\n" << "Documentation for taskd can be found using 'man taskd' or at " << "http://taskwarrior.org" << "\n" << "\n"; } else { try { // Some defaults come from the environment. char* root_env = getenv ("TASKDDATA"); if (root_env) config.set ("root", root_env); // Process all the options. std::vector <std::string> positionals; std::vector <std::string>::iterator arg; for (arg = args.begin (); arg != args.end (); ++arg) { if (closeEnough ("--data", *arg, 3)) { ++arg; if (arg == args.end () || (*arg)[0] == '-') throw std::string (STRING_TASKD_DATA); config.set ("root", *arg); } else if (closeEnough ("--quiet", *arg, 3)) config.set ("verbose", 0); else if (closeEnough ("--debug", *arg, 3)) config.set ("debug", 1); else if (closeEnough ("--force", *arg, 3)) config.set ("confirmation", 0); else if (closeEnough ("--daemon", *arg, 3)) config.set ("daemon", 1); else if (taskd_applyOverride (config, *arg)) ; else positionals.push_back (*arg); } // A database object interfaces to the data. Database db (&config); // The highest-level commands are hard-coded: if (closeEnough ("init", args[0], 3)) command_init (db, positionals); else if (closeEnough ("config", args[0], 3)) command_config (db, positionals); else if (closeEnough ("status", args[0], 3)) command_status (db, positionals); else if (closeEnough ("help", args[0], 3)) command_help ( positionals); else if (closeEnough ("diagnostics", args[0], 3)) command_diag (db, positionals); else if (closeEnough ("server", args[0], 3)) command_server (db, positionals); else if (closeEnough ("add", args[0], 3)) command_add (db, positionals); else if (closeEnough ("remove", args[0], 3)) command_remove (db, positionals); else if (closeEnough ("suspend", args[0], 3)) command_suspend (db, positionals); else if (closeEnough ("resume", args[0], 3)) command_resume (db, positionals); else if (closeEnough ("client", args[0], 3)) command_client (db, positionals); else if (closeEnough ("validate", args[0], 3)) command_validate (db, positionals); else throw format (STRING_TASKD_BAD_COMMAND, args[0]); } catch (std::string& error) { if (error == "usage") { std::vector <std::string> no_args; command_help (no_args); } else std::cout << error << "\n"; status = -1; } catch (std::bad_alloc& error) { std::cerr << "Error: Memory allocation failed: " << error.what () << "\n"; status = -3; } catch (...) { std::cerr << STRING_ERROR_UNKNOWN << "\n"; status = -2; } } } else command_help (args); return status; }
bool OutputImageParams::PartialXform::matches(PartialXform const& other) const { return closeEnough(m_11, other.m_11) && closeEnough(m_12, other.m_12) && closeEnough(m_21, other.m_21) && closeEnough(m_22, other.m_22); }
void Mesh::mirrorMesh(vector<int> planar_faces){ map<int, Face*> mirror_faces; vector<Vertex*> mirror_vertices; map<int, Face*> updated_faces; map<int, int> temp_twins; int last_face_id; std::set<int> planar_set; for(vector<int>::iterator it = planar_faces.begin(); it != planar_faces.end(); it++) planar_set.insert(*it); Face* pface = faces[(*planar_faces.begin())]; ofVec3f o = vList[pface->getA()->getId()]->getPoint(); //get a point on this plane ofVec3f n = pface->getFaceNormal(); double w = -(n.x * o.x) - (n.y * o.y) - (n.z * o.z); for( vector<Vertex*>::iterator it = vList.begin(); it != vList.end(); it++){ ofVec3f p = (*it)->getPoint(); double distance = n.x*p.x + n.y*p.y + n.z*p.z + w; ofVec3f pos = p + 2*distance * -1*n; //starting from the original the distance in the other direction int vid = vList.size()+mirror_vertices.size(); if(!closeEnough(p, pos)){ mirror_vertices.push_back(new Vertex(vid, pos.x, pos.y, pos.z)); temp_twins.insert(pair<int, int> ((*it)->getId(), vid)); insertTwin((*it)->getId(), vid); }else{ temp_twins.insert(pair<int, int> ((*it)->getId(), (*it)->getId())); //link it to itself } } vList.insert(vList.end(), mirror_vertices.begin(), mirror_vertices.end()); //find any additional planar triangles for(map<int, Face*>::iterator it = faces.begin(); it != faces.end(); it++){ last_face_id = (*it).first; Face* x = (*it).second; if(planar_set.count(x->getId()) > 0) continue; int a = x->getA()->getId(); int b = x->getB()->getId(); int c = x->getC()->getId(); if(temp_twins[a] == a && temp_twins[b] == b && temp_twins[c] == c) planar_set.insert(x->getId()); } //remove any triangles that lie on the mirror plane for(map<int, Face*>::iterator it = faces.begin(); it != faces.end(); it++){ Face* x = (*it).second; if(planar_set.count(x->getId()) == 0) updated_faces.insert(*it); } faces.clear(); faces.insert(updated_faces.begin(), updated_faces.end()); //now replicate remaining faces with new vertex values for(map<int, Face*>::iterator it = faces.begin(); it != faces.end(); it++){ Face* x = (*it).second; int a = x->getA()->getId(); int b = x->getB()->getId(); int c = x->getC()->getId(); x->resetFaceVertexNexts(); //this will make it so that it will look for connections int fid = last_face_id + mirror_faces.size() + 1; //okay to have mirror faces size because it will be sequential Face* n_face = new Face(fid, temp_twins[b], temp_twins[a], temp_twins[c]); //flip to make ccw mirror_faces.insert(pair<int, Face*> (fid, n_face)); } assert(mirror_faces.size() == faces.size()); faces.insert(mirror_faces.begin(), mirror_faces.end()); assert(faces.size() == 2*mirror_faces.size()); //make sure we didn't duplicate any indices constructTopology(); }