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;
}
Exemple #2
0
//--------------------------------------------------------------
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();
	}
}
Exemple #3
0
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);
    }
}
Exemple #4
0
	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;		
	}
	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;		
	}
Exemple #6
0
// 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;
}
Exemple #7
0
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);
        }
    }
    
}
Exemple #8
0
void Plant::makeStroke(int i,
                       float min,
                       float max,
                       ofPolyline &centerLine,
                       ofPolyline *line1,
                       ofPolyline *line2
                       ){
    ofVec2f v = centerLine.getTangentAtIndex(i);
    float length = ofMap(i, 0, centerLine.size()-1, max, min) ;
    float angle = 90;
    float hackValue = 0.8;
    if(i==0 || i == centerLine.size()-1){
        ofVec2f p = centerLine.getVertices()[i] + v.rotate(angle)*length*hackValue;
        ofVec2f v2 = centerLine.getTangentAtIndex(i);
        ofVec2f p2 = centerLine.getVertices()[i] + v2.rotate(-angle)*length*hackValue;
        line1->lineTo(p);
        line2->lineTo(p2);
    }
    if(i>0 && i < centerLine.size()-1){
        makeCorner(line1, centerLine, i, angle, length);
        makeCorner(line2, centerLine, i, -angle, length);
    }
    if(i == centerLine.size()-1){
        ofVec2f v = centerLine.getTangentAtIndex(i);
        float length = ofMap(i, 0, centerLine.size()-1, min, min) ;
        ofVec2f _p2 = centerLine.getVertices()[i] + v.rotate(90)*length*hackValue;
        ofVec2f _p1 = centerLine.getVertices()[i] + v.rotate(180)*length*hackValue;
        ofVec2f _p3 = _p1 + (_p2 - _p1)/2;
        ofVec2f _delta = _p2 - _p1;
        ofVec2f pCenter = _p3 - _delta.getPerpendicular()*min;
        ofVec2f pLeft = pCenter - _delta/2;
        ofVec2f pRight = pCenter + _delta/2;
        
        line2->bezierTo(_p1, pLeft, pCenter);
        line1->bezierTo(_p2, pRight, pCenter);
        
        //                ofSetColor(ofColor::yellow);
        //                ofDrawCircle(p1, 5);
        //                ofSetColor(ofColor::red);
        //                ofDrawCircle(p2, 5);
        //                ofSetColor(ofColor::blueViolet);
        //                ofDrawCircle(p3, 5);
        //                ofSetColor(ofColor::darkMagenta);
        //                ofDrawCircle(pCenter, 5);
        //                ofSetColor(ofColor::lightPink);
        //                ofDrawCircle(pLeft, 5);
        //                ofSetColor(ofColor::lightSkyBlue);
        //                ofDrawCircle(pRight, 5);
    }

}
Exemple #9
0
// 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;
}
Exemple #10
0
glmPolyline toGlm(const ofPolyline &_poly){
    glmPolyline poly;
    for (int i = 0; i < _poly.size(); i++) {
        poly.add(toGlm(_poly[i]));
    }
    return poly;
}
Exemple #11
0
//--------------------------------------------------------------
// Code by Theo from URL above
//--------------------------------------------------------------
// http://www.openframeworks.cc/forum/viewtopic.php?f=9&t=1443
//--------------------------------------------------------------
bool phdPointInsidePolygon(ofPolyline & _points, float px, float py) {
    int N = _points.size();
    if (N == 0) return false;
    int counter = 0;
    int i;
    double xinters;
    ofPoint p1, p2;

    p1 = _points[0];
    for (int i = 1; i <= N; i++) {
        p2 = _points[i % N];
        if (py > MIN(p1.y,p2.y)) {
            if (py <= MAX(p1.y,p2.y)) {
                if (px <= MAX(p1.x,p2.x)) {
                    if (p1.y != p2.y) {
                        xinters = (py-p1.y)*(p2.x-p1.x)/(p2.y-p1.y)+p1.x;
                        if (p1.x == p2.x || px <= xinters) counter++;
                    }
                }
            }
        }
        p1 = p2;
    }

    if (counter % 2 == 0)
        return false;
    else
        return true;
}
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());
}
ofRectangle ofGetBoundingBox(const ofPolyline& polyline) {
	ofRectangle box;
	int n = polyline.size();
	if(n > 0) {
		const ofPoint& first = polyline[0];
		// inititally, use width and height as max x and max y
		box.set(first.x, first.y, first.x, first.y);
		for(int i = 0; i < n; i++) {
			const ofPoint& cur = polyline[i];
			if(cur.x < box.x) {
				box.x = cur.x;
			}
			if(cur.x > box.width) {
				box.width = cur.x;
			}
			if(cur.y < box.y) {
				box.y = cur.y;
			}
			if(cur.y > box.height) {
				box.height = cur.y;
			}
		}
		// later, we make width and height relative
		box.width -= box.x;
		box.height -= box.y;
	}
	return box;
}
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;
}
Exemple #15
0
//
// 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);
}
Exemple #16
0
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);
}
Exemple #17
0
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;
}
Exemple #18
0
// 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;
}
Exemple #19
0
// code example referenced from 3d/cameraRibbonExample
ofMesh ofApp::polylineToRibbonMesh(ofPolyline& polyline, float thickness) {
    
    ofMesh mesh;
    mesh.setMode(OF_PRIMITIVE_TRIANGLE_STRIP);
    
    for(int i = 1; i < polyline.size(); i++){
        
        //find this point and the next point
        ofVec3f thisPoint = polyline[i-1];
        ofVec3f nextPoint = polyline[i];
        
        //get the direction from one to the next.
        //the ribbon should fan out from this direction
        ofVec3f direction = (nextPoint - thisPoint);
        
        //get the distance from one point to the next
        //float distance = direction.length();
        
        //get the normalized direction. normalized vectors always have a length of one
        //and are really useful for representing directions as opposed to something with length
        ofVec3f unitDirection = direction.normalized();
        
        //find both directions to the left and to the right
        ofVec3f toTheLeft = unitDirection.getRotated(-90, ofVec3f(0,0,1));
        ofVec3f toTheRight = unitDirection.getRotated(90, ofVec3f(0,0,1));
        
        //calculate the points to the left and to the right
        //by extending the current point in the direction of left/right by the length
        ofVec3f leftPoint = thisPoint+toTheLeft * thickness;
        ofVec3f rightPoint = thisPoint+toTheRight * thickness;
        
        // fill mesh
        mesh.addVertex(leftPoint);
        mesh.addVertex(rightPoint);
        
        // draw the end? same orintation as previous
        // only need this if the end needs to join to the beginning
        if(i == polyline.size()-1) {
            ofVec3f firstLeft = mesh.getVertex(0);
            ofVec3f firstRight = mesh.getVertex(1);
            mesh.addVertex(firstLeft);
            mesh.addVertex(firstRight);
        }
    }
    
    return mesh;
}
Exemple #20
0
int phdPointOverVertex(ofPolyline & _points, double px, double py) {
    for(int i = 0; i < _points.size(); i++) {
        if(fabs(_points[i].x - px) < 5 && fabs(_points[i].y - py) < 5) {
            return i;
        }
    }
    return -1;
}
Exemple #21
0
//----------------------------------------
void ofxBox2dEdge::addVertexes(ofPolyline &polyline) {
	for (int i=0; i<polyline.size(); i++) {
		ofPolyline::addVertex(polyline[i].x, polyline[i].y);
	}
    // Temporary hack to ensure it's flagged as changed, until we
    // switch to OF 0.8.0.
    setClosed(isClosed());
}
//----------------------------------------------------------
void ofTessellator::tessellateToPolylines( const ofPolyline& src,  ofPolyWindingMode polyWindingMode, vector<ofPolyline>& dstpoly, bool bIs2D){

	if (src.size() > 0) {
		ofPolyline& polyline = const_cast<ofPolyline&>(src);
		tessAddContour(cacheTess, bIs2D ? 2 : 3, &polyline.getVertices()[0], sizeof(glm::vec3), polyline.size());
	}
	performTessellation( polyWindingMode, dstpoly, bIs2D );
}
// a much faster but less accurate version would check distances to vertices first,
// which assumes vertices are evenly spaced
ofPoint ofGetClosestPoint(const ofPolyline& polyline, const ofPoint& target, unsigned int* nearestIndex) {
	if(polyline.size() < 2) {
		if(nearestIndex != NULL) {
			nearestIndex = 0;
		}
		return target;
	}
	
	float distance = 0;
	ofPoint nearestPoint;
	unsigned int nearest = 0;
	float normalizedPosition = 0;
	unsigned int lastPosition = polyline.size() - 1;
	if(polyline.getClosed()) {
		lastPosition++;
	}
	for(int i = 0; i < (int) lastPosition; i++) {
		bool repeatNext = i == (int) (polyline.size() - 1);
		
		const ofPoint& cur = polyline[i];
		const ofPoint& next = repeatNext ? polyline[0] : polyline[i + 1];
		
		float curNormalizedPosition = 0;
		ofPoint curNearestPoint = ofGetClosestPoint(cur, next, target, &curNormalizedPosition);
		float curDistance = curNearestPoint.distance(target);
		if(i == 0 || curDistance < distance) {
			distance = curDistance;
			nearest = i;
			nearestPoint = curNearestPoint;
			normalizedPosition = curNormalizedPosition;
		}
	}
	
	if(nearestIndex != NULL) {
		if(normalizedPosition > .5) {
			nearest++;
			if(nearest == polyline.size()) {
				nearest = 0;
			}
		}
		*nearestIndex = nearest;
	}
	
	return nearestPoint;
}
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 );
}
vector< ofPoint > utility::findClosestPoints(ofPolyline one, ofPolyline two)
{
	float shortestDist = INFINITY;
	vector< ofPoint > closest;
	closest.resize(2);
	for (int i = 0; i < one.size(); ++i)
	{
		for (int j = i; j < two.size(); ++j)
		{
			float dsquared = ofDistSquared(one[i].x, one[i].y, two[j].x, two[j].y);
			if(dsquared <= shortestDist) {
				closest[0] = one[i];
				closest[1] = two[j];
			}
		}
	}

	return closest;
}
//----------------------------------------------------------
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();
}
Exemple #27
0
ofPath testApp::getPathFromPolyline(ofPolyline polyLine) {
    
    ofPath path;
    
    for (int i=0; i < polyLine.size(); i++) {
        path.lineTo(polyLine[i]);
    }
    
    return path;
    
}
ofPolyline utility::transform(ofPolyline input, int dx, int dy, float z, int r)
{
	ofPolyline output;		
	for (int i = 0; i < input.size(); ++i)
	{
		ofPoint pt = input[i];
		float tx = pt.x * z + dx;
		float ty = pt.y * z + dy;
		output.addVertex(ofPoint(tx, ty));
	}
	return output;
}
Exemple #29
0
//--------------------------------------------------------------
void drawWithNormals(const ofPolyline& polyline) {
	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, cur.y, 0);
		ofRotate(angle);
		ofDrawLine(0, 0, 0, distance);
		ofDrawLine(0, 0, distance, 0);
		glPopMatrix();
	}
}
Exemple #30
0
ofBuffer ofxEpilog::createPayloadVectorBody(ofPolyline vector_vertexes, OutputConfig &out_conf)
{
    ofBuffer buffer;
    
    // add vector vertexes
    if(vector_vertexes.size() > 0)
    {
        for(int i=0; i<vector_vertexes.size(); i++)
        {
            // update parameters of vector process
            buffer.append(createPayloadVectorParams(out_conf));
            
            if(out_conf.enable_laser_emit && i != 0)
                buffer.append(HPGL_VECTOR_PEN_DOWN); // PD
            else
                buffer.append(HPGL_VECTOR_PEN_UP); // PU
            
            // convert to HPGL vector format from ofPolyline (unit:inch)
            ofPoint p = vector_vertexes[i];
            buffer.append(ofToString( floor((out_conf.dpi/MM_PER_INCH) * p.x) ) + "," + ofToString( floor((out_conf.dpi/MM_PER_INCH) * p.y)) + ";");
        }
    }
    return buffer;
}