示例#1
0
void pathFactory::mousePointerStraight(ofPath &p, float x_dim, float y_dim, float t_size){

    vector<ofPoint> tpoints;

    float tw = 0.3;
    float sw = 0.074;
    float cl = 1;
    float al = 0.74;
    float bl = 0.55;

    tpoints.push_back(ofPoint(0,0));
    tpoints.push_back(ofPoint(-tw,al));//a1
    tpoints.push_back(ofPoint(-sw,bl)); // b1
    tpoints.push_back(ofPoint(-sw,cl)); //c1
    tpoints.push_back(ofPoint(sw,cl));//c2
    tpoints.push_back(ofPoint(sw,bl)); // b2
    tpoints.push_back(ofPoint(tw,al)); //a2
    tpoints.push_back(ofPoint(0,0));


    for(int i = 0; i < tpoints.size(); i++){
        tpoints[i] *= ofVec2f(x_dim, y_dim);
        tpoints[i] *= t_size;
        p.lineTo(tpoints[i]);
    }

    p.close();

}
示例#2
0
void ShapeContentRect::push(ofPath& path)
{
	vector<ofPath::Command>& command = path.getCommands();
	int command_count_prev = command.size();
	path.rectRounded(pos_-size_/2.f, size_.x, size_.y, roundness_);
	command_count_ = command.size() - command_count_prev;
}
示例#3
0
// Temporary fix until OF 0.8.0
static void rectangle(ofPath & path, const ofRectangle & r){
	path.moveTo(r.getTopLeft());
	path.lineTo(r.getTopRight());
	path.lineTo(r.getBottomRight());
	path.lineTo(r.getBottomLeft());
	path.close();
}
示例#4
0
void ShapeContentEllipse::push(ofPath& path)
{
	vector<ofPath::Command>& command = path.getCommands();
	int command_count_prev = command.size();
	path.ellipse(pos_.x, pos_.y, size_.x, size_.y);
	path.close();
	command_count_ = command.size() - command_count_prev;
}
示例#5
0
ofRectangle ofxGetBoundingBox(ofPath &path) {
  ofRectangle rect;
  for (int i=0; i<path.getOutline().size(); i++) {
    ofRectangle b = path.getOutline().at(i).getBoundingBox();
    if (i==0) rect = b;
    else rect.growToInclude(b);
  }
  return rect;
}
示例#6
0
void ofPath::append(const ofPath & path){
	if(mode==COMMANDS){
		for(auto & command: path.getCommands()){
			addCommand(command);
		}
	}else{
		for(auto & poly: path.getOutline()){
			polylines.push_back(poly);
		}
	}
	flagShapeChanged();
}
示例#7
0
void ShapeContentFill::pop(ofPath& path)
{
	ofPushStyle();
	path.setFilled(true);
	ofColor prev = path.getFillColor();
	float opacity = prev.a/255.f*opacity_;
	path.setFillColor(ofColor(color_, opacity*255));
	ofEnableBlendMode(blend_mode_);
	path.draw();
	path.setFillColor(prev);
	ofPopStyle();
}
 void handlePathDrawStyle(ofPath& p)
 {
     p.setFilled(m_hasFill);
     p.setFillColor(m_fillColor);
     p.setStrokeColor(m_strokeColor);
     if( m_hasStroke )
     {
         p.setStrokeWidth(m_strokeWeight);
     }
     else
     {
         p.setStrokeWidth(0);
     }
 }
