rt300@0: /*
rt300@0:  *  mesh.cpp
rt300@0:  *  springstructure
rt300@0:  *
rt300@0:  *  Created by Robert Tubb on 07/06/2011.
rt300@0:  *  Copyright 2011 __MyCompanyName__. All rights reserved.
rt300@0:  *
rt300@0:  */
rt300@0: 
rt300@0: #include "mesh.h"
rt300@0: #include "testApp.h"
rt300@0: #include "lump.h"
rt300@0: #include <math.h>
rt300@0: 
rt300@0: extern GlobalForces globalForces;
rt300@3: extern ScanPath  scanPath; // now global
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: Mesh::Mesh(){
rt300@0: 	// construct an empty structure
rt300@10:     setReasonableDefaults();
rt300@10: 
rt300@10:     cout << "constructed mesh base" << endl;
rt300@10: }
rt300@10: 
rt300@10: 
rt300@10: Mesh::~Mesh(){
rt300@10: 	cout << "destroying mesh" << endl;
rt300@10: 
rt300@10: 
rt300@10: }
rt300@10: //--------------------------------------------------------------
rt300@10: void Mesh::setReasonableDefaults(){
rt300@10:     numSprings = 0;
rt300@0: 	numLumps = 0;
rt300@10:     
rt300@0: 	syrup = false;
rt300@0: 	GRAB_RANGE = 0.040;
rt300@0:     propagationSpeed = 0.5; // this will be changed by adjusting k/m
rt300@10: 	
rt300@0:     
rt300@0:     m = 123.0;
rt300@0:     k = 0.1;
rt300@0:     f = 0.999;
rt300@10:     
rt300@0:     prevLump = -1;
rt300@0:     
rt300@0:     // some reasonable defaults
rt300@0:     setSpringConstant(0.8);
rt300@0:     setMass(1);
rt300@0:     setFriction(0.999991);
rt300@0: }
rt300@9: //--------------------------------------------------------------
rt300@9: //--------------------------------------------------------------
rt300@9: Mesh::Mesh(Json::Value& jmesh){
rt300@10:     setReasonableDefaults(); // sensible?
rt300@9:     
rt300@9:     meshType = (MeshType)jmesh.get("meshType",0).asInt();
rt300@9:     dim1 = jmesh.get("dim1",0).asInt();
rt300@9:     dim2 = jmesh.get("dim1",0).asInt();
rt300@9:     
rt300@9:     // need to know how many springs and lumps
rt300@9:     numLumps = jmesh.get("numLumps",0).asInt();
rt300@9:     numSprings = jmesh.get("numSprings",0).asInt();
rt300@9:     
rt300@9:     // make them
rt300@9:     makeComponents(numLumps, numSprings);
rt300@13:     setLumpPositionsFromJson(jmesh["lumpPositions"], jmesh["lumpRestPositions"]);
rt300@9:     makeConnectionsFromJson(jmesh["connections"]);
rt300@9:     makeScanPathFromJson(jmesh["scanPath"]);
rt300@9:     constrainFromJson(jmesh["constrainedLumps"]);
rt300@9: 
rt300@9:     // now set saved properties 
rt300@9:     setSpringConstant(jmesh["springConstant"].asDouble());
rt300@9:     setMass(jmesh["mass"].asDouble());
rt300@9:     setFriction(jmesh["friction" ].asDouble());
rt300@9:     // rest length?
rt300@9:     zeroRestLength();
rt300@9: }
rt300@9: 
rt300@9: //--------------------------------------------------------------
rt300@13: void Mesh::setLumpPositionsFromJson(Json::Value lumpPositions, Json::Value lumpRestPositions){
rt300@9:     int N = lumpPositions.size();
rt300@9:     
rt300@9:     for(int i=0;i<N;i++){
rt300@9:         lumps[i].position.x = lumpPositions[i]["x"].asFloat();
rt300@9:         lumps[i].position.y = lumpPositions[i]["y"].asFloat();
rt300@9:         
rt300@13:         lumps[i].zeroRefPos.x = lumpRestPositions[i]["x"].asFloat();
rt300@13:         lumps[i].zeroRefPos.y = lumpRestPositions[i]["y"].asFloat();
rt300@9: 	}
rt300@9: }
rt300@9: //--------------------------------------------------------------
rt300@9: void Mesh::makeConnectionsFromJson(Json::Value connections){
rt300@9:     
rt300@9:     // format: pairs of lump indexes, and a connecting spring
rt300@9:     for (int i=0;i<connections.size();i++){
rt300@13:         connect(i, connections[i]["s"].asInt(),connections[i]["e"].asInt()); // will the springs be in the right order? they need to be!
rt300@9:         
rt300@9:     }
rt300@9: }
rt300@9: 
rt300@9: //--------------------------------------------------------------
rt300@9: void Mesh::makeScanPathFromJson(Json::Value jscanPath){
rt300@9:     
rt300@9:     for(int i=0;i<jscanPath.size();i++){
rt300@9:         scanPath.addElement(&lumps[jscanPath[i]["lumpNo"].asInt()], &springs[jscanPath[i]["springNo"].asInt()]);
rt300@9:     }
rt300@9: }
rt300@9: //--------------------------------------------------------------
rt300@9: void Mesh::constrainFromJson(Json::Value constrainedLumps){
rt300@9: 
rt300@9:     for(int i=0;i<constrainedLumps.size();i++){
rt300@9: 
rt300@9:         lumps[constrainedLumps[i].asInt()].constrain(); // TODO ignores XY thing
rt300@9: 
rt300@9: 	}
rt300@9: }
rt300@9: 
rt300@9: //--------------------------------------------------------------
rt300@9: Json::Value Mesh::convertToJsonForSaving(){
rt300@9:     
rt300@9:     // needs to be good to put back into
rt300@9:     /*
rt300@9:      void setLumpPositionsFromJson(Json::Value lumpPositions);
rt300@9:      void makeConnectionsFromJson(Json::Value connections);
rt300@9:      void makeScanPathFromJson(Json::Value scanPathElements);
rt300@9:      void constrainFromJson(Json::Value constrainedLumps);
rt300@9:     */
rt300@9:     
rt300@9:     Json::Value jmesh;
rt300@9:     
rt300@9:     jmesh["meshType"] = meshType;
rt300@9:     jmesh["dim1"] = dim1; // these don't exist...
rt300@9:     jmesh["dim2"] = dim2;
rt300@9:     // need to know how many springs and lumps
rt300@9:     jmesh["numLumps"] = numLumps;
rt300@9:     jmesh["numSprings"] = numSprings;
rt300@9:     jmesh["springConstant"] = k;
rt300@9:     jmesh["mass"] = m;
rt300@9:     jmesh["friction" ] = f;
rt300@9:     for(int i=0;i<lumps.size();i++){
rt300@9:         jmesh["lumpPositions"][i]["x"] = lumps[i].position.x;
rt300@9:         jmesh["lumpPositions"][i]["y"] = lumps[i].position.y;
rt300@13:         // just use rest pos ... too much data! 
rt300@13:         jmesh["lumpRestPositions"][i]["x"] = lumps[i].zeroRefPos.x;
rt300@13:         jmesh["lumpRestPositions"][i]["y"] = lumps[i].zeroRefPos.y;
rt300@9: 	}
rt300@9: 
rt300@9:     jmesh["connections"] = saveConnectionsAsJson();
rt300@9:     jmesh["scanPath"] = scanPath.convertToJsonForSaving();
rt300@9: 
rt300@9:     // save all indexes of constrained lumps
rt300@9:     int j = 0;
rt300@9:     for(int i=0;i<lumps.size();i++){
rt300@9: 		if(lumps[i].constrained){
rt300@9:             
rt300@9:             jmesh["constrainedLumps"][j] = i;
rt300@9:             j++;
rt300@9:         }
rt300@9: 	}
rt300@9:   
rt300@9:     
rt300@9:     return jmesh;
rt300@9:     
rt300@9: }
rt300@9: //--------------------------------------------------------------
rt300@9: Json::Value Mesh::saveConnectionsAsJson(){
rt300@9:     Json::Value connections;
rt300@9:     // loop all springs
rt300@9:     
rt300@9:     for(int i = 0; i<springs.size(); i++){
rt300@13:         connections[i]["s"]= springs[i].getStartLumpIndex();
rt300@13:         connections[i]["e"]= springs[i].getEndLumpIndex();
rt300@9:     }
rt300@9:     return connections;
rt300@9:     
rt300@9:     
rt300@9: }
rt300@9: //--------------------------------------------------------------
rt300@9: //--------------------------------------------------------------
rt300@0: ///////////
rt300@0: // interface (called from testApp)
rt300@0: ///////////
rt300@0: void Mesh::update(){
rt300@0: 	// update all the springs and masses sequentially
rt300@0:     // INTERP HACK - this bit of code is to debug pops and clicks
rt300@0:   /*  
rt300@0:     static int updown = 0;
rt300@0:     updown++;
rt300@0:     if(updown > 24){
rt300@4:         for(int i=0;i<lumps.size();i++){
rt300@0:             lumps[i].position.y = 0.4;
rt300@0:         }	
rt300@0:     
rt300@0:     }else{
rt300@0:         
rt300@4:         for(int i=0;i<lumps.size();i++){
rt300@0:             lumps[i].position.y = 0.6;
rt300@0:         }	
rt300@0:      
rt300@0:     }
rt300@0:     if(updown > 48) updown = 0;
rt300@0:   	// update the ends of the springs to reflect lump movement
rt300@0: 	
rt300@0: 	for(int i=0;i<numSprings;i++){
rt300@0: 		springs[i].updateEndPoints();
rt300@0: 	}	  
rt300@0:     
rt300@0:     return;
rt300@0:     
rt300@0:    */
rt300@0:     
rt300@0:     globalForces.update();
rt300@0: 	// calculate all the forces in the springs
rt300@4: 	for(int i=0;i<springs.size();i++){
rt300@0: 		springs[i].calculateForce();
rt300@0: 	}	
rt300@0:     
rt300@0: 	// accelerate the lumps
rt300@4: 	for(int i=0;i<lumps.size();i++){
rt300@0: 		lumps[i].applyForce();
rt300@0: 	}	
rt300@0:     
rt300@0:     // move filters into apply force? not really, they're not forces.
rt300@0:     // apply homing filter
rt300@4: 	for(int i=0;i<lumps.size();i++){
rt300@0: 		lumps[i].homingFilter(globalForces.homingAmt);
rt300@0: 	}	    
rt300@0:     // apply averaging filter
rt300@0:     // 
rt300@0:     averagingFilter(globalForces.avFilterAmt);
rt300@0:     
rt300@0: 	// update the ends of the springs to reflect lump movement
rt300@0: 	for(int i=0;i<numSprings;i++){
rt300@0: 		springs[i].updateEndPoints();
rt300@0: 	}	
rt300@0:     
rt300@0:     // scan the updated mesh
rt300@3:     scanPath.updateWavetables();
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::averagingFilter(double amt){
rt300@0:     // we need a temporary store for average position, can't update in place with central diffs
rt300@4:     vector<TwoVector> avLumpPos = vector<TwoVector>(lumps.size());
rt300@0:     
rt300@4:     
rt300@4:     for(int i=0;i<lumps.size();i++){
rt300@0: 		avLumpPos[i] = lumps[i].averageOfConnected();
rt300@0: 	}	 
rt300@4:     // now we can set pos. needs to be separate loop because we don't want to average *moved* lumps
rt300@4:     for(int i=0;i<lumps.size();i++){
rt300@0:             // mix in the average with the 'real'
rt300@0: 
rt300@0:             lumps[i].position.x = (1 - amt)*lumps[i].position.x + amt*avLumpPos[i].x;
rt300@0:             lumps[i].position.y = (1 - amt)*lumps[i].position.y + amt*avLumpPos[i].y;
rt300@0: 
rt300@0: 	}    
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::draw(){
rt300@0: 	// draw all the components belonging to mesh
rt300@0: 
rt300@0: 	int i;
rt300@0: 	for(i=0;i<numSprings;i++){
rt300@0: 		springs[i].draw();
rt300@0: 	}
rt300@0: 
rt300@4: 	for(i=0;i<lumps.size();i++){
rt300@0: 		lumps[i].draw();
rt300@0: 	}
rt300@0: 
rt300@8: 
rt300@0: 
rt300@0: 
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: TwoVector Mesh::calculateCentre(){
rt300@0:     // calculates average of all lump positions
rt300@0:     
rt300@0:     double x = 0, y = 0;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         x += lumps[i].position.x;
rt300@0:         y += lumps[i].position.y;
rt300@0:         
rt300@0:     }
rt300@4:     x = x/lumps.size();
rt300@4:     y = y/lumps.size();
rt300@0:     
rt300@0:     //cout << "centre : " << x << "," << y << endl;
rt300@0:     
rt300@0:     centre.setCoord(x,y);
rt300@0:     
rt300@0:     return centre;
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::resetAll(){
rt300@0: 	// it's this simple
rt300@0: 	resetPositions();
rt300@0:     resetVelocities();
rt300@0:     unconstrain();
rt300@0:     clearScanPath();
rt300@0:     makeDefaultScanPath();
rt300@0:     constrain(0.0,0.0,CONSTRAIN_EDGES);
rt300@0:     constrain(0.0,0.0,CONSTRAIN_CORNERS);
rt300@0:     
rt300@0: 	// unless we want to reset velocities...?
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::resetPositions(){
rt300@0: 	// it's this simple
rt300@0: 	setLumpPositions();
rt300@0: 	// unless we want to reset velocities...?
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::resetVelocities(){
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setVelocity(0.0,0.0);
rt300@0:         
rt300@0:     }    
rt300@0: }
rt300@0: void Mesh::toggleHome(bool on){
rt300@0:     static double prev;
rt300@0:     
rt300@0:     if(!home && on){
rt300@0:         home = on;
rt300@0:         prev = globalForces.homingAmt;
rt300@0:         globalForces.homingAmt = 0.3;
rt300@0:         
rt300@0: 
rt300@0:     }else if (home && !on){
rt300@0:         home = on; // ie false
rt300@0:         globalForces.homingAmt = prev;        
rt300@0:     }
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::resetEverything(){
rt300@0: 
rt300@0: }
rt300@0: 
rt300@0: //--------------
rt300@0: void Mesh::toggleSyrup(){
rt300@0:     if(syrup){
rt300@0:         toggleSyrup(false);
rt300@0:     }else{
rt300@0:         toggleSyrup(true);
rt300@0:     }
rt300@0: }
rt300@0: //--------------
rt300@0: void Mesh::toggleSyrup(bool on){
rt300@0: 	if (!on){
rt300@0: 		syrup = false;
rt300@4: 		for(int i=0;i<lumps.size();i++) lumps[i].setFriction(0.998);
rt300@0: 	}else{
rt300@0: 		syrup = true;
rt300@4: 		for(int i=0;i<lumps.size();i++) lumps[i].setFriction(0.90);
rt300@0: 	}
rt300@0: }
rt300@0: //----------------------------------------------------------------
rt300@0: void Mesh::toggleGravity(){
rt300@0:     globalForces.gravityOn = !globalForces.gravityOn;
rt300@0: }
rt300@0: //----------------------------------------------------------------
rt300@0: void Mesh::toggleGravity(bool on){
rt300@0: 	if (!on){
rt300@0:         globalForces.gravityOn = true;
rt300@0: 	}else{
rt300@0:         globalForces.gravityOn = false;
rt300@0: 	}
rt300@0: }
rt300@0: 
rt300@0: //----------------------------------------------------------------
rt300@0: void Mesh::toggleSpringForces(){
rt300@0: 
rt300@0: 		Spring::forcesOn = !Spring::forcesOn;
rt300@0: 
rt300@0: }
rt300@0: //----------------------------------------------------------------
rt300@0: void Mesh::toggleSpringForces(bool on){
rt300@0: 	if (!on){
rt300@0: 		Spring::forcesOn = false;
rt300@0: 
rt300@0: 	}else{
rt300@0: 		Spring::forcesOn = true;
rt300@0: 
rt300@0: 	}
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::unconstrain(){
rt300@0: 	
rt300@4: 	for(int i = 0; i<lumps.size(); i++){
rt300@0: 		
rt300@0: 		lumps[i].unconstrain();
rt300@0: 		
rt300@0: 	}
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::unconstrain(double ax, double ay, constrainMode aMode){
rt300@0: 	int i = 0;
rt300@0:     TwoVector diff;
rt300@0: 	// check if lump is within grab range
rt300@0: 	switch (aMode) {
rt300@0: 		case CONSTRAIN_GRAB_REGION:
rt300@4: 			for(i = 0; i<lumps.size(); i++){
rt300@0: 				
rt300@0: 				diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0: 				
rt300@0: 				if (diff.norm() < GRAB_RANGE){
rt300@0: 					lumps[i].unconstrain();
rt300@0: 				}
rt300@0: 			}
rt300@0: 			break;
rt300@0: 		case CONSTRAIN_EDGES:
rt300@0:             // hmm
rt300@0: 			break;
rt300@0: 			
rt300@0: 		default:
rt300@0: 			break;
rt300@0: 	}
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setRestLength(){
rt300@0: 	for(int i = 0; i<numSprings; i++){
rt300@0: 		springs[i].setRestLength();
rt300@0: 	}
rt300@0: 
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setZeroAudioLine(){
rt300@0: 	// set zero rest pos to where they are now
rt300@4:     for(int i = 0; i<lumps.size(); i++){
rt300@0: 		
rt300@0: 		lumps[i].setZeroRefPos();
rt300@0: 		
rt300@0: 	}
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setPropagationSpeed(double aSpeed){
rt300@0:     
rt300@0:     propagationSpeed = aSpeed;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setInvMass(propagationSpeed*propagationSpeed); // inverse mass is c^2
rt300@0:     }
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::increasePropagationSpeed(){
rt300@0:     
rt300@0:     propagationSpeed = propagationSpeed + 0.01;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setInvMass(propagationSpeed*propagationSpeed); // inverse mass is c^2
rt300@0:     }
rt300@0:     cout << "prop speed  = " << propagationSpeed << endl;
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::decreasePropagationSpeed(){
rt300@0:     
rt300@0:     propagationSpeed = propagationSpeed - 0.01;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setInvMass(propagationSpeed*propagationSpeed); // inverse mass is c^2
rt300@0:     }
rt300@0:     cout << "prop speed  = " << propagationSpeed << endl;
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setSpringConstant(double aK){
rt300@0:     k = aK;
rt300@0:     if(sqrt(k/m) > 0.9){
rt300@0:         k = m * 0.9;
rt300@0:     }
rt300@0:     cout << "k/m = " << k/m << endl;
rt300@9:     for(int i = 0; i < springs.size(); i++){
rt300@0:         springs[i].setSpringConstant(k); // inverse mass is c^2
rt300@0:     }      
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setMass(double aM){
rt300@0: 
rt300@0:     m = aM;
rt300@0: 
rt300@0:     if(sqrt(k/m) > 0.9){
rt300@0:         m = k/0.9;
rt300@0:     }
rt300@15:     //cout << "k/m = " << k/m << endl;
rt300@0:     double im = 1/aM;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setInvMass(im); 
rt300@0:     }    
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setFriction(double newF){
rt300@0:     f = newF;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setFriction(f); 
rt300@0:     }        
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setMassAsym(double aAsym){
rt300@0:     // use m as bass and add asym linearly across mesh. might be wierd for some meshes!
rt300@0:     double newm,incr;
rt300@0:     newm = m;
rt300@4:     incr = aAsym*m/(lumps.size()-1);
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setInvMass(1/newm);
rt300@0:         newm += incr;
rt300@0:     }    
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setSpringConstantAsym(double aAsym){
rt300@0:     // from 0 to 1
rt300@0:     if (aAsym > 1.0){
rt300@0:         aAsym = 1.0;
rt300@0:     }
rt300@0:     if (aAsym < 0.0){
rt300@0:         aAsym = 0.0;
rt300@0:     }
rt300@0:     double newk, incr;
rt300@0:     newk = k;
rt300@0:     incr = (1-aAsym)*k/(numSprings-1);
rt300@0:     for(int i = 0; i < numSprings; i++){
rt300@0:         springs[i].setSpringConstant(newk);
rt300@0:         newk -= incr;
rt300@0:     }    
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setFrictionAsym(double aAsym){
rt300@0:     // multiplying it doesn't make sense!
rt300@0:     double newF,incr;
rt300@0:     newF = f;
rt300@4:     incr = aAsym*f/(lumps.size()-1);
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setFriction(newF); 
rt300@0:         newF += incr;
rt300@0:     }        
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::checkHover(double ax, double ay){
rt300@0: 	TwoVector diff;
rt300@0: 	bool found = false;
rt300@0: 	// check if lump is within grab range
rt300@4: 	for(int i = 0; i<lumps.size(); i++){
rt300@0: 		diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0: 		//cout << "diff " << diff.x << "," << diff.y << endl;
rt300@0: 		if (diff.norm() < GRAB_RANGE){
rt300@0: 			if(!found)	{
rt300@0: 				lumps[i].highlight();
rt300@0: 				found = true;
rt300@0: 			}
rt300@0: 		}else{
rt300@0: 			lumps[i].unhighlight();
rt300@0: 		}
rt300@0: 	}	
rt300@0: 	
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::grab(double ax, double ay, int touchID){
rt300@0: 	// attempt to grab a lump ax and ay should be already normalised
rt300@0: 	
rt300@0: 	TwoVector diff;
rt300@0:     
rt300@0: 	// find closest
rt300@0:     int nearest = getNearestLump(ax,ay);
rt300@10:     //if(nearest = -1) return; // there are no lumps!
rt300@0:     diff.setCoord(lumps[nearest].position.x - ax, lumps[nearest].position.y - ay);
rt300@0:     //cout << "diff " << diff.x << "," << diff.y << endl;
rt300@10:     cout << GRAB_RANGE << endl;
rt300@0:     if (diff.norm() < GRAB_RANGE){
rt300@10:         
rt300@0:         cout << "grabbing lump " << nearest << endl;
rt300@10:         
rt300@0:         // move this lump to mouse pos
rt300@0:         
rt300@0:         lumps[nearest].grab(touchID);
rt300@0:     }
rt300@0: 
rt300@0: 	
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::unGrab(int touchID){
rt300@0: 	
rt300@4: 	for(int i=0; i<lumps.size();i++){
rt300@0:         if(lumps[i].grabID == touchID){ // only release the lumps that were grabbed by this finger
rt300@0:             lumps[i].unGrab();
rt300@0:             lumps[i].unhighlight();
rt300@0:         }
rt300@0: 	}
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::drag(double ax, double ay, int touchID){
rt300@0: 	// maybe set up specific id's for grabbed lumps
rt300@4: 	for(int i=0; i<lumps.size();i++){
rt300@0:         if(lumps[i].grabID == touchID){// only move the lumps that were grabbed by this finger
rt300@0:             
rt300@0:             lumps[i].drag(ax,ay,touchID);
rt300@0:         }
rt300@0: 	}
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: /* also could:
rt300@0:  add random velocities
rt300@0:  etc
rt300@0:  */
rt300@0: //////////////////////
rt300@0: // protected utils
rt300@0: ////////////////////////
rt300@0: //---------------------------------------------------------------
rt300@0: void Mesh::connect(int aspringnum,int alumpnum){
rt300@0: 	//cout << "connecting spring " << aspringnum << " to lump " << alumpnum << endl;
rt300@0: 	// should we check valid indexes?
rt300@0: 	lumps[alumpnum].attachSpring(&springs[aspringnum]);
rt300@0: 	springs[aspringnum].attachLump(&lumps[alumpnum]);
rt300@0: 
rt300@0: }
rt300@0: //---------------------------------------------------------------
rt300@0: void Mesh::connect(int aspringnum,int alumpnum,int alumpnum2){
rt300@0: 	// better version - just connects 2 lumps with a spring
rt300@0: 	// should we check valid indexes?
rt300@0: 	lumps[alumpnum].attachSpring(&springs[aspringnum]);
rt300@0: 	springs[aspringnum].attachLump(&lumps[alumpnum]);
rt300@0: 	lumps[alumpnum2].attachSpring(&springs[aspringnum]);
rt300@0: 	springs[aspringnum].attachLump(&lumps[alumpnum2]);
rt300@0:     
rt300@0: }
rt300@0: 
rt300@0: void Mesh::zeroRestLength(){
rt300@0:     // sets springs rest length to zero - collapses structure
rt300@3:     for(vector<Spring>::iterator spriter = springs.begin(); spriter < springs.end(); spriter++){
rt300@3:         (*spriter).setRestLength(0.0);
rt300@0:     }
rt300@3: 
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: int Mesh::getNearestLump(double ax, double ay){
rt300@0:     // not used yet
rt300@0: 	int nearestLumpIndex = -1;
rt300@0: 	TwoVector diff;
rt300@0: 	double distance = 1.0;
rt300@0: 	double minDistance = 1.0;
rt300@0: 
rt300@4: 	for(int i = 0; i<lumps.size(); i++){
rt300@0: 		diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0: 		distance = diff.norm();
rt300@0: 		if(distance < minDistance && !lumps[i].constrained){ // don't grab if constrained ?? 
rt300@0: 			minDistance = distance;
rt300@0: 			nearestLumpIndex = i;
rt300@0: 		}
rt300@0: 	}	
rt300@13:     //cout << "nearest lump : " << nearestLumpIndex << endl;
rt300@0:     
rt300@0: 	return nearestLumpIndex;
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::clearScanPath(){
rt300@0: 	// in between having clicked and drawn we can't play anything
rt300@3:     scanPath.clear();
rt300@0:     prevLump = -1;
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::disconnectDraw(){
rt300@0:     prevLump = -1;
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: int Mesh::inscribeScanPath(double ax, double ay){
rt300@0:     bool foundPath = false;
rt300@0:     int targetLump, intermediateLump; 
rt300@0:     int count = 0;
rt300@0:     TwoVector halfWay;
rt300@0:     // is this ridiculously complicated for no reason?
rt300@0:     
rt300@0:     targetLump = getNearestLump(ax,ay); // target is the one closest to touch point, prev is last point already on our path
rt300@0:     
rt300@4:     while(!foundPath && count < 10000){
rt300@0:         count++;
rt300@3:         if(prevLump == -1){ // (scanPath.howManyElements() == 0){ //
rt300@0:             //first lump
rt300@0:             foundPath = true;
rt300@0:             prevLump = targetLump;
rt300@0:             //cout << "first lump" << endl;
rt300@4:             lumps[targetLump].isScanPathStart = true;
rt300@0:             return targetLump;
rt300@0:         }
rt300@0:         // check if this lump connected to last lump by a spring
rt300@0:         Spring * connectedToPrev  = lumps[targetLump].checkConnectedTo(&lumps[prevLump]);
rt300@0:         
rt300@0:         // if not connectedToLast will be null
rt300@0:         if (!connectedToPrev){
rt300@0:             //cout << "setting half way" << endl;
rt300@0:             // set coords to 1/2 way and recurse
rt300@0:             double halfdiffx = ((ax-lumps[prevLump].position.x)*0.5);
rt300@0:             double halfdiffy = ((ay - lumps[prevLump].position.y)*0.5);
rt300@0:             if (halfdiffx < 0.0001 && halfdiffy < 0.0001){
rt300@0:                 // not found nuffun
rt300@0:                 //cout << "not found a path, quitting" << endl;
rt300@0:                 return -1;
rt300@0:             }
rt300@0:             halfWay.setCoord( ax - halfdiffx , ay -  halfdiffy);
rt300@0:             
rt300@0:             
rt300@0:             intermediateLump = inscribeScanPath(halfWay.x,halfWay.y);
rt300@0:             if(intermediateLump == -1){
rt300@0:                 //cout << "finding intermediate didn't work" << endl;
rt300@0:                 return -1;
rt300@0:             }
rt300@0:             // now check that the found intermediate targetLump is connected to the original targetlump 
rt300@0:             Spring * connectedToNext  = lumps[targetLump].checkConnectedTo(&lumps[prevLump]);
rt300@0:             if(!connectedToNext){
rt300@0:                 // set prevLump to the interm and try again
rt300@0:                 prevLump = intermediateLump;
rt300@0:                 targetLump = inscribeScanPath(ax,ay);
rt300@0:                 if(targetLump == -1){
rt300@0:                     //cout << "joining up next one didn't work" << endl;
rt300@0:                     return -1;
rt300@0:                 }
rt300@0:             }
rt300@0:         }else{
rt300@0:             //cout << "CONNECTED! adding an element" << endl;
rt300@0:             
rt300@0:             // hurrah, add the spring and lump to the scanpath in the right order...
rt300@0:             // get pointer to lump and spring
rt300@0:             
rt300@3:             scanPath.addElement(&lumps[targetLump], connectedToPrev);
rt300@4:             
rt300@4:             // indicate end
rt300@4:             lumps[prevLump].isScanPathEnd = false;
rt300@4:             lumps[targetLump].isScanPathEnd = true;
rt300@0:             // and set prev lump to that one
rt300@0:             prevLump = targetLump;
rt300@0:             foundPath = true;
rt300@0:             return targetLump; // 
rt300@0:         }
rt300@0:         
rt300@0:     }
rt300@0: 
rt300@0:     cout << "reached end of inscribe func" << endl;
rt300@0: 
rt300@0:     return -1;
rt300@0: }
rt300@0: 
rt300@8: // ---------------------------------------------------------------------------------------
rt300@8: 
rt300@8: 
rt300@8: 
rt300@0: void Mesh::hit(double dax, double day,int velocity, GlobalForces::excitationTypes aEType, GlobalForces::excitationShapes aEShape){
rt300@0:     // set filter to something low
rt300@0:     globalForces.homingAmt = 0.0;
rt300@0:     
rt300@0:     double radius = 0.1, distance; // size of lump
rt300@0:     double impactStrength = globalForces.excitationStrength*velocity/1000; // velocity as in note loudness
rt300@0:     double amt = 0.0;
rt300@0:     TwoVector diff;
rt300@0:     // get all the lumps and smack em
rt300@12:     int xamt = globalForces.exciteShapeX; // harmonic number of sine
rt300@0:     int yamt = globalForces.exciteShapeY;
rt300@0: 
rt300@0:     switch(aEShape){
rt300@0:     
rt300@0:         case GlobalForces::SINE:
rt300@0:             
rt300@0:             // applies a sine wave to all lumps, x and y
rt300@4:             for(int i = 0; i < lumps.size(); i++){
rt300@0:                 if(!lumps[i].constrained){
rt300@0:                     lumps[i].position.y = lumps[i].zeroRefPos.y + impactStrength*sin(PI* (2*(xamt-1) + 1) * lumps[i].position.x);
rt300@0:                     lumps[i].position.x = lumps[i].zeroRefPos.x + impactStrength*sin(PI* (2*(yamt-1) + 1) * lumps[i].position.y);
rt300@0:                 }
rt300@0:             }
rt300@0:             
rt300@0:             break;
rt300@0:         case GlobalForces::GAUSS:
rt300@0:             // temporarily not a gauss...
rt300@4:             for(int i = 0; i < lumps.size(); i++){
rt300@0:                 diff.setCoord(lumps[i].position.x - dax, lumps[i].position.y - day);
rt300@0:                 distance = diff.norm();
rt300@0:                 if(distance < radius){
rt300@0:                     amt = impactStrength*(1 + cos(PI*distance/radius)); // a 2d hamming.
rt300@0:                     lumps[i].position.y += amt;
rt300@0:                     
rt300@0:                 }     
rt300@0:             }
rt300@0:             break;
rt300@0:         case GlobalForces::NOISE:
rt300@0:             // 2D noise
rt300@4:             for(int i = 0; i < lumps.size(); i++){
rt300@0:                     lumps[i].position.x += impactStrength*rand();
rt300@0:                     lumps[i].position.y += impactStrength*rand();
rt300@0:                     
rt300@0:             }     
rt300@0:             break;
rt300@0:         default:
rt300@0:             break;
rt300@0:     }
rt300@0:     
rt300@0:     
rt300@0: }
rt300@0: 
rt300@0: void Mesh::spatialHarmonic(int aharm, int aharm2){
rt300@0:     double magdr,theta;
rt300@0:     TwoVector r, nr, centre, rhat, displacement;
rt300@0:     centre.setCoord(0.5, 0.5);
rt300@0:     // applies a sine wave to all lumps, x and y
rt300@0:     if(radial){
rt300@0:         // distance from centre is tweaked
rt300@4:         for(int i = 0; i < lumps.size(); i++){
rt300@0:             if(!lumps[i].constrained ){ //&& lumps[i].isInScanPath
rt300@0: 
rt300@0:                 // lots of sins and tans - might be simplifiable?
rt300@0:                 r = lumps[i].position - centre;
rt300@0:                 rhat = r.unitDir();
rt300@0:                 theta = atan2(r.y,r.x);
rt300@0:                 magdr = sin(aharm*theta);
rt300@0:                 
rt300@0:                 // new r for lump:
rt300@0:                 displacement = rhat * 0.1*globalForces.touchStrength*magdr;
rt300@0:                 lumps[i].position = lumps[i].position + displacement;
rt300@0:                 
rt300@0:             }
rt300@0:         }
rt300@0:     }else{
rt300@4:         for(int i = 0; i < lumps.size(); i++){
rt300@0:             if(!lumps[i].constrained){
rt300@1:                 lumps[i].position.y = lumps[i].zeroRefPos.y + globalForces.touchStrength/256.0*sin(PI* (2*(aharm-1) + 1) * lumps[i].position.x);
rt300@1:                 lumps[i].position.x = lumps[i].zeroRefPos.x + globalForces.touchStrength/256.0*sin(PI* (2*(aharm2-1) + 1) * lumps[i].position.y);
rt300@0:             }
rt300@0:         }
rt300@0:     }
rt300@0: }
rt300@0: 
rt300@0: void Mesh::damp(){
rt300@0:     // set friction and filters to something high
rt300@0:     //globalForces.avFilterAmt = 0.0;
rt300@0:     globalForces.homingAmt = 0.3;    
rt300@0: }
rt300@0: void Mesh::forceField(double dax,double day,double strength){
rt300@0:     
rt300@0:     // 
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: double Mesh::getNextSample(){
rt300@0: 
rt300@0: 	return 0.0;
rt300@0: 
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: // VIRTUAL
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::makeDefaultScanPath(){
rt300@9: 	// make 
rt300@0: 	cout << "!!!!Mesh base class makeDefaultScanPath\n";
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::setLumpPositions(){
rt300@0:     // places lumps in the right positions 
rt300@0: 	cout << "!!!!Mesh base class setLumpPositions\n";
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::makeConnections(){
rt300@0:     // connects the lmps and springs. the spring needs to know which lumps are at each end
rt300@0:     // and lumps need to know which springs attached
rt300@0:     // calls connect method that does this
rt300@0: 	cout << "!!!!Mesh base class make connections\n";
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@9: void Mesh::makeComponents(int numLumps, int numSprings){
rt300@9:     // does not need to know what shape we're in to set up the right number of lumps and springs
rt300@0: 	cout << "!!!!Mesh base class makeComponents\n";
rt300@9:     
rt300@9:     //lumps = new Lump[numLumps];
rt300@9:     lumps = vector<Lump>(numLumps);
rt300@9: 	cout << "made " << numLumps << " lumps\n";
rt300@9: 	
rt300@9:     // one by one
rt300@9:     springs = vector<Spring>(numSprings);
rt300@9:     
rt300@9: 	cout << "made " << numSprings << " springs\n";
rt300@9:     
rt300@9:     // tell them what index they are (for connections)
rt300@9:     for(int i = 0; i<lumps.size(); i++){
rt300@9:         lumps[i].myIndexInMesh = i;
rt300@9:     }
rt300@9:     for(int i = 0; i<springs.size(); i++){
rt300@9:         springs[i].myIndexInMesh = i;
rt300@9:     }
rt300@9:     
rt300@9:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void Mesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	cout << "!!!!Mesh base class constrain\n";
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: /****************************************/
rt300@9: //		SquareMesh					*/
rt300@0: /****************************************/
rt300@0: //--------------------------------------------------------------
rt300@9: SquareMesh::SquareMesh(): Mesh() {
rt300@9:     // the default is called from derived classes
rt300@9:     radial = false;
rt300@9: 	cout << "default constructor SQUARE mesh\n";
rt300@9: }
rt300@9: //---------------------------------------------------------------
rt300@9: SquareMesh::SquareMesh(int height, int width): Mesh() {
rt300@9:     // this one called when no derived class
rt300@9: 	meshType = SQUARE_MESH;
rt300@0: 	makeComponents(height, width);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0: 	
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@0:     constrain(0,0,CONSTRAIN_EDGES_XY);
rt300@0:     
rt300@0:     zeroRestLength();
rt300@0:     
rt300@0:     radial = false;
rt300@0: 	
rt300@0: 	cout << "constructing SQUARE mesh\n";
rt300@0: }
rt300@9: SquareMesh::~SquareMesh(){
rt300@0: 	
rt300@9: 	cout << "destructing SQUARE mesh\n";
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: // make componets for square
rt300@9: void SquareMesh::makeComponents(int aheight, int awidth){
rt300@1:     
rt300@9:     
rt300@0: 	height = aheight;
rt300@0: 	width = awidth;
rt300@0: 	numLumps = height * width;
rt300@9:     // horz             // vert             // criss cross
rt300@0: 	numSprings = (width-1)*height + (height-1)*width + 2*(height-1)*(width-1);
rt300@0: 	
rt300@9:     Mesh::makeComponents(numLumps, numSprings); // kinda wierd but works.
rt300@3:     
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@9: void SquareMesh::setLumpPositions(){
rt300@9:     // numbering works line by line like text, analogue tv's etc
rt300@0: 	double vspacing = 1.0/(height-1);
rt300@0: 	double hspacing = 1.0/(width-1);
rt300@0: 	int i =0;
rt300@0: 	// set positions
rt300@0: 	for(int row = 0; row < height; row++){ // go down column
rt300@0: 		for(int col = 0;col < width; col++){ // go along row
rt300@4:             if(i >= lumps.size()){
rt300@1:                 cout << " setLumpPosisions index error!\n";
rt300@1:             }
rt300@0: 			lumps[i].setPosition(hspacing*col,vspacing*row);
rt300@0: 			
rt300@0: 			i++;
rt300@0: 		}
rt300@0: 	}
rt300@9:     
rt300@9: }
rt300@9: //--------------------------------------------------------------
rt300@9: void SquareMesh::makeConnections(){
rt300@9: 	
rt300@9: 	// could be cleverer in terms of numbering?
rt300@9: 	int lumpnum = 0;
rt300@9: 	int springnum = 0;
rt300@9: 	// attach horizontal
rt300@9: 	for ( int i=0;i<height;i++){
rt300@9: 		for(int j=0;j<width-1;j++){
rt300@9: 			connect(springnum,lumpnum);
rt300@9: 			lumpnum++;
rt300@9:             if(springnum >= numSprings){
rt300@9:                 cout << " makeConnections index error!\n";
rt300@9:             }
rt300@9:             if(lumpnum >= lumps.size()){
rt300@9:                 cout << " makeConnections index error!\n";
rt300@9:             }
rt300@9: 			connect(springnum,lumpnum);
rt300@9: 			springnum++;
rt300@9: 			
rt300@9: 		}
rt300@9: 		lumpnum++;
rt300@9: 	}
rt300@9:     cout << "lumps attach horz: " << lumpnum-1 << ", spring " << springnum-1 << "\n";
rt300@9: 	// attach vertical
rt300@9: 	lumpnum = 0;
rt300@9: 	for ( int i=0;i<width;i++){
rt300@9: 		for(int j=0;j<height-1;j++){
rt300@9: 			connect(springnum,lumpnum);
rt300@9: 			lumpnum+=width;
rt300@9:             if(springnum >= numSprings){
rt300@9:                 cout << " makeConnections index error!\n";
rt300@9:             }
rt300@9:             if(lumpnum >= lumps.size()){
rt300@9:                 cout << " makeConnections index error!\n";
rt300@9:             }
rt300@9: 			connect(springnum,lumpnum);
rt300@9: 			springnum++;
rt300@9: 			
rt300@9: 		}
rt300@9: 		lumpnum -= (width*(height-1)) - 1;
rt300@9: 	}
rt300@1: 
rt300@0: }
rt300@9: 
rt300@9: //--------------------------------------------------------------
rt300@9: void SquareMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@9: 	
rt300@9: 	TwoVector diff;
rt300@9: 	int i = 0;
rt300@9: 	
rt300@9: 	// check if lump is within grab range
rt300@9: 	switch (aMode) {
rt300@9: 		case CONSTRAIN_GRAB_REGION:
rt300@9: 			for(i = 0; i<lumps.size(); i++){
rt300@9: 				
rt300@9: 				diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@9: 				
rt300@9: 				if (diff.norm() < GRAB_RANGE){
rt300@9:                     if(i >= lumps.size()){
rt300@9:                         cout << "constrain index error\n";
rt300@9:                     }
rt300@9: 					lumps[i].constrain();
rt300@9: 				}
rt300@9: 			}
rt300@9: 			break;
rt300@9: 		case CONSTRAIN_EDGES:
rt300@9: 			i = 0;
rt300@9: 			for(int row = 0; row < height; row++){ // go down column
rt300@9: 				for(int col = 0;col < width; col++){ // go along row
rt300@9: 					if(row == 0 || row == height-1 || col == 0 || col == width-1){
rt300@9:                         if(i >= lumps.size()){
rt300@9:                             cout << "constrain index error\n";
rt300@9:                         }
rt300@9: 						lumps[i].constrain();
rt300@9: 					}
rt300@9: 					i++;
rt300@9: 				}
rt300@9: 			}
rt300@9: 			break;
rt300@9: 		case CONSTRAIN_EDGES_XY:
rt300@9: 			i = 0;
rt300@9: 			for(int row = 0; row < height; row++){ // go down column
rt300@9: 				for(int col = 0;col < width; col++){ // go along row
rt300@9: 					if(row == 0 || row == height-1){
rt300@9:                         if(i >= lumps.size()){
rt300@9:                             cout << "constrain index error\n";
rt300@9:                         }
rt300@9: 						lumps[i].constrain(Lump::CONSTRAIN_Y);
rt300@9: 					}else if( col == 0 || col == width-1){
rt300@9:                         if(i >= lumps.size()){
rt300@9:                             cout << "constrain index error\n";
rt300@9:                         }
rt300@9:                         lumps[i].constrain(Lump::CONSTRAIN_X);
rt300@9:                     }
rt300@9: 					i++;
rt300@9: 				}
rt300@9: 			}
rt300@9: 			break;
rt300@9: 		case CONSTRAIN_CORNERS:
rt300@9: 			i = 0;
rt300@9: 			for(int row = 0; row < height; row++){ // go down column
rt300@9: 				for(int col = 0;col < width; col++){ // go along row
rt300@9: 					if(   (row == 0 && col == 0)
rt300@9: 					   || (row == height-1 && col == 0)
rt300@9: 					   || (row == 0 && col == width-1)
rt300@9: 					   || (row == height-1 && col == width-1)){
rt300@9:                         if(i >= lumps.size()){
rt300@9:                             cout << "constrain index error\n";
rt300@9:                         }
rt300@9: 						lumps[i].constrain();
rt300@9: 					}
rt300@9: 					i++;
rt300@9: 				}
rt300@9: 			}
rt300@9: 			break;
rt300@9: 			
rt300@9: 		default:
rt300@9: 			break;
rt300@9: 	}
rt300@9: 	
rt300@9: }
rt300@9: 
rt300@9: //--------------------------------------------------------------
rt300@9: void SquareMesh::makeDefaultScanPath(){
rt300@9:     if (height < 10 || width < 10) return; // not much point
rt300@9:     
rt300@9:     int vmarg = 5;
rt300@9:     int hmarg = 5;
rt300@9:     
rt300@9:     int lumpno = vmarg * width + hmarg; // top left corner
rt300@9:     int springno = vmarg * (width - 1) + hmarg;
rt300@9:     // do top horz
rt300@9:     for(int i = 0; i < width - 2*hmarg; i++){
rt300@9:         if(lumpno >= lumps.size()) cout << "makeDefaultScanPath index error\n";
rt300@9:         if(springno >= numSprings) cout << "makeDefaultScanPath index error\n";
rt300@9:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@9:         lumpno++;
rt300@9:         springno++;
rt300@9:     }
rt300@9:     
rt300@9:     // do right vert, lumpno starts the same
rt300@9:     // all horz spr    // left marg rows      // top margin
rt300@9:     springno  = height*(width-1) + ((height-1) * (width - hmarg)) + vmarg;
rt300@9:     
rt300@9:     for(int i = 0; i < height - (2 * vmarg); i++){
rt300@9:         if(lumpno >= lumps.size()) cout << "makeDefaultScanPath index error\n";
rt300@9:         if(springno >= numSprings) cout << "makeDefaultScanPath index error\n";
rt300@9:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@9:         springno++; // jump to next row
rt300@9:         lumpno += width;   // ditto
rt300@9:     }
rt300@9:     
rt300@9:     
rt300@9:     // do bottom horz right to left
rt300@9:     springno = (height - vmarg) * (width - 1) + (width - hmarg - 1);
rt300@9:     for(int i = 0; i < width - 2*hmarg; i++){
rt300@9:         if(lumpno >= lumps.size()) cout << "makeDefaultScanPath index error\n";
rt300@9:         if(springno >= numSprings) cout << "makeDefaultScanPath index error\n";
rt300@9:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@9:         springno--; // jump to next row
rt300@9:         lumpno--;   // ditto
rt300@9:     }
rt300@9:     
rt300@9:     // all horz spr    // left marg rows    // top margin
rt300@9:     springno  = height*(width-1) + ((height-1) * hmarg) +  height - vmarg - 1;
rt300@9:     for(int i = 0; i < height - 2 * vmarg; i++){
rt300@9:         if(lumpno >= lumps.size()) cout << "makeDefaultScanPath index error\n";
rt300@9:         if(springno >= numSprings) cout << "makeDefaultScanPath index error\n";
rt300@9:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@9:         springno--; // jump to next row
rt300@9:         lumpno -= width;   // ditto
rt300@9:     }
rt300@9:     
rt300@9: }
rt300@9: //--------------------------------------------------------------
rt300@9: 
rt300@9: /****************************************/
rt300@9: //		SquareCrossMesh					*/
rt300@9: /****************************************/
rt300@9: //--------------------------------------------------------------
rt300@9: SquareCrossMesh::SquareCrossMesh(int height, int width){
rt300@9:     
rt300@9: 	meshType = SQUARE_CROSS_MESH;
rt300@9: 	makeComponents(height, width);
rt300@9: 	
rt300@9: 	setLumpPositions();
rt300@9: 	
rt300@9: 	makeConnections();
rt300@9: 	
rt300@9: 	makeDefaultScanPath();
rt300@9:     
rt300@9:     constrain(0,0,CONSTRAIN_EDGES);
rt300@9:     
rt300@9:     zeroRestLength();
rt300@9:     
rt300@9:     radial = false;
rt300@9: 	
rt300@9: 	cout << "constructing SQUARECROSS mesh\n";
rt300@9: }
rt300@9: SquareCrossMesh::~SquareCrossMesh(){
rt300@9: 	
rt300@9: 	cout << "destructing SQUARECROSS mesh\n";
rt300@9: }
rt300@9: 
rt300@0: //--------------------------------------------------------------
rt300@0: void SquareCrossMesh::makeConnections(){
rt300@0: 	
rt300@0: 	// could be cleverer in terms of numbering?
rt300@0: 	int lumpnum = 0;
rt300@0: 	int springnum = 0;
rt300@0: 	// attach horizontal 
rt300@0: 	for ( int i=0;i<height;i++){
rt300@0: 		for(int j=0;j<width-1;j++){
rt300@0: 			connect(springnum,lumpnum);
rt300@0: 			lumpnum++;
rt300@1:             if(springnum >= numSprings){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@4:             if(lumpnum >= lumps.size()){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@0: 			connect(springnum,lumpnum);
rt300@0: 			springnum++;
rt300@0: 			
rt300@0: 		}
rt300@0: 		lumpnum++;
rt300@0: 	}
rt300@1:     cout << "lumps attach horz: " << lumpnum-1 << ", spring " << springnum-1 << "\n";
rt300@0: 	// attach vertical 
rt300@0: 	lumpnum = 0;
rt300@0: 	for ( int i=0;i<width;i++){
rt300@0: 		for(int j=0;j<height-1;j++){
rt300@0: 			connect(springnum,lumpnum);
rt300@0: 			lumpnum+=width;
rt300@1:             if(springnum >= numSprings){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@4:             if(lumpnum >= lumps.size()){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@0: 			connect(springnum,lumpnum);
rt300@0: 			springnum++;
rt300@0: 			
rt300@0: 		}
rt300@0: 		lumpnum -= (width*(height-1)) - 1;
rt300@0: 	}	
rt300@0: 	// attach diagonal
rt300@0: 	lumpnum = 0;
rt300@0: 	for ( int i=0;i<width-1;i++){
rt300@0: 		for(int j=0;j<height-1;j++){
rt300@0: 			connect(springnum,lumpnum);
rt300@0: 			lumpnum+=(width);
rt300@1:             if(springnum >= numSprings){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@4:             if(lumpnum >= lumps.size()){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@0: 			connect(springnum,lumpnum+1);
rt300@0: 			springnum++;
rt300@0: 			
rt300@0: 		}
rt300@0: 		lumpnum -= (width*(height-1)) - 1;
rt300@0: 	}	
rt300@0: 	// attach other diagonal
rt300@0: 	lumpnum = 1;
rt300@0: 	for ( int i=0;i<width-1;i++){
rt300@0: 		for(int j=0;j<height-1;j++){
rt300@0: 			connect(springnum,lumpnum);
rt300@0: 			lumpnum+=(width);
rt300@1:             if(springnum >= numSprings){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@4:             if(lumpnum >= lumps.size()){
rt300@1:                 cout << " makeConnections index error!\n";
rt300@1:             }
rt300@0: 			connect(springnum,lumpnum-1);
rt300@0: 			springnum++;
rt300@0: 			
rt300@0: 		}
rt300@0: 		lumpnum -= (width*(height-1)) - 1;
rt300@0: 	}	
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@9: 
rt300@0: //--------------------------------------------------------------
rt300@0: 
rt300@0: 
rt300@0: /****************************************/
rt300@0: //		SpiderMesh					*/
rt300@0: /****************************************/
rt300@0: SpiderMesh::SpiderMesh(int aNumSpokes,int aNumRings) : Mesh(){
rt300@8:     meshType = SPIDER_MESH;
rt300@8:     
rt300@0: 	numSpokes = aNumSpokes;
rt300@0: 	numRings = aNumRings;
rt300@0:     
rt300@0:     radial = true;
rt300@0: 	
rt300@0: 	makeComponents(numSpokes, numRings);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0: 
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@0:     constrain(0.0,0.0,CONSTRAIN_EDGES);
rt300@0:     constrain(0.0,0.0,CONSTRAIN_CORNERS);
rt300@0: 	
rt300@0: 	cout << "constructed SPIDER mesh\n";
rt300@0: 	
rt300@0: 	
rt300@0: 	
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void SpiderMesh::makeComponents(int aDimension1, int aDimension2){
rt300@0:     // make componets creates the correct number of lumps and springs according to dimensions and mesh type
rt300@0: 	cout << "!!!spider makeComponents\n";
rt300@0: 	numLumps = numSpokes * numRings + 1; // +1 cos one in the middle
rt300@0: 	numSprings = 2 * numSpokes * numRings;
rt300@0: 	
rt300@4: 	//lumps = new Lump[numLumps];
rt300@4: 	lumps = vector<Lump>(numLumps);
rt300@4:     cout << "made " << numLumps << " lumps\n";
rt300@3: 	springs = vector<Spring>(numSprings);
rt300@3:     
rt300@0: 	cout << "made " << numSprings << " springs\n";	
rt300@0: 	
rt300@0: 				
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void SpiderMesh::setLumpPositions(){
rt300@0: 	cout << "!spider setLumpPositions\n";
rt300@0: 	// here we're assuming that zero spoke is to right
rt300@0: 	// work out sines / cosines for each spoke
rt300@0: 	int l = 1;
rt300@0: 	double hyplen,xpos,ypos;
rt300@0: 	
rt300@0: 	double * cosines = new double[numSpokes];
rt300@0: 	double * sines = new double[numSpokes];
rt300@0: 	double angle = 2 * PI / numSpokes;
rt300@0: 	
rt300@0: 	double ringSpacing = 1.0/(2*numRings);
rt300@0: 	
rt300@0: 	for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 		cosines[spoke] = cos(angle*spoke);
rt300@0: 		sines[spoke] = sin(angle*spoke);
rt300@0: 	}
rt300@0: 		
rt300@0: 	lumps[0].setPosition(0.5,0.5);
rt300@0: 
rt300@0: 	for(int ring = 0; ring < numRings; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 			hyplen = ringSpacing * (ring+1);
rt300@0: 			xpos = hyplen * cosines[spoke] + 0.5;
rt300@0: 			ypos = hyplen*sines[spoke] + 0.5;
rt300@0: 			lumps[l].setPosition(xpos,ypos);
rt300@0: 			l++;
rt300@0: 			
rt300@0: 		}
rt300@0: 	}
rt300@0: 	delete [] cosines;
rt300@0: 	delete [] sines;
rt300@0: 			
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void SpiderMesh::makeConnections(){
rt300@0: 	// TODO needs to be rewritten to automatically 
rt300@0: 	// add in lumps and springs AS we're connecting
rt300@0: 	//using std vector
rt300@0: 	// this is dumb
rt300@0: 	cout << "!!!spider make connections\n";
rt300@0: 
rt300@0: 	// UNLIKE a spider we're going to make rings first, to make indexing the scan path easier...
rt300@0: 
rt300@0: 	for(int ring = 0; ring < numRings; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes-1; spoke++){
rt300@0: 			//		spring ,				lump
rt300@0: 			connect(numSpokes*ring + spoke, ring*numSpokes + spoke + 1);
rt300@0: 			connect(numSpokes*ring + spoke, ring*numSpokes + spoke + 2);
rt300@0: 		}
rt300@0: 		// remember the last one on the ring goes back to first
rt300@0: 		//		spring ,						lump
rt300@0: 		connect(numSpokes*ring + numSpokes - 1 , ring*numSpokes + numSpokes);
rt300@0: 		connect(numSpokes*ring + numSpokes - 1,  ring*numSpokes + 1);
rt300@0: 	}	
rt300@0: 	// at which point we have used numSpokes*numRings springs
rt300@0: 	int used = numSpokes*numRings;
rt300@0: 	// first ring is different cos it connects to central point
rt300@0: 	for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 		connect(used,0); // inner radial on center
rt300@0: 		connect(used,spoke+1);  // outer radial
rt300@0: 		springs[used].setRestLength(0.0); // need tension on spokes
rt300@0: 		used++;
rt300@0: 	}
rt300@0: 	// now do the rest of the radial spokes
rt300@0: 	for(int ring = 0; ring < numRings-1; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 			connect(used,ring*numSpokes+1+spoke); // 
rt300@0: 			connect(used,(ring+1)*numSpokes+1+spoke);  // going to next ring out
rt300@0: 			springs[used].setRestLength(0.0);
rt300@0: 			used++;
rt300@0: 		}
rt300@0: 	}
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void SpiderMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	cout << "!!spider constrain\n";
rt300@0: 	
rt300@0: 	TwoVector diff;
rt300@0: 	int i = 0;
rt300@0: 	
rt300@0: 	// check if lump is within grab range
rt300@0: 	switch (aMode) {
rt300@0: 		case CONSTRAIN_GRAB_REGION:
rt300@4: 			for(i = 0; i<lumps.size(); i++){
rt300@0: 				
rt300@0: 				diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0: 				
rt300@0: 				if (diff.norm() < GRAB_RANGE){
rt300@0: 					lumps[i].constrain();
rt300@0: 				}
rt300@0: 			}
rt300@0: 			break;
rt300@0: 		case CONSTRAIN_EDGES:
rt300@0: 		{
rt300@0: 			// constrain outer ring
rt300@0: 			int startLump = numSpokes*(numRings-1) + 1;
rt300@0: 			for(int l = startLump; l < startLump + numSpokes; l++){
rt300@0: 				lumps[l].constrain();
rt300@0: 			}
rt300@0: 	
rt300@0: 			break;
rt300@0: 		}
rt300@0: 		case CONSTRAIN_CORNERS:
rt300@0: 			// er... constrain the centre
rt300@0: 			lumps[0].constrain();
rt300@0: 			
rt300@0: 			break;
rt300@0: 			
rt300@0: 		default:
rt300@0: 			break;
rt300@0: 	}
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: 
rt300@0: void SpiderMesh::makeDefaultScanPath(){
rt300@0: 	
rt300@0: 	cout << "!!spider makeDefaultScanPath\n";
rt300@0:     
rt300@5:     /*
rt300@5:     // add a all inner rings to the path
rt300@5:     
rt300@5:     
rt300@0:     int ringNo = ceil(numRings/2.0);
rt300@0:     int springno = 0, lumpno = 0;
rt300@0:     for(int i = 0; i < numSpokes; i++){
rt300@0:         lumpno = numSpokes*ringNo + 1 + i;
rt300@0:         springno = numSpokes*ringNo + i;
rt300@3:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@0:     }
rt300@0:     cout << "!!spider scan path created on ring " << ringNo << "\n";
rt300@5:      */
rt300@5:     
rt300@0:     // add a spoke to the path
rt300@5: 
rt300@0:     int springno = 0, lumpno = 0;
rt300@0:     
rt300@0:     int springsinrings = numSpokes*numRings;
rt300@0:     for(int i = 0; i < numRings-1; i++){
rt300@0:         lumpno = numSpokes*i; // zero, numspokes etc
rt300@5:         springno = springsinrings + numSpokes*i -1; // starts from total rings, increments by numspokes etc
rt300@5:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@5:     }
rt300@5:     
rt300@5:     for(int i = 0; i < numRings-1; i++){
rt300@5:         lumpno = numSpokes*i + 1; // zero, numspokes etc
rt300@0:         springno = springsinrings + numSpokes*i; // starts from total rings, increments by numspokes etc
rt300@3:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@5:     }
rt300@5:     /*
rt300@5:     for(int i = numRings-2; i >= 0 ; i--){
rt300@5:         lumpno = numSpokes*i; // zero, numspokes etc
rt300@5:         springno = springsinrings + numSpokes*i; // starts from total rings, increments by numspokes etc
rt300@5:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@5:     }
rt300@5:      */
rt300@5: 
rt300@0:  }
rt300@0: 
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: /****************************************/
rt300@0: //		Holed Spider    Mesh            */
rt300@0: /****************************************/
rt300@0: //--------------------------------------------------------------
rt300@0: HoledSpiderMesh::HoledSpiderMesh(int aNumSpokes,int aNumRings) : Mesh(){
rt300@8:     meshType = HOLED_SPIDER_MESH;
rt300@0: 	numSpokes = aNumSpokes;
rt300@0: 	numRings = aNumRings;
rt300@0:     radial = true;
rt300@0: 	
rt300@0: 	makeComponents(numSpokes, numRings);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0:     
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@0:     constrain(0.0,0.0,CONSTRAIN_EDGES);
rt300@0:     constrain(0.0,0.0,CONSTRAIN_CORNERS);
rt300@0: 	
rt300@0: 	cout << "constructed SPIDER mesh\n";
rt300@0: }
rt300@0: 
rt300@0: void HoledSpiderMesh::makeComponents(int aDimension1, int aDimension2){
rt300@0:     // make componets creates the correct number of lumps and springs according to dimensions and mesh type
rt300@0: 	cout << "HOLED spider makeComponents\n";
rt300@0: 	numLumps = numSpokes * numRings; 
rt300@0: 	numSprings = numSpokes * numRings + numSpokes * (numRings - 1);
rt300@0: 	
rt300@4: 	lumps = vector<Lump>(numLumps);
rt300@4:     cout << "made " << numLumps << " lumps\n";
rt300@3: 	springs = vector<Spring>(numSprings);
rt300@0: 	cout << "made " << numSprings << " springs\n";	
rt300@0: 	
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void HoledSpiderMesh::setLumpPositions(){
rt300@0: 	cout << "HOLED spider setLumpPositions\n";
rt300@0: 	// here we're assuming that zero spoke is to right
rt300@0: 	// work out sines / cosines for each spoke
rt300@0: 	int l = 0;
rt300@0: 	double hyplen,xpos,ypos;
rt300@0: 	
rt300@0: 	double * cosines = new double[numSpokes];
rt300@0: 	double * sines = new double[numSpokes];
rt300@0: 	double angle = 2 * PI / numSpokes;
rt300@0: 	
rt300@0: 	double ringSpacing = 1.0/(2*numRings);
rt300@0: 	
rt300@0: 	for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 		cosines[spoke] = cos(angle*spoke);
rt300@0: 		sines[spoke] = sin(angle*spoke);
rt300@0: 	}
rt300@0:     
rt300@0: 	for(int ring = 0; ring < numRings; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 			hyplen = ringSpacing * (ring+1);
rt300@0: 			xpos = hyplen * cosines[spoke] + 0.5;
rt300@0: 			ypos = hyplen*sines[spoke] + 0.5;
rt300@0: 			lumps[l].setPosition(xpos,ypos);
rt300@0: 			l++;
rt300@0: 			
rt300@0: 		}
rt300@0: 	}
rt300@0: 	delete [] cosines;
rt300@0: 	delete [] sines;
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void HoledSpiderMesh::makeConnections(){
rt300@0: 	// TODO needs to be rewritten to automatically 
rt300@0: 	// add in lumps and springs AS we're connecting
rt300@0: 	//using std vector
rt300@0: 	// this is dumb
rt300@0: 	cout << "HOLED spider make connections\n";
rt300@0:     
rt300@0: 	// UNLIKE a spider we're going to make rings first, to make indexing the scan path easier...
rt300@0:     
rt300@0: 	for(int ring = 0; ring < numRings; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes-1; spoke++){
rt300@0: 			//		spring ,				lump
rt300@0: 			connect(numSpokes*ring + spoke, ring*numSpokes + spoke + 0);
rt300@0: 			connect(numSpokes*ring + spoke, ring*numSpokes + spoke + 1);
rt300@0: 		}
rt300@0: 		// remember the last one on the ring goes back to first
rt300@0: 		//		spring ,						lump
rt300@0: 		connect(numSpokes*ring + numSpokes - 1 , ring*numSpokes + numSpokes - 1);
rt300@0: 		connect(numSpokes*ring + numSpokes - 1,  ring*numSpokes);
rt300@0: 	}	
rt300@0: 	// at which point we have used numSpokes*numRings springs
rt300@0: 	int used = numSpokes*numRings;
rt300@0: 	// now do the rest of the radial spokes
rt300@0: 	for(int ring = 0; ring < numRings-1; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 			connect(used,ring*numSpokes+spoke); // 
rt300@0: 			connect(used,(ring+1)*numSpokes+spoke);  // going to next ring out
rt300@0: 			springs[used].setRestLength(0.0);
rt300@0: 			used++;
rt300@0: 		}
rt300@0: 	}
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void HoledSpiderMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	cout << "HOLED spider constrain\n";
rt300@0: 	
rt300@0: 	TwoVector diff;
rt300@0: 	int i = 0;
rt300@0: 	int startLump = 0;
rt300@0: 	// check if lump is within grab range
rt300@0: 	switch (aMode) {
rt300@0: 		case CONSTRAIN_GRAB_REGION:
rt300@4: 			for(i = 0; i<lumps.size(); i++){
rt300@0: 				
rt300@0: 				diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0: 				
rt300@0: 				if (diff.norm() < GRAB_RANGE){
rt300@0: 					lumps[i].constrain();
rt300@0: 				}
rt300@0: 			}
rt300@0: 			break;
rt300@0: 		case CONSTRAIN_EDGES:
rt300@0: 		{
rt300@0: 			// constrain outer ring
rt300@0: 			startLump = numSpokes*(numRings-1);
rt300@0: 			for(int l = startLump; l < startLump + numSpokes; l++){
rt300@0: 				lumps[l].constrain();
rt300@0: 			}
rt300@0:             
rt300@0: 			break;
rt300@0: 		}
rt300@0: 		case CONSTRAIN_CORNERS:
rt300@0: 			// constrain inner ring
rt300@0: 			
rt300@0: 			for(int l = startLump; l < startLump + numSpokes; l++){
rt300@0: 				lumps[l].constrain();
rt300@0: 			}
rt300@0:             
rt300@0: 			break;
rt300@0: 			
rt300@0: 		default:
rt300@0: 			break;
rt300@0: 	}
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: 
rt300@0: void HoledSpiderMesh::makeDefaultScanPath(){
rt300@0: 	
rt300@0: 	cout << "HOLED spider makeDefaultScanPath\n";
rt300@0:     
rt300@0:      // add a ring to the path
rt300@0:      int ringNo = floor(numRings/2.0);
rt300@0:      int springno = 0, lumpno = 0;
rt300@0:      for(int i = 0; i < numSpokes; i++){
rt300@0:          lumpno = numSpokes*ringNo + i;
rt300@0:          springno = numSpokes*ringNo + i;
rt300@0:          
rt300@3:          scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@0:      }
rt300@0:      cout << "HOLED spider scan path created on ring " << ringNo << "\n";
rt300@0:      
rt300@0:     // add a spoke to the path
rt300@0:     /*
rt300@0:     int springno = 0, lumpno = 0;
rt300@0:     
rt300@0:     int springsinrings = numSpokes*numRings;
rt300@0:     for(int i = 0; i < numRings-1; i++){
rt300@0:         lumpno = numSpokes*i; // zero, numspokes etc
rt300@0:         springno = springsinrings + numSpokes*i; // starts from total rings, increments by numspokes etc
rt300@3:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@0:     } 
rt300@0:      */
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: /****************************************/
rt300@0: //		Holed Spider Cross   Mesh            */
rt300@0: /****************************************/
rt300@0: //--------------------------------------------------------------
rt300@0: SpiderCrossMesh::SpiderCrossMesh(int aNumSpokes,int aNumRings) : Mesh(){
rt300@8:     meshType = SPIDER_CROSS_MESH;
rt300@0: 	numSpokes = aNumSpokes;
rt300@0: 	numRings = aNumRings;
rt300@0:     radial = true;
rt300@0: 	
rt300@0: 	makeComponents(numSpokes, numRings);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0:     
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@0:     constrain(0.0,0.0,CONSTRAIN_EDGES);
rt300@0:     constrain(0.0,0.0,CONSTRAIN_CORNERS);
rt300@0: 	
rt300@0: 	cout << "constructed SpiderCrossMesh mesh\n";
rt300@0: }
rt300@0: 
rt300@0: void SpiderCrossMesh::makeComponents(int aDimension1, int aDimension2){
rt300@0:     // make componets creates the correct number of lumps and springs according to dimensions and mesh type
rt300@0: 	cout << "SpiderCrossMesh spider makeComponents\n";
rt300@0: 	numLumps = numSpokes * numRings; 
rt300@0:                 // rings                // spokes  & diags
rt300@0: 	numSprings = numSpokes * numRings + 3 * numSpokes * (numRings - 1);
rt300@0: 	
rt300@9: 	Mesh::makeComponents(numLumps, numSprings);
rt300@0: 	
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void SpiderCrossMesh::setLumpPositions(){
rt300@0: 	cout << "SpiderCrossMesh spider setLumpPositions\n";
rt300@0: 	// here we're assuming that zero spoke is to right
rt300@0: 	// work out sines / cosines for each spoke
rt300@0: 	int l = 0;
rt300@0: 	double hyplen,xpos,ypos;
rt300@0: 	
rt300@0: 	double * cosines = new double[numSpokes];
rt300@0: 	double * sines = new double[numSpokes];
rt300@0: 	double angle = 2 * PI / numSpokes;
rt300@0: 	
rt300@0: 	double ringSpacing = 1.0/(2*numRings);
rt300@0: 	
rt300@0: 	for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 		cosines[spoke] = cos(angle*spoke);
rt300@0: 		sines[spoke] = sin(angle*spoke);
rt300@0: 	}
rt300@0:     
rt300@0: 	for(int ring = 0; ring < numRings; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 			hyplen = ringSpacing * (ring+1);
rt300@0: 			xpos = hyplen * cosines[spoke] + 0.5;
rt300@0: 			ypos = hyplen*sines[spoke] + 0.5;
rt300@0: 			lumps[l].setPosition(xpos,ypos);
rt300@0: 			l++;
rt300@0: 			
rt300@0: 		}
rt300@0: 	}
rt300@0: 	delete [] cosines;
rt300@0: 	delete [] sines;
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void SpiderCrossMesh::makeConnections(){
rt300@0: 
rt300@0: 	cout << "SpiderCrossMesh spider make connections\n";
rt300@0:     
rt300@0: 	// UNLIKE a spider we're going to make rings first, to make indexing the scan path easier...
rt300@0:     
rt300@0: 	for(int ring = 0; ring < numRings; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes-1; spoke++){
rt300@0: 			//		spring ,				lump
rt300@0: 			connect(numSpokes*ring + spoke, ring*numSpokes + spoke + 0);
rt300@0: 			connect(numSpokes*ring + spoke, ring*numSpokes + spoke + 1);
rt300@0: 		}
rt300@0: 		// remember the last one on the ring goes back to first
rt300@0: 		//		spring ,						lump
rt300@0: 		connect(numSpokes*ring + numSpokes - 1 , ring*numSpokes + numSpokes - 1);
rt300@0: 		connect(numSpokes*ring + numSpokes - 1,  ring*numSpokes);
rt300@0: 	}	
rt300@0: 	// at which point we have used numSpokes*numRings springs
rt300@0: 	int used = numSpokes*numRings;
rt300@0:     
rt300@0: 	// now do radial spokes
rt300@0: 	for(int ring = 0; ring < numRings-1; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes; spoke++){
rt300@0: 			connect(used,ring*numSpokes+spoke); // 
rt300@0: 			connect(used,(ring+1)*numSpokes+spoke);  // going to next ring out
rt300@0: 			springs[used].setRestLength(0.0);
rt300@0: 			used++;
rt300@0: 		}
rt300@0: 	}
rt300@0:     // now do diag /
rt300@0:     for(int ring = 0; ring < numRings-1; ring++){
rt300@0: 		for(int spoke = 0; spoke < numSpokes-1; spoke++){
rt300@0: 			connect(used,ring*numSpokes+spoke,(ring+1)*numSpokes+spoke+1); // 
rt300@0: 			springs[used].setRestLength(0.0);
rt300@0: 			used++;
rt300@0: 		}
rt300@0:         connect(used,ring*numSpokes+numSpokes-1,(ring+1)*numSpokes); // wrap to first 
rt300@0:         springs[used].setRestLength(0.0);
rt300@0:         used++;
rt300@0: 	}
rt300@0:     
rt300@0:     // now do \ diag
rt300@0:     for(int ring = 0; ring < numRings-1; ring++){
rt300@0:         connect(used,ring*numSpokes,(ring+1)*numSpokes+numSpokes-1); // wrap first to last 
rt300@0:         springs[used].setRestLength(0.0);
rt300@0:         used++;
rt300@0: 		for(int spoke = 1; spoke < numSpokes; spoke++){
rt300@0: 			connect(used,ring*numSpokes+spoke,(ring+1)*numSpokes+spoke-1); // 
rt300@0: 			springs[used].setRestLength(0.0);
rt300@0: 			used++;
rt300@0: 		}
rt300@0: 
rt300@0: 	}
rt300@0:     cout << "used: " << used << " numSprings: " << numSprings << endl;
rt300@0:     
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void SpiderCrossMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	cout << "SpiderCrossMesh spider constrain\n";
rt300@0: 	
rt300@0: 	TwoVector diff;
rt300@0: 	int i = 0;
rt300@0: 	int startLump = 0;
rt300@0: 	// check if lump is within grab range
rt300@0: 	switch (aMode) {
rt300@0: 		case CONSTRAIN_GRAB_REGION:
rt300@4: 			for(i = 0; i<lumps.size(); i++){
rt300@0: 				
rt300@0: 				diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0: 				
rt300@0: 				if (diff.norm() < GRAB_RANGE){
rt300@0: 					lumps[i].constrain();
rt300@0: 				}
rt300@0: 			}
rt300@0: 			break;
rt300@0: 		case CONSTRAIN_EDGES:
rt300@0: 		{
rt300@0: 			// constrain outer ring
rt300@0: 			startLump = numSpokes*(numRings-1);
rt300@0: 			for(int l = startLump; l < startLump + numSpokes; l++){
rt300@0: 				lumps[l].constrain();
rt300@0: 			}
rt300@0:             
rt300@0: 			break;
rt300@0: 		}
rt300@0: 		case CONSTRAIN_CORNERS:
rt300@0: 			// constrain inner ring
rt300@0: 			
rt300@0: 			for(int l = startLump; l < startLump + numSpokes; l++){
rt300@0: 				lumps[l].constrain();
rt300@0: 			}
rt300@0:             
rt300@0: 			break;
rt300@0: 			
rt300@0: 		default:
rt300@0: 			break;
rt300@0: 	}
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: 
rt300@0: void SpiderCrossMesh::makeDefaultScanPath(){
rt300@0: 	
rt300@0: 	cout << "SpiderCrossMesh spider makeDefaultScanPath\n";
rt300@0:     
rt300@0:     // add a ring to the path
rt300@0:     int ringNo = floor(numRings/2.0);
rt300@0:     int springno = 0, lumpno = 0;
rt300@0:     for(int i = 0; i < numSpokes; i++){
rt300@0:         lumpno = numSpokes*ringNo + i;
rt300@0:         springno = numSpokes*ringNo + i;
rt300@3:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@0:     }
rt300@0:     cout << "SpiderCrossMesh spider scan path created on ring " << ringNo << "\n";
rt300@0:     
rt300@0:     // add a spoke to the path
rt300@0:     /*
rt300@0:      int springno = 0, lumpno = 0;
rt300@0:      
rt300@0:      int springsinrings = numSpokes*numRings;
rt300@0:      for(int i = 0; i < numRings-1; i++){
rt300@0:      lumpno = numSpokes*i; // zero, numspokes etc
rt300@0:      springno = springsinrings + numSpokes*i; // starts from total rings, increments by numspokes etc
rt300@3:      scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@0:      } 
rt300@0:      */
rt300@0: }
rt300@0: 
rt300@0: /****************************************/
rt300@0: //		Line    Mesh					*/
rt300@0: /****************************************/
rt300@0: 
rt300@0: LineMesh::LineMesh(int aNumSegments) : Mesh(){
rt300@8:     meshType = LINE_MESH;
rt300@0: 	numSegments = aNumSegments;
rt300@0:     radial = false;
rt300@0:     
rt300@0: 	makeComponents(aNumSegments, 0);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0:     
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@6:     
rt300@0:     
rt300@0:     setPropagationSpeed(0.6);
rt300@0: 	
rt300@6:     for(int i = 0; i < lumps.size(); i++){
rt300@6:         lumps[i].constrain(Lump::CONSTRAIN_X);
rt300@6:     }
rt300@6:     
rt300@6:     constrain(0.0,0.0,CONSTRAIN_EDGES);
rt300@0: 	cout << "constructed LINE mesh\n";
rt300@0: 	
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void LineMesh::makeComponents(int aDimension1, int aDimension2){
rt300@0:     // make componets creates the correct number of lumps and springs according to dimensions and mesh type
rt300@0: 	cout << "Line class makeComponents\n";
rt300@0:     // 
rt300@0:     numLumps = numSegments+1;
rt300@0:     numSprings = numSegments;
rt300@9:     Mesh::makeComponents(numLumps, numSprings);
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void LineMesh::setLumpPositions(){
rt300@0: 	cout << "LineMesh class setLumpPositions\n";
rt300@0:     // 
rt300@0:     double hspacing = (1.0 - 0.05)/numSegments;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         lumps[i].setPosition(0.025+hspacing*i, 0.5);
rt300@0:     }
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void LineMesh::makeConnections(){
rt300@0:     // connects the lmps and springs. the spring needs to know which lumps are at each end
rt300@0:     // and lumps need to know which springs attached
rt300@0:     // calls connect method that does this
rt300@0: 	cout << "LineMesh class make connections\n";
rt300@0:     for(int i = 0; i < numSegments; i++){
rt300@0:         connect(i,i);
rt300@0:         connect(i,i+1);
rt300@0:     }
rt300@6: 
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void LineMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	cout << "LineMesh class constrain\n";
rt300@0:     if (aMode == CONSTRAIN_EDGES || aMode == CONSTRAIN_CORNERS){
rt300@0:         lumps[0].constrain();
rt300@4:         lumps[lumps.size()-1].constrain();
rt300@0:     }else if (aMode == CONSTRAIN_GRAB_REGION){
rt300@0:         TwoVector diff;
rt300@4:         for(int i = 0; i<lumps.size(); i++){
rt300@0:             
rt300@0:             diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0:             
rt300@0:             if (diff.norm() < GRAB_RANGE){
rt300@0:                 lumps[i].constrain();
rt300@0:             }
rt300@0:         }
rt300@0:     }
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: //--------------------------------------------------------------
rt300@0: void LineMesh::makeDefaultScanPath(){
rt300@0: 	
rt300@0: 	cout << "LineMesh class makeDefaultScanPath\n";
rt300@14:     for(int i = 1; i < numSegments-1; i++){
rt300@3:         scanPath.addElement(&lumps[i], &springs[i]);
rt300@0:     }
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: /****************************************/
rt300@0: //		GROUNDED LINE  Mesh					*/
rt300@0: /****************************************/
rt300@0: 
rt300@0: GroundedLineMesh::GroundedLineMesh(int aNumSegments) : Mesh(){
rt300@8:     meshType = GROUNDED_LINE_MESH;
rt300@0: 	numSegments = aNumSegments;
rt300@0:     radial = false;
rt300@0: 	makeComponents(aNumSegments, 0);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0:     
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@0:     constrain(0.0,0.0,CONSTRAIN_ALL_X);
rt300@0:     
rt300@0:     setPropagationSpeed(0.6);
rt300@0: 	
rt300@0: 	cout << "constructed GROUNDED LINE mesh\n";
rt300@0: 	
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void GroundedLineMesh::makeComponents(int aDimension1, int aDimension2){
rt300@0:     // make componets creates the correct number of lumps and springs according to dimensions and mesh type
rt300@0:     
rt300@0:     // THIS IS CRAP should be able to just create new ones and attach them...?
rt300@0: 	cout << "Line class makeComponents\n";
rt300@0:     // 
rt300@0:     numLumps = (numSegments+1)*2;
rt300@0:     numSprings = numSegments*2;
rt300@9:     Mesh::makeComponents(numLumps, numSprings);
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void GroundedLineMesh::setLumpPositions(){
rt300@0: 	cout << "LineMesh class setLumpPositions\n";
rt300@0:     // 
rt300@0: 
rt300@0:     double hspacing = (1.0 - 0.05)/numSegments;
rt300@0:     for(int i = 0; i < (numSegments+1); i++){
rt300@0:         // moving ones
rt300@0:         lumps[i].setPosition(0.025+hspacing*i, 0.5);
rt300@0:         //grounded ones
rt300@0:         lumps[i + numSegments+1].setPosition(0.025+hspacing*i,0.5*cos(i*hspacing*PI) + 0.5 );
rt300@0:     }
rt300@0:     
rt300@0: 
rt300@0: 
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void GroundedLineMesh::makeConnections(){
rt300@0:     // connects the lmps and springs. the spring needs to know which lumps are at each end
rt300@0:     // and lumps need to know which springs attached
rt300@0:     // calls connect method that does this
rt300@0: 	cout << "LineMesh class make connections\n";
rt300@0:     for(int i = 0; i < numSegments; i++){
rt300@0:         connect(i,i,i+1);
rt300@0:         connect(i + numSegments,i , i + numSegments+1);
rt300@0: 
rt300@0:     }
rt300@0: 
rt300@0:     setRestLength();
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void GroundedLineMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	cout << "LineMesh class constrain\n";
rt300@0:     if (aMode == CONSTRAIN_EDGES || aMode == CONSTRAIN_CORNERS){
rt300@0:         lumps[0].constrain();
rt300@4:         lumps[lumps.size()-1].constrain();
rt300@0:         
rt300@4:         for(int i = numSegments; i < lumps.size(); i++){
rt300@0:             lumps[i].constrain();
rt300@0:         }
rt300@0:     }
rt300@0: 
rt300@0:     if (aMode == CONSTRAIN_GRAB_REGION){
rt300@0:         TwoVector diff;
rt300@4:         for(int i = 0; i<lumps.size(); i++){
rt300@0:             
rt300@0:             diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0:             
rt300@0:             if (diff.norm() < GRAB_RANGE){
rt300@0:                 lumps[i].constrain();
rt300@0:             }
rt300@0:         }
rt300@0:     }
rt300@0:     if (aMode == CONSTRAIN_ALL_X){
rt300@0: 
rt300@0:         
rt300@0:         for(int i = 0; i<numSegments; i++){
rt300@0: 
rt300@0:             lumps[i].constrain(Lump::CONSTRAIN_X);
rt300@0:         }
rt300@4:         for(int i = numSegments; i < lumps.size(); i++){
rt300@0:             lumps[i].constrain();
rt300@0:         }
rt300@0:         lumps[0].constrain();
rt300@4:         lumps[lumps.size()-1].constrain();
rt300@0:     }
rt300@0:         
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: //--------------------------------------------------------------
rt300@0: void GroundedLineMesh::makeDefaultScanPath(){
rt300@0: 	
rt300@0: 	cout << "LineMesh class makeDefaultScanPath\n";
rt300@0:     for(int i = 0; i < numSegments; i++){
rt300@3:         scanPath.addElement(&lumps[i], &springs[i]);
rt300@0:     }
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: 
rt300@0: /****************************************/
rt300@0: //		DROPLET    Mesh					*/
rt300@0: /****************************************/
rt300@0: // more of a balloon really - filled with compressible gas
rt300@0: DropletMesh::DropletMesh(int aNumSegments) : Mesh(){
rt300@8:     meshType = DROPLET_MESH;
rt300@0:     restArea = 1.0;
rt300@0:     radial = true;
rt300@0: 	numSegments = aNumSegments;
rt300@0:     
rt300@0: 	makeComponents(aNumSegments, 0);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0:     
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@0:     //constrain(0.0,0.0,CONSTRAIN_EDGES);
rt300@0:     
rt300@0:     setPropagationSpeed(0.8);
rt300@0:     
rt300@0:     zeroRestLength();
rt300@0:     globalForces.pressureAmt = 0.4;
rt300@0: 	
rt300@0: 	cout << "constructed DropletMesh mesh\n";
rt300@0: 	
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void DropletMesh::makeComponents(int aDimension1, int aDimension2){
rt300@0:     // make componets creates the correct number of lumps and springs according to dimensions and mesh type
rt300@0: 	cout << "Line class makeComponents\n";
rt300@0:     // 
rt300@0:     numLumps = numSegments;
rt300@0:     numSprings = numSegments;
rt300@9:     Mesh::makeComponents(numLumps, numSprings);
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void DropletMesh::setLumpPositions(){
rt300@0: 	cout << "DropletMesh class setLumpPositions\n";
rt300@0:     // make a circle centred around 0.5,0.5 radius 0.4
rt300@0: 	int l = 0;
rt300@0: 	double hyplen,xpos,ypos;
rt300@0: 	
rt300@0: 	double * cosines = new double[numSegments];
rt300@0: 	double * sines = new double[numSegments];
rt300@0: 	double angle = 2 * PI / numSegments;
rt300@0:     
rt300@0: 	for(int spoke = 0; spoke < numSegments; spoke++){
rt300@0: 		cosines[spoke] = cos(angle*spoke);
rt300@0: 		sines[spoke] = sin(angle*spoke);
rt300@0: 	}
rt300@0:     
rt300@0:     hyplen = 0.2; // aka radius
rt300@0:     
rt300@0:     // 
rt300@0: 	//lumps[0].setPosition(0.5,0.5);
rt300@0:     
rt300@0:     for(int spoke = 0; spoke < numSegments; spoke++){
rt300@0:         
rt300@0:         xpos = hyplen * cosines[spoke] + 0.5;
rt300@0:         ypos = hyplen*sines[spoke] + 0.5;
rt300@0:         lumps[l].setPosition(xpos,ypos);
rt300@0:         l++;
rt300@0:         
rt300@0:     }
rt300@0:     calculateCentre();
rt300@0:     restArea = calculateArea() * 3; // this is like the amount of air in there originally, inflate a bit !
rt300@0:     
rt300@0: 	delete [] cosines;
rt300@0: 	delete [] sines;
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void DropletMesh::makeConnections(){
rt300@0:     // connects the lmps and springs. the spring needs to know which lumps are at each end
rt300@0:     // and lumps need to know which springs attached
rt300@0:     // calls connect method that does this
rt300@0: 	cout << "DropletMesh class make connections\n";
rt300@0:     for(int i = 0; i < numSegments-1; i++){
rt300@0:         connect(i,i,i+1);
rt300@0:     }
rt300@0:     // finally connect end spring to start lump
rt300@0:     connect(numSegments-1,numSegments-1);
rt300@0:     connect(numSegments-1,0);
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void DropletMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	cout << "DropletMesh class constrain\n";
rt300@0:     if (aMode == CONSTRAIN_EDGES || aMode == CONSTRAIN_CORNERS){
rt300@0:         lumps[0].constrain();
rt300@4:         lumps[lumps.size()-1].constrain();
rt300@0:     }  else  if (aMode == CONSTRAIN_GRAB_REGION){
rt300@0:         TwoVector diff;
rt300@4:         for(int i = 0; i<lumps.size(); i++){
rt300@0:             
rt300@0:             diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0:             
rt300@0:             if (diff.norm() < GRAB_RANGE){
rt300@0:                 lumps[i].constrain();
rt300@0:             }
rt300@0:         }
rt300@0:     }
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: //--------------------------------------------------------------
rt300@0: void DropletMesh::makeDefaultScanPath(){
rt300@0: 	
rt300@0: 	cout << "DropletMesh class makeDefaultScanPath\n";
rt300@0:     for(int i = 0; i < numSegments; i++){
rt300@3:         scanPath.addElement(&lumps[i], &springs[i]);
rt300@0:     }
rt300@0:     cout << "DropletMesh class makeDefaultScanPath\n";
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: double DropletMesh::calculateArea(){
rt300@0:     
rt300@0:     // how do we calculate area?? answer: average all radii !
rt300@0:     
rt300@0:     // calc average radius magnitude
rt300@0:     double radiusMag = 0.0, avRadiusMag = 0.0;
rt300@4:     for(int i = 0; i < lumps.size(); i++){
rt300@0:         TwoVector radius;
rt300@0:         radius.setCoord(centre.x - lumps[i].position.x, centre.y - lumps[i].position.y );
rt300@0:         radiusMag = radius.norm();
rt300@0:         avRadiusMag += radiusMag;
rt300@0:     }
rt300@4:     avRadiusMag /= lumps.size();
rt300@0:     
rt300@0:     // calc area
rt300@0:     double area = 2 * PI * avRadiusMag*avRadiusMag;
rt300@0:     
rt300@0:     return area;
rt300@0:     
rt300@0: }
rt300@0: 
rt300@0: double DropletMesh::calculatePressure(){
rt300@0:     // work out pressure on the springs. 
rt300@0:     // this will be proportional to the difference in the rest area to the current area
rt300@0:     //this will exert a force proportional to length
rt300@0:     
rt300@0:     double da = restArea - calculateArea();
rt300@0:     // if current area is smaller this will create positive pressure
rt300@0:     
rt300@0:     globalForces.setPressure(da);
rt300@0:     return globalForces.pressure;
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void DropletMesh::update(){
rt300@0: 
rt300@0:     calculateCentre();
rt300@0:     calculatePressure();
rt300@0:     Mesh::update(); // schweet
rt300@0:     
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: 
rt300@0: /****************************************/
rt300@0: //		TriangleMesh					*/
rt300@0: /****************************************/
rt300@0: //--------------------------------------------------------------
rt300@0: TriangleMesh::TriangleMesh(int height, int width): Mesh() {
rt300@8:     meshType = TRIANGLE_MESH;
rt300@0: 	radial = false;
rt300@0: 	makeComponents(height, width);
rt300@0: 	
rt300@0: 	setLumpPositions();
rt300@0: 	
rt300@0: 	makeConnections();
rt300@0: 	
rt300@0: 	makeDefaultScanPath();
rt300@0:     
rt300@0:     constrain(0,0,CONSTRAIN_EDGES);
rt300@0:     
rt300@0:     zeroRestLength();
rt300@1:     
rt300@0: 	
rt300@0: 	cout << "constructing TRIANGLE mesh\n";
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: // make componets for tri
rt300@0: void TriangleMesh::makeComponents(int aheight, int awidth){
rt300@0: 	height = aheight;
rt300@0: 	width = awidth;
rt300@0: 	numLumps = height * width;
rt300@0:                 /* horz   ---            \ diag                  / diag              */
rt300@0: 	numSprings = (width-1) * (height-1) +  width * (height - 1) + (width-1) * (height - 1);
rt300@0: 	
rt300@9: 	Mesh::makeComponents(numLumps, numSprings);
rt300@0: }
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void TriangleMesh::setLumpPositions(){
rt300@0: 	double vspacing = 1.0/(height-1);
rt300@0: 	double hspacing = 1.0/(width - 0.5);
rt300@0: 	int i =0;
rt300@0: 	// set positions
rt300@0: 	for(int row = 0; row < height; row++){ // go down column
rt300@0: 		for(int col = 0;col < width; col++){ // go along row
rt300@0:             // if even row start from wall
rt300@0:             if(row%2){ // odd
rt300@0:                 lumps[i].setPosition(hspacing*col + 0.5*hspacing,vspacing*row);
rt300@0: 			}else{ // even
rt300@0:                 lumps[i].setPosition(hspacing*col,vspacing*row);
rt300@0:             }
rt300@0: 			i++;
rt300@0: 		}
rt300@0: 	}
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: void TriangleMesh::makeConnections(){
rt300@0: 	
rt300@0: 	// could be cleverer in terms of numbering?
rt300@0: 	int lumpnum = 0;
rt300@0: 	int springnum = 0;
rt300@0:     
rt300@0: 	// attach horizontal a
rt300@0: 	for ( int row=1;row< height;row++){
rt300@0: 		for(int col=0;col<width-1;col++){
rt300@0: 			connect(springnum,lumpnum,lumpnum+1);
rt300@0:             lumpnum++;
rt300@0:             springnum++;
rt300@0: 		}
rt300@0:         lumpnum++;
rt300@0: 	}
rt300@0: 	
rt300@0:     /* now do /\/\/\/\/\/\/\ */
rt300@0: 	lumpnum = 0;
rt300@0: 	for ( int row=0;row<height-1;row++){
rt300@0:         
rt300@0:         if(row%2 == 0){ 
rt300@0:             // even ie 0
rt300@0:             /* start with \  diag */
rt300@0:             for(int col=0;col<width-1;col++){
rt300@0:                 /* \ */
rt300@0:                 connect(springnum++, lumpnum, lumpnum+ width);
rt300@0:                 lumpnum++;
rt300@0:                 /* / */
rt300@0:                 connect(springnum++, lumpnum, lumpnum+(width-1));
rt300@0:                 
rt300@0:             }
rt300@0:             connect(springnum++, lumpnum, lumpnum+width);
rt300@0:             lumpnum++;
rt300@0:             
rt300@0:         }else{         // odd
rt300@0:             for(int col=0;col<width-1;col++){
rt300@0:                 /* / */
rt300@0:                 connect(springnum++, lumpnum, lumpnum+ width);
rt300@0:                 /* \ */
rt300@0:                 connect(springnum++, lumpnum, lumpnum+(width+1));
rt300@0:                 lumpnum++;
rt300@0:             }
rt300@0:             // last r to l
rt300@0:             /* / */
rt300@0:             connect(springnum++, lumpnum, lumpnum+(width));
rt300@0:             lumpnum++;
rt300@0:             
rt300@0:         }
rt300@0:     }
rt300@0:     
rt300@0: }	
rt300@0: 
rt300@0: 
rt300@0: 
rt300@0: //--------------------------------------------------------------
rt300@0: void TriangleMesh::constrain(double ax, double ay, constrainMode aMode){
rt300@0: 	// exactly the same as square
rt300@0: 	TwoVector diff;
rt300@0: 	int i = 0;
rt300@0: 	
rt300@0: 	// check if lump is within grab range
rt300@0: 	switch (aMode) {
rt300@0: 		case CONSTRAIN_GRAB_REGION:
rt300@4: 			for(i = 0; i<lumps.size(); i++){
rt300@0: 				
rt300@0: 				diff.setCoord(lumps[i].position.x - ax, lumps[i].position.y - ay);
rt300@0: 				
rt300@0: 				if (diff.norm() < GRAB_RANGE){
rt300@0: 					lumps[i].constrain();
rt300@0: 				}
rt300@0: 			}
rt300@0: 			break;
rt300@0: 		case CONSTRAIN_EDGES:
rt300@0: 			i = 0;
rt300@0: 			for(int row = 0; row < height; row++){ // go down column
rt300@0: 				for(int col = 0;col < width; col++){ // go along row
rt300@0: 					if(row == 0 || row == height-1 || col == 0 || col == width-1){
rt300@0: 						lumps[i].constrain();
rt300@0: 					}
rt300@0: 					i++;
rt300@0: 				}
rt300@0: 			}	
rt300@0: 			break;
rt300@0: 		case CONSTRAIN_CORNERS:
rt300@0: 			i = 0;
rt300@0: 			for(int row = 0; row < height; row++){ // go down column
rt300@0: 				for(int col = 0;col < width; col++){ // go along row
rt300@0: 					if(   (row == 0 && col == 0)
rt300@0: 					   || (row == height-1 && col == 0) 
rt300@0: 					   || (row == 0 && col == width-1) 
rt300@0: 					   || (row == height-1 && col == width-1)){
rt300@0: 						lumps[i].constrain();
rt300@0: 					}
rt300@0: 					i++;
rt300@0: 				}
rt300@0: 			}
rt300@0: 			break;
rt300@0: 			
rt300@0: 		default:
rt300@0: 			break;
rt300@0: 	}
rt300@0: 	
rt300@0: }
rt300@0: //--------------------------------------------------------------
rt300@0: //--------------------------------------------------------------
rt300@0: void TriangleMesh::makeDefaultScanPath(){
rt300@0: 
rt300@0:     int vmarg = 4;
rt300@0:     int hmarg = 4;
rt300@0:     
rt300@0:     int lumpno = vmarg * width + hmarg; // top left corner
rt300@0:     int springno = vmarg * (width - 1) + hmarg;
rt300@0:     // do top horz
rt300@0:     for(int i = 0; i < width - 2*hmarg; i++){
rt300@3:         scanPath.addElement(&lumps[lumpno], &springs[springno]);
rt300@0:         lumpno++;
rt300@0:         springno++;
rt300@0:     }
rt300@0: 
rt300@0:     
rt300@0: }
rt300@0: