int main(int argc, char* argv[]) {
// Check arguments
if (argc < 2) {
std::cerr << "Usage: " << argv[0] << " NODES_FILE TETS_FILE\n";
exit(1);
}
MeshType mesh;
std::vector<typename MeshType::node_type> nodes;
// Create a nodes_file from the first input argument
std::ifstream nodes_file(argv[1]);
// Interpret each line of the nodes_file as a 3D Point and add to the Mesh
Point p;
while (CS207::getline_parsed(nodes_file, p))
nodes.push_back(mesh.add_node(p));
// Create a trianges_file from the second input argument
std::ifstream triangles_file(argv[2]);
// Interpret each line of the tets_file as three ints which refer to nodes
std::array<int,3> t;
// add in the triangles
while (CS207::getline_parsed(triangles_file, t))
for (unsigned i = 1; i < t.size(); ++i)
for (unsigned j = 0; j < i; ++j)
for (unsigned k = 0; k < j; ++k)
{
mesh.add_triangle(nodes[t[i]], nodes[t[j]], nodes[t[k]]);
}
// Set masses of nodes equal to 1/N where N is the number of nodes
// and the initial velocities to 0. Also, get the indexes of
// the nodes at positions (1,0,0) and (0,0,0)
for(auto it=mesh.node_begin(); it != mesh.node_end(); ++ it)
{
(*it).value().mass = total_mass/mesh.num_nodes();
(*it).value().velocity = Point(0.0,0.0,0.0);
}
// Set spring constants for each node equal to spring_const variable
// and set initial length values equal to lengths of edges prior to
// running the symplectic Euler steps
for(auto it=mesh.edge_begin(); it != mesh.edge_end(); ++ it)
{
(*it).value().spring_constant = spring_const;
(*it).value().initial_length = (*it).length();
}
// Set the triangle direction values so that we can determine which
// way to point normal vectors. This part assumes a convex shape
Point center = get_center(mesh);
for(auto it=mesh.triangle_begin(); it != mesh.triangle_end(); ++ it)
{
//std::cout << (*it).index() << std::endl;
set_normal_direction((*it),center);
}
// Print out the stats
std::cout << mesh.num_nodes() << " " << mesh.num_edges() << std::endl;
std::cout << "Center: " << get_center(mesh) << std::endl;
// Launch the SDLViewer
CS207::SDLViewer viewer;
auto node_map = viewer.empty_node_map(mesh);
viewer.launch();
viewer.add_nodes(mesh.node_begin(), mesh.node_end(), node_map);
viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map);
viewer.center_view();
// Begin the mass-spring simulation
double dt = 0.0001;
double t_start = 0;
double t_end = 20.0;
// Initialize constraints
PlaneConstraint c1;
//SelfCollisionConstraint c2;
//auto combined_constraints = make_combined_constraints(c1,c2);
for (double t = t_start; t < t_end; t += dt) {
MassSpringForce ms_force;
PressureForce p_force = PressureForce(0.0);
DampingForce d_force = DampingForce(mesh.num_nodes());
GravityForce g_force;
WindForce w_force;
(void) d_force; // prevents compiler from throwing error for unused variable
if (t >= t_addgas - dt) {
p_force.set_pressure(gas_const/get_volume(mesh));
if (t < t_addgas)
std::cout << "Adding gas to the ball now..." << std::endl;
}
auto combined_forces = make_combined_force(ms_force, p_force, w_force, g_force);
symp_euler_step(mesh, t, dt, combined_forces, c1);
// Update viewer with nodes' new positions
viewer.add_nodes(mesh.node_begin(), mesh.node_end(), node_map);
// update the viewer's label with the ball center's position on the z axis
viewer.set_label(get_center(mesh).z);
}
return 0;
}
int main(int argc, char** argv) {
// Check arguments
if (argc < 5) {
std::cerr << "Usage: " << argv[0] << " NODES_FILE TETS_FILE\n";
exit(1);
}
// Construct the first mesh
MeshType mesh;
//construct the second mesh
MeshType mesh2;
std::vector<typename MeshType::node_type> mesh_node;
// Read all Points and add them to the Mesh
std::ifstream nodes_file(argv[1]);
Point p;
while (CS207::getline_parsed(nodes_file, p)) {
mesh_node.push_back(mesh.add_node(p));
}
// Read all mesh triangles and add them to the Mesh
std::ifstream tris_file(argv[2]);
std::array<int,3> t;
while (CS207::getline_parsed(tris_file, t)) {
mesh.add_triangle(mesh_node[t[0]], mesh_node[t[1]], mesh_node[t[2]]);
}
std::vector<typename MeshType::node_type> mesh_node2;
// Read all Points and add them to the Mesh
std::ifstream nodes_file2(argv[3]);
while (CS207::getline_parsed(nodes_file2, p)) {
mesh_node2.push_back(mesh2.add_node(p));
}
// Read all mesh triangles and add them to the Mesh
std::ifstream tris_file2(argv[4]);
while (CS207::getline_parsed(tris_file2, t)) {
mesh2.add_triangle(mesh_node2[t[0]], mesh_node2[t[1]], mesh_node2[t[2]]);
}
//move the second mesh to the specified position
for(auto it = mesh2.node_begin();it!=mesh2.node_end();++it){
(*it).position().elem[1] +=4 ;
(*it).position().elem[2] +=4 ;
}
// Print out the stats
std::cout << mesh.num_nodes() << " "
<< mesh.num_edges() << " "
<< mesh.num_triangles() << std::endl;
std::cout << mesh2.num_nodes() << " "
<< mesh2.num_edges() << " "
<< mesh2.num_triangles() << std::endl;
//set the mass and velocity of each Node for the first mesh
for (auto it = mesh.node_begin(); it != mesh.node_end(); ++it){
(*it).value().mass = float(1)/mesh.num_nodes();
(*it).value().velocity = Point(0, 10, 10);
}
//set the mass and velocity of each Node for the second mesh
for (auto it = mesh2.node_begin(); it != mesh2.node_end(); ++it){
(*it).value().mass = float(1)/mesh.num_nodes();
(*it).value().velocity = Point(0, -10, -10);
}
//set K and L for each edge
for (auto it = mesh.node_begin(); it != mesh.node_end(); ++it)
{
for (auto j = (*it).edge_begin(); j != (*it).edge_end(); ++j){
(*j).value().L = (*j).length();
(*j).value().K = 16000;
}
}
for (auto it = mesh2.node_begin(); it != mesh2.node_end(); ++it)
{
for (auto j = (*it).edge_begin(); j != (*it).edge_end(); ++j){
(*j).value().L = (*j).length();
(*j).value().K = 16000;
}
}
// Launch the SDLViewer
CS207::SDLViewer viewer;
auto node_map = viewer.empty_node_map(mesh);
viewer.launch();
viewer.add_nodes(mesh.node_begin(), mesh.node_end(), node_map);
viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map);
viewer.add_nodes(mesh2.node_begin(), mesh2.node_end(), node_map);
viewer.add_edges(mesh2.edge_begin(), mesh2.edge_end(), node_map);
viewer.center_view();
//Begin the mass-spring simulation
double dt = 0.0002;
double t_start = 0.0;
double t_end = 10.0;
//three color parameter
int color1 = 1;
int color2 = 1;
int color3 = 1;
//Create listener
Pause_listener* pause = new Pause_listener(dt);
Speed_listener* speed = new Speed_listener(dt, dt);
XYZ_listener<MeshType>* xyz = new XYZ_listener<MeshType>(&mesh);
Color_listener* col = new Color_listener(&color1, &color2, &color3);
//add listener
viewer.add_listener(pause);
viewer.add_listener(speed);
viewer.add_listener(xyz);
viewer.add_listener(col);
//Initialize forces
WindForce wind_force(Point(0,100,200));
PressureForce<typename MeshType::node_type, MeshType> pressure_force(1, 2500, &mesh);
DampingForce damp_force(float(1)/mesh.num_nodes());
//auto force = make_combined_force(MassSpringForce(), GravityForce(), make_combined_force(pressure_force, damp_force, wind_force));
auto force = make_combined_force(MassSpringForce(), make_combined_force(pressure_force, damp_force, wind_force));
//Initialize constriants
auto constraint = PlaneConstraint<MeshType>(-4);
//simulation processing
for (double t = t_start; t < t_end; t += dt) {
constraint(mesh, 0);
constraint(mesh2, 0);
//define a collision constrain
auto collision_constrain = CollisionConstraint<MeshType>();
//add the forces to the meshs at each dt
symp_euler_step(mesh, t, dt, force);
symp_euler_step(mesh2, t, dt, force);
//detec the collision betweent the two meshes
CollisionDetector<MeshType> c;
c.add_object(mesh);
c.add_object(mesh2);
c.check_collisions();
std::vector<unsigned> collision;
std::vector<unsigned> collision2;
//find the corresponding mesh for each node
for (auto it=c.begin(); it!= c.end(); ++it){
auto boom = *it;
Node n = boom.n1;
if (boom.mesh1 == &mesh)
collision.push_back(n.index());
if (boom.mesh1 == &mesh2)
collision2.push_back(n.index());
}
//add the collision constrain to the meshes
collision_constrain(mesh,mesh2,collision,collision2);
viewer.set_label(t);
//update with removed nodes
//clear teh viewer's node
viewer.clear();
node_map.clear();
//update viewer with new positions and new edges
viewer.add_nodes(mesh.node_begin(), mesh.node_end(), color(color1, color2, color3), node_map);
viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map);
viewer.add_nodes(mesh2.node_begin(), mesh2.node_end(), color(color1, color2, color3), node_map);
viewer.add_edges(mesh2.edge_begin(), mesh2.edge_end(), node_map);
// These lines slow down the animation for small graphs
if (mesh.num_nodes() < 100)
CS207::sleep(0.001);
}
return 0;
}
// =============================================================================
int main(int argc, char** argv) {
// Check arguments
if (argc < 3) {
std::cerr << "Usage: " << argv[0] << " NODES_FILE TETS_FILE\n";
exit(1);
}
// Construct an empty graph
GraphType graph;
// Create a nodes_file from the first input argument
std::ifstream nodes_file(argv[1]);
// Interpret each line of the nodes_file as a 3D Point and add to the Graph
Point p;
std::vector<typename GraphType::node_type> nodes;
while (CME212::getline_parsed(nodes_file, p))
nodes.push_back(graph.add_node(p));
// Create a tets_file from the second input argument
std::ifstream tets_file(argv[2]);
// Interpret each line of the tets_file as four ints which refer to nodes
std::array<int,4> t;
while (CME212::getline_parsed(tets_file, t)) {
graph.add_edge(nodes[t[0]], nodes[t[1]]);
graph.add_edge(nodes[t[0]], nodes[t[2]]);
#if 1
// Diagonal edges
graph.add_edge(nodes[t[0]], nodes[t[3]]);
graph.add_edge(nodes[t[1]], nodes[t[2]]);
#endif
graph.add_edge(nodes[t[1]], nodes[t[3]]);
graph.add_edge(nodes[t[2]], nodes[t[3]]);
}
// Set initial velocity and mass
for (GraphType::NodeIterator it = graph.node_begin(); it != graph.node_end(); ++it) {
Node n = *it;
n.value().vel = Point(0,0,0); // Initial velocity == 0
n.value().mass = 1.0 / graph.num_nodes(); // graph has total mass == 1, constant density
}
// Set rest length for all of the Edges to their initial length
for (GraphType::EdgeIterator ei = graph.edge_begin(); ei != graph.edge_end(); ++ei ) {
(*ei).value().L = (*ei).length();
}
// Print out the stats
std::cout << graph.num_nodes() << " " << graph.num_edges() << std::endl;
// Launch the SDLViewer
CME212::SDLViewer viewer;
auto node_map = viewer.empty_node_map(graph);
viewer.launch();
viewer.add_nodes(graph.node_begin(), graph.node_end(), node_map);
viewer.add_edges(graph.edge_begin(), graph.edge_end(), node_map);
viewer.center_view();
// Begin the mass-spring simulation
double dt = 0.001;
double t_start = 0;
double t_end = 5.0;
for (double t = t_start; t < t_end; t += dt) {
// P1 ---------------------------------------------------------------------
// symp_euler_step(graph, t, dt, Problem1Force());
// P3 ----------------------------------------------------------------------
//symp_euler_step(graph, t, dt, cf);
// Create individual forces
GravityForce g(grav);
MassSpringForce msf(100);
DampingForce d(1.0 / graph.num_nodes());
// Combine the individual forces
auto cf = make_combined_force(g, msf, d);
// P4 ----------------------------------------------------------------------
// Create individual constraints
HPlane hp(-0.75);
Sphere sp(0.15, Point(0.5,0.5,-0.5));
SphereRemove sr(0.15, Point(0.5,0.5,-0.5));
// Combined individual constraints
// P4.1
// auto c = make_combined_constraint(hp, FixedConstraint());
// P4.2
// auto c = make_combined_constraint(sp, FixedConstraint());
// P4.3
auto c = make_combined_constraint(sr, FixedConstraint());
// Mixed constraints
// auto c = make_combined_constraint(hp, sr, FixedConstraint());
// auto c = make_combined_constraint(hp, sp, FixedConstraint());
symp_euler_step(graph, t, dt, cf, c);
viewer.clear();
node_map.clear();
viewer.add_nodes(graph.node_begin(), graph.node_end(), node_map);
viewer.add_edges(graph.edge_begin(), graph.edge_end(), node_map);
// Update viewer with nodes' new positions
viewer.add_nodes(graph.node_begin(), graph.node_end(), node_map);
viewer.set_label(t);
// These lines slow down the animation for small graphs, like grid0_*.
// Feel free to remove them or tweak the constants.
if (graph.size() < 100)
CME212::sleep(0.0001);
}
return 0;
}