void ofSetCurrentRenderer(ofPtr<ofBaseRenderer> renderer_){
	renderer = renderer_;
	renderer->setupGraphicDefaults();

	if(renderer->rendersPathPrimitives()){
		shape.setMode(ofPath::PATHS);
	}else{
		shape.setMode(ofPath::POLYLINES);
	}

	shape.setUseShapeColor(false);

	ofSetStyle(currentStyle);
}
示例#10
0
void ofxSimplifyPath(ofPath &path, int iterations, float amount) {
    for (int iteration=0; iteration<iterations; iteration++) {
        vector<ofSubPath> &subpaths = path.getSubPaths();
        for (int i=0; i<subpaths.size(); i++) {
            vector<ofSubPath::Command> &commands = subpaths[i].getCommands();
            if (commands.size()<amount) continue;
            for (int j=0; j<commands.size()-1; j++) {
                if (commands[j].to.distance(commands[j+1].to)<3) {
                    commands[j].to = (commands[j].to+commands[j+1].to)/2;
                    commands.erase(commands.begin()+j+1);
                }
            }
        }
    }
    path.flagShapeChanged();
}
示例#11
0
void pathFactory::roundedRect(ofPath &p, float x_dim, float y_dim, float t_size){

    ofRectangle r;
    r.setFromCenter(0,0, x_dim * t_size, y_dim * t_size);
    p.rectRounded(r, t_size/10);

}
示例#12
0
void ofSetCurrentRenderer(ofPtr<ofBaseRenderer> renderer_,bool setDefaults){
	renderer = renderer_;
	if(renderer->rendersPathPrimitives()){
		shape.setMode(ofPath::COMMANDS);
	}else{
		shape.setMode(ofPath::POLYLINES);
	}

	shape.setUseShapeColor(false);

	if(setDefaults){
		renderer->setupGraphicDefaults();
		ofSetStyle(currentStyle);
		ofBackground(currentStyle.bgColor);
	}
}
示例#13
0
bool Clipper::addPath(const ofPath& paths,
                      ClipperLib::PolyType PolyTyp,
                      bool autoClose,
                      ClipperLib::cInt scale)
{
    return addPolylines(paths.getOutline(), PolyTyp, autoClose, scale);
}
示例#14
0
void ofxSimplifyPath(ofPath &path, int iterations, float amount, float distance) { //wat doet amount?? should be distance???
    for (int iteration=0; iteration<iterations; iteration++) {
        vector<ofSubPath> &subpaths = path.getSubPaths();
        for (int i=0; i<subpaths.size(); i++) {
            vector<ofSubPath::Command> &commands = subpaths[i].getCommands();
            if (commands.size()<amount) continue;
            for (int j=1; j<commands.size()-2; j++) { //laat eerste en laatste punt met rust
                if (commands[j].to.distance(commands[j+1].to)<distance) {
                    commands[j].to = (commands[j].to+commands[j+1].to)/2;
                    commands.erase(commands.begin()+j+1);
                }
            }
        }
    }
    path.flagShapeChanged();
}
示例#15
0
void ShapeContentShape::pop(ofPath& path)
{
	vector<ofPath::Command>& command = path.getCommands();
	while(command_count_-- > 0) {
		command.pop_back();
	}
}
示例#16
0
void ShapeContentPoly::push(ofPath& path)
{
	vector<ofPath::Command>& command = path.getCommands();
	int command_count_prev = command.size();
	
	
	
	
	command_count_ = command.size() - command_count_prev;
}
示例#17
0
文件: main.cpp 项目: chparsons/ofxGPC
 void draw(){
     
     path.draw();
     path2.draw();
     
     ofPushMatrix();
     ofTranslate(300, 0);
     for ( auto p : unioned ) {
         p.draw();
     }
     ofPopMatrix();
     
     ofPushMatrix();
     ofTranslate(600, 0);
     for ( auto p : diffed ) {
         p.draw();
     }
     ofPopMatrix();
 }
示例#18
0
void ShapeContentPath::push(ofPath& path)
{
	vector<ofPath::Command>& command = path.getCommands();
	int command_count_prev = command.size();
	vector<ofPath::Command>& my_command = path_.getCommands();
	for(vector<ofPath::Command>::iterator it = my_command.begin(); it != my_command.end(); ++it) {
		command.push_back(*it);
	}
	command_count_ = command.size() - command_count_prev;
}
示例#19
0
文件: Svg.cpp 项目: cviejo/mPD
void Svg::setupShape(struct svgtiny_shape * shape, ofPath & path){

	float* p = shape->path;

	path.setFilled(false);

	if(shape->fill != svgtiny_TRANSPARENT){
		path.setFilled(true);
		path.setFillHexColor(shape->fill);
		path.setPolyWindingMode(OF_POLY_WINDING_NONZERO);
    }

	if(shape->stroke != svgtiny_TRANSPARENT){
		path.setStrokeWidth(shape->stroke_width);
		path.setStrokeHexColor(shape->stroke);
	}

	for(int i = 0; i < (int)shape->path_length;){
		if(p[i] == svgtiny_PATH_MOVE){
			path.moveTo(p[i + 1], p[i + 2]);
			i += 3;
		}
		else if(p[i] == svgtiny_PATH_CLOSE){
			path.close();

			i += 1;
		}
		else if(p[i] == svgtiny_PATH_LINE){
			path.lineTo(p[i + 1], p[i + 2]);
			i += 3;
		}
		else if(p[i] == svgtiny_PATH_BEZIER){
			path.bezierTo(p[i + 1], p[i + 2],
						   p[i + 3], p[i + 4],
						   p[i + 5], p[i + 6]);
			i += 7;
		}
		else{
			ofLogError("Svg") << "setupShape(): SVG parse error";
			i += 1;
		}
	}
}
示例#20
0
文件: main.cpp 项目: fraco/genArt
    void drawBranch(float x, float y, float radius, int level)
    {

        path.clear();
        path.setStrokeColor(ofColor::blueSteel);
        path.setStrokeWidth(level*2);
        path.arc(x,y, radius,radius, -180, 0);

        path.draw();
        
        ofFill();
        ofSetColor(56);
        ofCircle(x, y, level*3);
        
        if (level > 0 ){
            drawBranch(x-radius, y+radius/2, radius/2, level-1);
            drawBranch(x+radius, y+radius/2, radius/2, level-1);
        }
//        return drawBranch(x, y, radius, level);
    }
