int Shadows::checkIfHole(ofPolyline& _contourLine){
int rta = -1;
// Calculate the centroid
//
ofPoint centroid = _contourLine.getCentroid2D();
// Check if it fits inside another another non-active blob.
//
for( map<int,AnimatedShadow*>::reverse_iterator rit = hands.rbegin(); rit != hands.rend(); rit++ ){
if ( !(rit->second->bActive) ) {
if ( rit->second->isInside( centroid ) ){
rta = rit->second->getId();
}
}
}
return rta;
}
//--------------------------------------------------------------
void ofApp::draw(){
if(poly.size() < 2) return;
ofPushMatrix();
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
ofRotateY(rotAngle);
ofSetColor(255, 255, 255);
poly.draw();
ofSetColor(0, 255, 0);
ofSetRectMode(OF_RECTMODE_CENTER);
glPointSize(5);
glBegin(GL_POINTS);
for(int i=0; i<poly.size(); i++) {
ofPoint p = poly[i];
glVertex3f(p.x, p.y, p.z);
}
glEnd();
for(int i=0; i<poly.size(); i++) {
ofPoint p = poly[i];
ofSetColor(255, 0, 0);
ofLine(p, p + poly.getTangentAtIndex(i) * 20);
ofSetColor(0, 255, 0);
ofLine(p, p + poly.getNormalAtIndex(i) * 20);
ofSetColor(0, 128, 255);
ofLine(p, p + poly.getRotationAtIndex(i) * 20);
}
float totalLength = poly.getPerimeter();
float totalArea = poly.getArea();
ofPoint nearestPoint = poly.getClosestPoint(ofPoint(mouseX-ofGetWidth()/2, mouseY-ofGetHeight()/2), &nearestIndex);
ofPoint nearestDataPoint = poly[nearestIndex];
float lengthAtIndex = poly.getLengthAtIndex(nearestIndex);
ofPoint pointAtIndex = poly.getPointAtIndexInterpolated(nearestIndex);
ofPoint pointAtLength = poly.getPointAtLength(lengthAtIndex);
ofPoint pointAtPercent = poly.getPointAtPercent(lengthAtIndex / totalLength);
float indexAtLength = poly.getIndexAtLength(lengthAtIndex);
float sinTime = ofMap(sin(ofGetElapsedTimef() * 0.5), -1, 1, 0, 1);
float sinIndex = sinTime * (poly.isClosed() ? poly.size() : (poly.size()-1)); // sinTime mapped to indices direct
float sinIndexLength = poly.getIndexAtPercent(sinTime); // sinTime mapped to indices based on length
float lengthAtIndexSin = poly.getLengthAtIndexInterpolated(sinIndex);
ofPoint pointAtIndexSin = poly.getPointAtIndexInterpolated(sinIndex);
ofPoint pointAtPercentSin = poly.getPointAtPercent(sinTime);
float angleAtIndex = poly.getAngleAtIndex(nearestIndex);
float angleAtIndexSin = poly.getAngleAtIndexInterpolated(sinIndex);
ofVec3f rotAtIndex = poly.getRotationAtIndex(nearestIndex);
ofVec3f rotAtIndexSin = poly.getRotationAtIndexInterpolated(sinIndex);
float rotMagAtIndex = rotAtIndex.length();
float rotMagAtIndexSin = rotAtIndexSin.length();
ofVec3f normalAtIndex = poly.getNormalAtIndex(nearestIndex);
ofVec3f tangentAtIndexSin = poly.getTangentAtIndexInterpolated(sinIndex);
ofVec3f normalAtIndexSin = poly.getNormalAtIndexInterpolated(sinIndex);
ofVec3f rotationAtIndexSin = poly.getRotationAtIndexInterpolated(sinIndex);
ofNoFill();
ofSetLineWidth(2);
ofSetColor(255, 0, 0);
ofCircle(nearestPoint, 5);
ofSetColor(255, 255, 0);
ofCircle(nearestDataPoint, 7);
// interpolating on indices
{
ofPoint p = poly.getPointAtIndexInterpolated(sinIndex);
ofSetColor(0, 255, 255);
ofCircle(p, 10);
ofSetColor(255, 0, 0);
ofLine(p, p + poly.getTangentAtIndexInterpolated(sinIndex) * 60);
ofSetColor(0, 255, 0);
ofLine(p, p + poly.getNormalAtIndexInterpolated(sinIndex) * 60);
ofSetColor(0, 128, 255);
ofLine(p, p + poly.getRotationAtIndexInterpolated(sinIndex) * 60);
}
// interpolating on length percentages
{
ofPoint p = poly.getPointAtIndexInterpolated(sinIndexLength);
ofSetColor(255, 0, 255);
ofCircle(p, 10);
ofSetColor(255, 0, 0);
ofLine(p, p + poly.getTangentAtIndexInterpolated(sinIndexLength) * 60);
ofSetColor(0, 255, 0);
ofLine(p, p + poly.getNormalAtIndexInterpolated(sinIndexLength) * 60);
ofSetColor(0, 128, 255);
ofLine(p, p + poly.getRotationAtIndexInterpolated(sinIndexLength) * 60);
}
ofSetColor(255, 255, 255);
ofCircle(poly.getCentroid2D(), 20);
ofPopMatrix();
stringstream s;
s << "Number of points: " << poly.size() << endl;
s << "totalLength: " << totalLength << endl;
s << endl;
s << "nearestIndex: " << nearestIndex << endl;
s << "nearestPoint: " << nearestPoint << endl;
s << "nearestDataPoint: " << nearestDataPoint << endl;
s << endl;
s << "lengthAtIndex: " << lengthAtIndex << endl;
s << "pointAtIndex: " << pointAtIndex << endl;
s << endl;
s << "pointAtLength: " << pointAtLength << endl;
s << "pointAtPercent: " << pointAtPercent << endl;
s << endl;
s << "indexAtLength: " << indexAtLength << endl;
s << endl;
s << "sinTime: " << sinTime << endl;
s << "sinIndex: " << sinIndex << endl;
s << "sinIndexLength: " << sinIndexLength << endl;
s << endl;
s << "lengthAtIndexSin: " << lengthAtIndexSin << endl;
s << "pointAtIndexSin: " << pointAtIndexSin << endl;
s << "pointAtPercentSin: " << pointAtPercentSin << endl;
s << endl;
s << "angleAtIndex: " << angleAtIndex << endl;
s << "angleAtIndexSin: " << angleAtIndexSin << endl;
s << endl;
s << "rotAtIndex: " << rotAtIndex << endl;
s << "rotAtIndexSin: " << rotAtIndexSin << endl;
s << endl;
s << "rotMagAtIndex: " << rotMagAtIndex << endl;
s << "rotMagAtIndexSin: " << rotMagAtIndexSin << endl;
s << endl;
s << "normalAtIndex: " << normalAtIndex << endl;
s << "normalAtIndexSin: " << normalAtIndexSin << endl;
ofSetColor(255);
ofDrawBitmapString(s.str(), 10, 30);
}
void LetterParticle::kill()
{
BaseParticle::kill(); // call the super /parent class!
std::vector<ofTTFCharacter> paths = font.getStringAsPoints(text);
std::vector<ofTTFCharacter>::iterator pathsIter = paths.begin();
while(pathsIter != paths.end())
{
std:
vector<ofPolyline> polylines = (*pathsIter).getOutline();
std::vector<ofPolyline>::const_iterator polyIter = polylines.begin();
while(polyIter != polylines.end())
{
if((*polyIter).size() > 0)
{
ofPolyline resampled = (*polyIter).getResampledBySpacing(2); // this number tells us how many particles
if(resampled.size() > 0)
{
const ofPolyline poly = resampled.getVertices();
auto centroid = poly.getCentroid2D(); // find the middle
// create a particle group
std::shared_ptr<BaseParticleGroup> particleGroup(new BaseParticleGroup());
// add particles to the particle system AND to the particle group
for(int i = 0; i < poly.size(); ++i)
{
std::shared_ptr<ParticleGroupMember> particle(new ParticleGroupMember());
// this is how we get the particle to move away from the center
// of the group (as calculated by the centroid)
auto newVelocity = glm::normalize(poly[i] - centroid) * ofRandom(.5,2);
particle->position = position + poly[i];
particle->velocity = velocity + newVelocity;
particle->acceleration = acceleration;
particle->maxAge = ofRandom(50,100);
particle->particleSystem = particleSystem; // make a link back to the particle system
particleSystem->addParticle(particle);
particleGroup->members.push_back(particle);
}
// add the particle group to the particle system
particleSystem->addParticleGroup(particleGroup);
}
}
++polyIter;
}
++pathsIter;
}
}
