easier filled ofPolyline, or easy ofPolyline->ofPath conversion

[kylemcdonald]

to draw a filled ofPolyline right now, you need to use beginshape/endshape. but i think a way of adding ofPolylines to an ofPath would be really good -- even a conversion from ofPolyline to ofPath might make sense.

[jvcleave]

just ran into this and found it confusing because ofPolyline is able to draw() but doesn't respect the current fill style

simple test

ofPolyline line;

//--------------------------------------------------------------
void testApp::setup(){
    line.addVertex(ofPoint(0, 0));
    line.addVertex(ofPoint(100, 0));
    line.addVertex(ofPoint(50, 100));
    line.addVertex(ofPoint(0, 0));
    line.close();


}

//--------------------------------------------------------------
void testApp::update(){

}

//--------------------------------------------------------------
void testApp::draw(){
    ofFill();
    ofSetColor(ofColor::red);
    line.draw();

}

[kylemcdonald]

still relevant. for reference, what i meant from two years ago was:

ofPolyline polyline;
// ...
ofBeginShape();
vector<ofPoint>& vertices = polyline.getVertices();
for(int j = 0; j < vertices.size(); j++) {
    ofVertex(vertices[j]);
}
ofEndShape();

and i propose one of the following:

polyline.getPath();
ofPath path(polyline); // constructor

[danzeeeman]

+1
cause then you can cache your paths as an ofMesh or ofVbo!

ofVbo vbo;
ofMesh mesh = polyline.getPath().getTessellation();
vbo.setMesh(mesh, GL_STATIC_DRAW);

[themancalledjakob]

does this make sense as a function to convert a vector of polylines to an ofPath?

ofPath polysToPath(vector<ofPolyline> polylines) {
  ofPath path;
  for(int outline = 0; outline < polylines.size(); ++outline) {
        for (int i = 0; i < polylines[outline].getVertices().size(); i++){
            if ( i == 0 )
                path.moveTo(polylines[outline].getVertices()[i].x,polylines[outline].getVertices()[i].y);
            else
                path.lineTo(polylines[outline].getVertices()[i].x,polylines[outline].getVertices()[i].y);
        }
        path.close();
    }
    return path;
}

[arturoc]

i would add this as a constructor and method of ofPath + a version with 1 polyline only. That way it can also be optimized in case the internal representation of the path is polylines instead of ofPath::Command and avoiding instantiation in case you want to do this per frame for example

[bilderbuchi]

Also, shouldn't polylines[outline].getVertices() be buffered in the inner for loop for better performance?

[totalgee]

The whole vector is being copied in this call; it would be better to declare it as (taking a const reference):

ofPath polysToPath(const vector<ofPolyline>& polylines);

[hamoid]

With ofxClipper calculating the intersection between two polylines there's no simple way to draw the results as a filled shape. As a quick solution I added this method to ofPath:

void ofPath::set(const std::vector<ofPolyline> & lines) {
    commands.clear();
    polylines = lines;
    mode = POLYLINES;
    cachedTessellation.clear();
    flagShapeChanged();
}

I use it like this:

    std::vector<ofPolyline> intersection = clipper.getClipped(ClipperLib::ClipType::ctIntersection);
    ofPath result;
    result.set(intersection); // <-- here we populate ofPath
    result.setFilled(true);
    result.setFillColor(ofColor::darkGray);

I'm not sure I understand @arturoc above when mentioning 1 polyline only, but if accepting a vector is too much it would be nice to be able to add multiple polylines to the ofPath like this:

    std::vector<ofPolyline> intersection = clipper.getClipped(ClipperLib::ClipType::ctIntersection);
    ofPath result;
    for(auto & line : intersection) {
      result.addPolyline(line);
    }