示例#21
0
vector<ofPoint*> ofxGetPointsFromPath(ofPath &path) {
    vector<ofPoint*> points;
    vector<ofSubPath> &subpaths = path.getSubPaths();
    for (int i=0; i<subpaths.size(); i++) {
        vector<ofSubPath::Command> &commands = subpaths[i].getCommands();
        for (int j=0; j<commands.size(); j++) {
            points.push_back(&commands[j].to);
        }
    }
    return points;
}
示例#22
0
    void keyPressed(int key) {
        switch (key) {
            case '/': case '\\': case '$': case '#': case '|': case '%': case '@': case '^': case '&': case '_': side.setShape(key); break;
            case '3': side.is3D=!side.is3D; break;
            case '<': twists-=.5; break;
            case '>': twists+=.5; break;
            case '\'': twists=0; break;
            case '?': showHelp(); break;
            case 'a': side.toggle(); break;
            case 'b': useSubpathColors=!useSubpathColors; break;
            case 'C': canvas.createCircle(); break;
            case 'c': canvas.clear(); files.unloadFile(); break;
            case 'd': debug=!debug; refreshDebugInfo(); break;
            case 'e': print(true); break;
            case 'f': ofToggleFullscreen(); break;
            case 'k': path.setFilled(!path.isFilled()); path.flagShapeChanged(); break;
            case 'h': objectHeight+=5; if (objectHeight>maxObjectHeight) objectHeight=maxObjectHeight; break;
            case 'H': objectHeight-=5; if (objectHeight<3) objectHeight=3; break;
            case 'G': ultimaker.sendCommand("G28 X0 Y0 Z0\nM84",2); break;
            case 'A': ultimaker.sendCommand("M84"); break;
            case 'T': ultimaker.sendCommand("M109 S230"); break;
            case 'l': files.loadNext(); break;
            case 'L': files.loadPrevious(); break;
            case 'o': files.load(); break;
            case 'p': case 'm': case OF_KEY_RETURN: print(); break;
            case 'q': stop(); break;
//            case 'r': ultimaker.setRelative(); break;
            case 'S': files.save(); break;
            case 's': files.saveAs(); break;
            case '`': showSubPathLines=!showSubPathLines;
            case 't': ultimaker.sendCommand("M105",1); break;
            case 'u': case 'z': canvas.undo(); break;
            case '~': files.deleteCurrentFile(); break;
            case ' ': files.listDir(); break;
            case 'x': files.saveSvg(resourceFolder+"template.svg",documentFolder+"output.svg"); break;
            case 27: if (ultimaker.isThreadRunning()) ultimaker.stopThread(); break;
            case 'n': cloneApp(); break; //run new instance of Doodle3D
            case 'i': cout << getNumInstances() << endl; break;
        }
    }
