void ofxPolylineLoad(ofPolyline & poly, string xmlPath) { ofXml xml; bool bLoaded = xml.load(xmlPath); if(bLoaded == false) { return; } xml.setTo("poly"); bool bClosed = ofToInt(xml.getAttribute("closed")); poly.clear(); int numOfPoints = xml.getNumChildren(); for(int i=0; i<numOfPoints; i++) { xml.setToChild(i); float x = ofToFloat(xml.getAttribute("x")); float y = ofToFloat(xml.getAttribute("y")); poly.addVertex(x, y); } if(bClosed == true) { poly.close(); } }
//-------------------------------------------------------------- void drawWithNormals(const ofPolyline& polyline, int zeroX, int zeroY, bool drawContours) { for (int i = 0; i < (int) polyline.size(); i++) { bool repeatNext = i == (int) polyline.size() - 1; const ofPoint& cur = polyline[i]; const ofPoint& next = repeatNext ? polyline[0] : polyline[i + 1]; float angle = atan2f(next.y - cur.y, next.x - cur.x) * RAD_TO_DEG; float distance = cur.distance(next); if (repeatNext) { ofSetColor(255, 0, 255); } glPushMatrix(); glTranslatef(cur.x + zeroX, cur.y + zeroY, 0); ofRotate(angle); // ofLine(0, 0, 0, distance); ofLine(0, 0, distance, 0); ofLine(0, distance, distance, distance); if (drawContours) { for (int i = distance; i < distance * 3; i += 5) { ofLine(0, 0, i, 0); ofLine(0, i, i, i); } } glPopMatrix(); } }
ofPolyline ofGetSmoothed(const ofPolyline& polyline, int smoothingSize, float smoothingShape) { ofPolyline result = polyline; if(!polyline.getClosed()) { ofLog( OF_LOG_ERROR, "ofSmooth() currently only supports closed ofPolylines." ); return polyline; } // precompute weights and normalization vector<float> weights; float weightSum = 0; weights.push_back(1); // center weight // side weights for(int i = 1; i <= smoothingSize; i++) { float curWeight = ofMap(i, 0, smoothingSize, 1, smoothingShape); weights.push_back(curWeight); weightSum += curWeight; } float weightNormalization = 1 / (1 + 2 * weightSum); // use weights to make weighted averages of neighbors int n = polyline.size(); for(int i = 0; i < n; i++) { for(int j = 1; j <= smoothingSize; j++) { int leftPosition = (n + i - j) % n; int rightPosition = (i + j) % n; const ofPoint& left = polyline[leftPosition]; const ofPoint& right = polyline[rightPosition]; result[i] += (left + right) * weights[j]; } result[i] *= weightNormalization; } return result; }
void testApp::renderOutlinesToFBO(ofPolyline& leftEye, ofPolyline& rightEye, ofPolyline& faceOutline){ outputFbo.begin(); ofClear(0,0,0,0); ofPushStyle(); //ofEnableAlphaBlending(); ofEnableBlendMode(OF_BLENDMODE_ADD); ofSetColor(0,0,255,255); ofBeginShape(); ofVertices(faceOutline.getVertices()); ofEndShape(); ofSetColor(255,0,0,255); ofBeginShape(); ofVertices(leftEye.getVertices()); ofEndShape(); ofSetColor(255,0,0,255); ofBeginShape(); ofVertices(rightEye.getVertices()); ofEndShape(); ofPopStyle(); outputFbo.end(); }
void contourToConvexHull(ofPolyline &src, ofPolyline &dst) { dst.clear(); vector<hPoint> P(src.size()); for(int i = 0; i < src.size(); i++) { P[i].x = src[i].x; P[i].y = src[i].y; } int n = src.size(), k = 0; vector<hPoint> H(2*n); // Sort points lexicographically sort(P.begin(), P.end()); // Build lower hull for (int i = 0; i < n; i++) { while (k >= 2 && cross(H[k-2], H[k-1], P[i]) <= 0) k--; H[k++] = P[i]; } // Build upper hull for (int i = n-2, t = k+1; i >= 0; i--) { while (k >= t && cross(H[k-2], H[k-1], P[i]) <= 0) k--; H[k++] = P[i]; } H.resize(k); for(int i = 0; i < H.size(); i++) { dst.addVertex(H[i].x + 500, H[i].y); } }
void ofxPolyline2Mesh::updateShape(const ofPolyline &polyline) { shape.clear(); norm.clear(); for (int i = 0; i < polyline.size(); i++) { shape.push_back(polyline[i]); } if (polyline.isClosed()) shape.push_back(polyline[0]); const ofVec3f V(0, 0, -1); for (int i = 0; i < shape.size() - 1; i++) { const ofVec3f& p1 = shape[i]; const ofVec3f& p2 = shape[i + 1]; const ofVec3f& n21 = (p2 - p1).normalized(); norm.push_back(n21.crossed(V)); } { const ofVec3f& p1 = shape[shape.size() - 1]; const ofVec3f& p2 = shape[0]; const ofVec3f& n21 = (p2 - p1).normalized(); norm.push_back(n21.crossed(V)); } current_segments.resize(shape.size()); last_segments.resize(shape.size()); }
ofPolyline ofGetResampledSpacing(const ofPolyline& polyline, float spacing) { ofPolyline result; // if more properties are added to ofPolyline, we need to copy them here result.setClosed(polyline.getClosed()); float totalLength = 0; int curStep = 0; int lastPosition = polyline.size() - 1; if(polyline.getClosed()) { lastPosition++; } for(int i = 0; i < lastPosition; i++) { bool repeatNext = i == (int) (polyline.size() - 1); const ofPoint& cur = polyline[i]; const ofPoint& next = repeatNext ? polyline[0] : polyline[i + 1]; ofPoint diff = next - cur; float curSegmentLength = diff.length(); totalLength += curSegmentLength; while(curStep * spacing <= totalLength) { float curSample = curStep * spacing; float curLength = curSample - (totalLength - curSegmentLength); float relativeSample = curLength / curSegmentLength; result.addVertex(cur.getInterpolated(next, relativeSample)); curStep++; } } return result; }
void testApp::oscSendContour(int label, const ofPolyline &polyline){ ofxOscMessage m; stringstream ss; ss<<"/contour"; m.setAddress(ss.str()); int size = polyline.size(); m.addIntArg(label); m.addIntArg(size); cout<<"contour: "<<label<<" size: "<<size<<endl; const ofRectangle& rect = polyline.getBoundingBox(); m.addIntArg(rect.getTopLeft().x); m.addIntArg(rect.getTopLeft().y); m.addIntArg(rect.getBottomRight().x); m.addIntArg(rect.getBottomRight().y); ofPolyline newLine = polyline.getResampledByCount(100); cout<<"resized to "<<newLine.size()<<endl; // newLine.draw(); if(bSendContours){ const vector<ofPoint> points = newLine.getVertices(); for(int i=0; i< newLine.size(); i++){ m.addFloatArg(points[i].x); m.addFloatArg(points[i].y); } } sender.sendMessage(m); }
vector<cv::Point2f> toCv(const ofPolyline& polyline) { vector<cv::Point2f> contour(polyline.size()); for(int i = 0; i < polyline.size(); i++) { contour[i].x = polyline[i].x; contour[i].y = polyline[i].y; } return contour; }
void phdGimbal2d::getKeyPoints(ofPolyline & _keys) { _keys.clear(); _keys.addVertex( 1.00, 0.0); _keys.addVertex( 0.75, 0.0); _keys.addVertex( 0.00, 0.0); _keys.addVertex( 0.00,-1.0); getTransformedPolyline(_keys, _keys, getOTSMatrix()); }
void LaserManager::addLaserPolyline(const ofPolyline& line, ColourSystem* coloursystem, float intens){ if((line.getVertices().size()==0)||(line.getPerimeter()<0.1)) return; shapes.push_back(new LaserPolyline(line, coloursystem, intens)); }
void update() { // Update our little offset thingy. offset += 0.01; if (offset > 1) { offset = 0; } // Update our camera. grabber.update(); // If the camera has a new frame to offer us ... if (grabber.isFrameNew()) { // Make a copy of our grabber pixels in the colorImage. colorImage.setFromPixels(grabber.getPixelsRef()); // When we assign a color image to a grayscale image, it is converted automatically. grayscaleImage = colorImage; // If we set learnBackground to true using the keyboard, we'll take a snapshot of // the background and use it to create a clean foreground image. if (learnBackground == true) { // We assign the grayscaleImage to the grayscaleBackgroundImage. grayscaleBackgroundImage = grayscaleImage; // Now we set learnBakground so we won't set a background unless // explicitly directed to with a keyboard command. learnBackground = false; } // Create a difference image by comparing the background and the current grayscale images. grayscaleAbsoluteDifference.absDiff(grayscaleBackgroundImage, grayscaleImage); // Assign grayscaleAbsoluteDifference to the grayscaleBinary image. grayscaleBinary = grayscaleAbsoluteDifference; // Then threshold the grayscale image to create a binary image. grayscaleBinary.threshold(threshold, invert); // Find contours (blobs) that are between the size of 20 pixels and // 1 / 3 * (width * height) of the camera. Also find holes. contourFinder.findContours(grayscaleBinary, 100, (width * height) / 3.0, 10, true); // Get the biggest blob and use it to draw. if (contourFinder.nBlobs > 0) { holePositions.addVertex(contourFinder.blobs[0].boundingRect.getCenter()); } else { holePositions.clear(); } } }
//-------------------------------------------------------------- void testApp::newPath() { path.clear(); // A path is a series of connected points // A more sophisticated path might be a curve path.addVertex(0, ofGetHeight()/2); path.addVertex(ofRandom(0, ofGetWidth()/2), ofRandom(0, ofGetHeight())); path.addVertex(ofRandom(ofGetWidth()/2, ofGetWidth()), ofRandom(0, ofGetHeight())); path.addVertex(ofGetWidth(), ofGetHeight()/2); }
vector<cv::Point2f> toCv(const ofPolyline& polyline) { // if polyline.getVertices() were const, this could wrap toCv(vec<vec2f>) vector<cv::Point2f> contour(polyline.size()); for(int i = 0; i < polyline.size(); i++) { contour[i].x = polyline[i].x; contour[i].y = polyline[i].y; } return contour; }
void ofCairoRenderer::draw(ofPolyline & poly){ cairo_new_path(cr); for(int i=0;i<(int)poly.size();i++){ cairo_line_to(cr,poly.getVertices()[i].x,poly.getVertices()[i].y); } if(poly.isClosed()) cairo_close_path(cr); cairo_stroke( cr ); }
// Backported from oF-dev branch on github float ShapeUtils::polylineArea(const ofPolyline &poly) { if (poly.size() < 2) return 0; float area = 0; for (int i = 0; i < (int) poly.size() - 1; i++) { area += poly[i].x * poly[i+1].y - poly[i+1].x * poly[i].y; } area += poly[poly.size()-1].x * poly[0].y - poly[0].x * poly[poly.size()-1].y; return 0.5 * area; }
void AnimatedShadow::insertHole( ofPolyline &holeContourLine ){ if (shapes.size() > 0){ holeContourLine.setClosed(true); holeContourLine.simplify(1); int lastFrame = shapes.size()-1; shapes[lastFrame].hole = holeContourLine.getSmoothed(1,1); shapes[lastFrame].haveHole = true; } }
void testApp::update(){ ofSetWindowTitle(ofToString(ofGetFrameRate())); mesh.clear(); for (int i = 0; i < balls.size(); i++) { balls[i].update(); float z = 0; ofPoint sp = ofPoint(balls[i].getPos().x, balls[i].getPos().y, z); mesh.curveTo(sp*1.0); } }
//---------------------------------------------------------- void ofGLRenderer::draw(ofPolyline & poly){ // use smoothness, if requested: if (bSmoothHinted) startSmoothing(); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_FLOAT, sizeof(ofVec3f), &poly.getVertices()[0].x); glDrawArrays(poly.isClosed()?GL_LINE_LOOP:GL_LINE_STRIP, 0, poly.size()); // use smoothness, if requested: if (bSmoothHinted) endSmoothing(); }
bool operator==(const ofPolyline& lhs, const ofPolyline& rhs) { vector<ofPoint> vertices1 = lhs.getVertices(); vector<ofPoint> vertices2 = rhs.getVertices(); if(vertices1.size() != vertices2.size()) return false; else { for(int i = 0; i < vertices1.size(); i++) { if(vertices1[i] != vertices2[i]) return false; } } return true; }
void ropeMesh::draw(ofPolyline stroke){ if (stroke.hasChanged()) { mesh.clear(); mesh.setMode(OF_PRIMITIVE_TRIANGLE_STRIP); vector < ofPoint > pts = stroke.getVertices(); for (int i = 0; i < pts.size(); i++){ int i_m_1 = MAX(i-1,0); int i_p_1 = MIN(i+1, pts.size()-1); ofPoint pta = pts[i_m_1]; ofPoint ptb = pts[i]; ofPoint ptc = pts[i_p_1]; ofPoint diff = ptc - pta; float angle = atan2(diff.y, diff.x); angle += PI/2; float width = 3; //diff.length(); ofPoint offsetA; offsetA.x = ptb.x + width * cos(angle); offsetA.y = ptb.y + width * sin(angle); ofPoint offsetB; offsetB.x = ptb.x - width * cos(angle); offsetB.y = ptb.y - width * sin(angle); ofSetColor(123,94,65); ofLine(offsetA, offsetB); mesh.addVertex(offsetA); mesh.addVertex(offsetB); } ofSetColor(197,155,108); ofFill(); mesh.draw(); ofSetRectMode(OF_RECTMODE_CENTER); if (stroke.size()>0) { top[num].draw(stroke.getVertices()[stroke.size()-1], width, height); } } }
void bezierSplinePoints(ofPolyline pnts, int count, int segments, ofPolyline & points) { double mu, mudelta; int x1, y1, x2, y2, n, h; ofVec2f pha, phb; if(count < 4 || count > 16383) return; // Phantom Points pha = ofVec2f(2.0*pnts[0].x-pnts[1].x, 2.0*pnts[0].y-pnts[1].y); phb = ofVec2f(2.0*pnts[count-1].x-pnts[count-2].x, 2.0*pnts[count-1].y-pnts[count-2].y); mudelta = 1.0 / segments; for(n = 2; n < count; n++) { mu = 0; if(n == 2) { x1 = Calculate(mu,pha.x,pnts[n-2].x,pnts[n-1].x,pnts[n].x); y1 = Calculate(mu,pha.y,pnts[n-2].y,pnts[n-1].y,pnts[n].y); } else if(n == count) { x1 = Calculate(mu,pnts[n-3].x,pnts[n-2].x,pnts[n-1].x,phb.x); y1 = Calculate(mu,pnts[n-3].y,pnts[n-2].y,pnts[n-1].y,phb.y); } else { x1 = Calculate(mu,pnts[n-3].x,pnts[n-2].x,pnts[n-1].x,pnts[n].x); y1 = Calculate(mu,pnts[n-3].y,pnts[n-2].y,pnts[n-1].y,pnts[n].y); } points.addVertex(x1, y1); mu = mu + mudelta; for(h = 1; h < segments; h++) { if(n == 2) { x2 = Calculate(mu,pha.x,pnts[n-2].x,pnts[n-1].x,pnts[n].x); y2 = Calculate(mu,pha.y,pnts[n-2].y,pnts[n-1].y,pnts[n].y); } else if(n == count) { x2 = Calculate(mu,pnts[n-3].x,pnts[n-2].x,pnts[n-1].x,phb.x); y2 = Calculate(mu,pnts[n-3].y,pnts[n-2].y,pnts[n-1].y,phb.y); } else { x2 = Calculate(mu,pnts[n-3].x,pnts[n-2].x,pnts[n-1].x,pnts[n].x); y2 = Calculate(mu,pnts[n-3].y,pnts[n-2].y,pnts[n-1].y,pnts[n].y); } points.addVertex(x2, y2); mu = mu + mudelta; } } }
// Backported from oF-dev branch on github ofPoint ShapeUtils::getCentroid2D(const ofPolyline &poly) { ofPoint centroid; for(int i=0;i<(int)poly.size()-1;i++){ centroid.x += (poly[i].x + poly[i+1].x) * (poly[i].x*poly[i+1].y - poly[i+1].x*poly[i].y); centroid.y += (poly[i].y + poly[i+1].y) * (poly[i].x*poly[i+1].y - poly[i+1].x*poly[i].y); } centroid.x += (poly[poly.size()-1].x + poly[0].x) * (poly[poly.size()-1].x*poly[0].y - poly[0].x*poly[poly.size()-1].y); centroid.y += (poly[poly.size()-1].y + poly[0].y) * (poly[poly.size()-1].x*poly[0].y - poly[0].x*poly[poly.size()-1].y); float area = ShapeUtils::polylineArea(poly); centroid.x /= (6*area); centroid.y /= (6*area); return centroid; }
//-------------------------------------------------------------- void ofxFatLine::setFromPolyline(ofPolyline & poly){ // ofxFatLine(); setGlobalColor(ofGetStyle().color); setGlobalWidth(ofGetStyle().lineWidth); if (!poly.getVertices().empty()){ addVertices(poly.getVertices()); for (int i = 0; i <getVertices().size(); i++) { addColor(globalColor); addWeight(globalWidth); } update(); //*/ } }
// Backported from oF-dev branch on github bool ShapeUtils::inside(const ofPolyline &polyline, float x, float y) { int counter = 0; int i; double xinters; ofPoint p1,p2; int N = polyline.size(); if (N == 0) { return false; } p1 = polyline[0]; for (i=1;i<=N;i++) { p2 = polyline[i % N]; if (y > MIN(p1.y,p2.y)) { if (y <= MAX(p1.y,p2.y)) { if (x <= MAX(p1.x,p2.x)) { if (p1.y != p2.y) { xinters = (y-p1.y)*(p2.x-p1.x)/(p2.y-p1.y)+p1.x; if (p1.x == p2.x || x <= xinters) counter++; } } } } p1 = p2; } if (counter % 2 == 0) return false; else return true; }
bool ShapeUtils::isRectangle(const ofPolyline &poly, float angle) { if (poly.size() != 4) { return false; } float delta = cos((90 - angle) * PI / 180); // Make sure it's a rectangle ofVec2f top = ofVec2f(poly[1].x - poly[0].x, poly[1].y - poly[0].y); ofVec2f right = ofVec2f(poly[2].x - poly[1].x, poly[2].y - poly[1].y); ofVec2f bottom = ofVec2f(poly[3].x - poly[2].x, poly[3].y - poly[2].y); ofVec2f left = ofVec2f(poly[0].x - poly[3].x, poly[0].y - poly[3].y); top.normalize(); right.normalize(); bottom.normalize(); left.normalize(); bool isRect = abs(top.dot(right)) < delta && abs(right.dot(bottom)) < delta && abs(bottom.dot(left)) < delta && abs(left.dot(top)) < delta; return isRect; }
void scanner_faces::draw_featEnMarco(ofPolyline feat, int gap, bool uu, bool rr) { ofRectangle featRect; featRect = feat.getBoundingBox(); featRect.x-=gap; featRect.y-=gap; featRect.width+=2*gap; featRect.height+=2*gap; ofSetLineWidth(1); if(rr) { ofLine(marco.rect.x-marco.gap, featRect.y, featRect.x, featRect.y); ofLine(marco.rect.x-marco.gap, featRect.y+featRect.height, featRect.x, featRect.y+featRect.height); } else { ofLine(marco.rect.x+marco.rect.width+marco.gap, featRect.y, featRect.x, featRect.y); ofLine(marco.rect.x+marco.rect.width+marco.gap, featRect.y+featRect.height, featRect.x, featRect.y+featRect.height); } if(uu) { ofLine(featRect.x, featRect.y, featRect.x, marco.rect.y-marco.gap); ofLine(featRect.x+marco.rect.width, featRect.y, featRect.x+marco.rect.width+marco.gap, featRect.y); } else { ofLine(featRect.x, featRect.y, featRect.x, marco.rect.y+marco.rect.height+marco.gap); ofLine(featRect.x+featRect.width, featRect.y, featRect.x+featRect.width, marco.rect.y+marco.rect.height+marco.gap); } ofSetLineWidth(2.5); ofRect(featRect); }
// // send ofPolyline to laser cutter // bool ofxEpilog::send(ofPolyline vector_vertexes) { if(vector_vertexes.size() == 0) return false; ofBuffer buffer; buffer.append(createPayloadHeader(getMachineProfile(), getOutputConfig())); // end raster part regardless of it's empty buffer.append(PCL_RASTER_END); // begin HPGL commands (vector part) buffer.append(HPGL_START); buffer.append(HPGL_VECTOR_INIT + HPGL_CMD_DELIMITER); // create vector part and append to the buffer buffer.append(createPayloadVectorBody(vector_vertexes, getOutputConfig())); if(!keep_alive) buffer.append(createPayloadFooter()); // end the session if(pjl_file.get() != NULL) pjl_file->writeFromBuffer(buffer); return tcp_client.sendRaw(buffer); }
glmPolyline toGlm(const ofPolyline &_poly){ glmPolyline poly; for (int i = 0; i < _poly.size(); i++) { poly.add(toGlm(_poly[i])); } return poly; }
void testApp::calibrationDone(ofPolyline &_surface){ ofLog(OF_LOG_NOTICE, "Calibration done"); if ( bStart ) killGame(); if (activeGameName == "simon"){ game = new Simon(); } else if (activeGameName == "pong"){ game = new Pong(); } else if (activeGameName == "shadows"){ game = new Shadows(); } else if (activeGameName == "oca"){ game = new Oca(); } else if (activeGameName == "communitas"){ game = new Communitas(); } else if (activeGameName == "kaleido"){ game = new Kaleido(); } if (game != NULL){ ofLog(OF_LOG_NOTICE, "Game " + activeGameName + " loaded"); game->init( _surface.getBoundingBox() ); iSurface.setTrackMode( game->getTrackMode() ); bStart = true; } else { ofLog(OF_LOG_ERROR, "Game " + activeGameName + " not loaded."); bStart = false; } }