//--------------------------------------------------------------
ofMesh ofApp::createMeshFromPath(ofPath path, float thickness){
	ofMesh mesh;
	// get outline of original path (for sides)
	vector <ofPolyline> outline = path.getOutline();
	// add front to mesh
	mesh.append(path.getTessellation());
	// get number of vertices in original path
	int numVerts = mesh.getNumVertices();
	// define offset based on thickness
	ofVec3f offset = ofVec3f(0, 0, -thickness);
	// translate path
	path.translate(offset);
	// add back to mesh
	mesh.append(path.getTessellation());
	// add sides to mesh (via indices)
	for(int j = 0; j < outline.size(); j++){
		int outlineSize = outline[j].getVertices().size();
		vector <int> outlineIndices;
		for(int i = 1; i < outlineSize; i++){
			ofVec3f & v = outline[j].getVertices()[i];
			int originalIndex = -1;
			for(int k = 0; k < numVerts; k++){
				if(v.match(mesh.getVertices()[k])){
					originalIndex = k;
					break;
				}
			}
			outlineIndices.push_back(originalIndex);
		}
		for(int i = 0; i < outlineIndices.size(); i++){
			const int a = outlineIndices[i];
			const int b = outlineIndices[(i + 1) % outlineIndices.size()];
			const int c = outlineIndices[i] + numVerts;
			const int d = outlineIndices[(i + 1) % outlineIndices.size()] + numVerts;
			mesh.addTriangle(a, b, c);
			mesh.addTriangle(c, b, d);
		}
	}
	return mesh;
}
示例#24
0
vector<ofPolyline> ofxGetPolylinesFromPath(ofPath path) {
    vector<ofPolyline> polylines;
    vector<ofSubPath> &subpaths = path.getSubPaths();
    for (int i=0; i<subpaths.size(); i++) {
        ofPolyline poly;
        vector<ofSubPath::Command> &commands = subpaths[i].getCommands();
        for (int j=0; j<commands.size()-1; j++) {
            poly.addVertex(commands[i].to);
        }
        polylines.push_back(poly);
    }
    return polylines;
}
//--------------------------------------------------------------
ofPath ofApp::resamplePath(ofPath path, float spacing){
	ofPath resampledPath;
	vector <ofPolyline> polylines = path.getOutline();
	for(int j = 0; j < polylines.size(); j++){
		ofPolyline spacePoly = polylines[j].getResampledBySpacing(spacing);
		resampledPath.moveTo(spacePoly[0]);
		for(int k = 1; k < spacePoly.size(); k++){
			resampledPath.lineTo(spacePoly[k]);
		}
		resampledPath.lineTo(spacePoly[0]);
	}
	return resampledPath;
}
示例#26
0
// -----------------------------------
void Letter::setup(ofPath letter, float depth)
{    
    // Tessellation is subdividing a concave polygon into convex polygons.
    front = letter.getTessellation();
    back = front;  
    
    // Loop through all of the vertices in the "back" mesh
    // and move them back in on the "z" axis
    vector<ofPoint>& f = front.getVertices();
    vector<ofPoint>& b = back.getVertices();
    for(int j=0; j< f.size(); j++)
    {
        f[j].z += depth/2.0;
        b[j].z -= depth/2.0;
    }
}
示例#27
0
void ShapeContentStroke::pop(ofPath& path)
{
	ofPushStyle();
	path.setFilled(false);
	ofColor prev = path.getStrokeColor();
	float opacity = prev.a/255.f*opacity_;
	path.setStrokeColor(ofColor(color_, opacity*255));
	path.setStrokeWidth(stroke_width_);
	ofEnableBlendMode(blend_mode_);
	path.draw();
	path.setStrokeColor(prev);
	ofPopStyle();
}
示例#28
0
bool ofxEpilog::send(ofPath path)
{
    //
    // TODO([email protected]): test again and finish implementation
    //
    
    if (!tcp_client.isConnected())
    {
        return false;
    }
    
    ofBuffer buffer;
    
    vector<ofPolyline> line = path.getOutline();
    for (int i=0; i<line.size(); i++)
    {
        if(!send(line[i]))
            return false;
    }
    return true;
}
示例#29
0
void ShapeContentGroup::pop(ofPath& path)
{
	if(transform_.isDirty()) {
		transform_.refreshMatrix();
	}
	transform_.pushMatrix();
	ofColor prev_st = path.getStrokeColor();
	ofColor prev_fi = path.getFillColor();
	float opacity_st = prev_st.a/255.f*opacity_;
	float opacity_fi = prev_fi.a/255.f*opacity_;
	path.setStrokeColor(ofColor(prev_st, opacity_st*255));
	path.setFillColor(ofColor(prev_fi, opacity_fi*255));
	for(vector<ShapeContent*>::reverse_iterator it = content_.rbegin(); it != content_.rend(); ++it) {
		(*it)->pop(path);
	}
	path.setStrokeColor(prev_st);
	path.setFillColor(prev_fi);
	transform_.popMatrix();
}
示例#30
0
//----------------------------------------------------------
void ofGLRenderer::draw(ofPath & shape){
	ofColor prevColor;
	if(shape.getUseShapeColor()){
		prevColor = ofGetStyle().color;
	}
	if(shape.isFilled()){
		ofMesh & mesh = shape.getTessellation();
		if(shape.getUseShapeColor()){
			setColor( shape.getFillColor() * ofGetStyle().color,shape.getFillColor().a/255. * ofGetStyle().color.a);
		}
		draw(mesh);
	}
	if(shape.hasOutline()){
		float lineWidth = ofGetStyle().lineWidth;
		if(shape.getUseShapeColor()){
			setColor( shape.getStrokeColor() * ofGetStyle().color, shape.getStrokeColor().a/255. * ofGetStyle().color.a);
		}
		setLineWidth( shape.getStrokeWidth() );
		vector<ofPolyline> & outlines = shape.getOutline();
		for(int i=0; i<(int)outlines.size(); i++)
			draw(outlines[i]);
		setLineWidth(lineWidth);
	}
	if(shape.getUseShapeColor()){
		setColor(prevColor);
	}
}