much progress

2 files changed, 190 insertions, 19 deletions

diff --git a/drawing/src/ofApp.cpp b/drawing/src/ofApp.cpp
index da00262..f84f0b0 100644
--- a/drawing/src/ofApp.cpp
+++ b/drawing/src/ofApp.cpp
@@ -1,9 +1,6 @@
 #include "ofApp.h"
 #include "glew.h"
 
-int MAX_POINTS=20000;
-int LASER_INTENSITY=37;
-
 vector<std::string> cmdnames={"moveTo","lineTo","curveTo","bezierTo","quadBezierTo","arc","arcNegative","close"};
 
 //--------------------------------------------------------------
@@ -12,7 +9,7 @@ void ofApp::setup(){
 	svg.load("lorenzo.svg");
 	imagepaths= svg.getPaths();
 
-	float simplify_factor=0.3f;
+	float simplify_factor=0.2f;
 
 	std::stringstream strm;
 
@@ -89,8 +86,16 @@ void ofApp::setup(){
 
     dirIdx = -1;
 
-    laser.set_pts(MAX_POINTS);
-    laser.set_intensity(LASER_INTENSITY);
+    laser.set_pts(30000);
+    laser.set_intensity(40);
+
+    warpframe[0]=glm::vec2(0,0);
+    warpframe[1]=glm::vec2(ofGetWidth(),0);
+    warpframe[2]=glm::vec2(ofGetWidth(),ofGetHeight());
+    warpframe[3]=glm::vec2(0,ofGetHeight());
+    mapping_scale=1.8;
+    select_warpframe=-1;
+    bDrawFrame=false;
 }
 
 //these are our directory's callbacks
@@ -128,6 +133,95 @@ void ofApp::update(){
 	
 }
 
+void ofApp::drawWarpFrame(){
+    ofSetColor(255,255,255);
+    ofNoFill();
+    for (int i=0;i<4;i++){
+    	ofDrawCircle(warpframe[i],25);
+    	ofDrawLine(warpframe[i],warpframe[(i+1)%4]);
+    }
+}
+
+void ofApp::gaussianElimination(float * input, int n)
+{
+	auto i = 0;
+	auto j = 0;
+	auto m = n - 1;
+
+	while (i < m && j < n) 
+	{
+		auto iMax = i;
+		for (auto k = i + 1; k < m; ++k)
+		{
+			if (fabs(input[k * n + j]) > fabs(input[iMax * n + j])) 
+			{
+				iMax = k;
+			}
+		}
+
+		if (input[iMax * n + j] != 0) 
+		{
+			if (i != iMax)
+			{
+				for (auto k = 0; k < n; ++k)
+				{
+					auto ikIn = input[i * n + k];
+					input[i * n + k] = input[iMax * n + k];
+					input[iMax * n + k] = ikIn;
+				}
+			}
+
+			float ijIn = input[i * n + j];
+			for (auto k = 0; k < n; ++k)
+			{
+				input[i * n + k] /= ijIn;
+			}
+
+			for (auto u = i + 1; u < m; ++u)
+			{
+				auto ujIn = input[u * n + j];
+				for (auto k = 0; k < n; ++k)
+				{
+					input[u * n + k] -= ujIn * input[i * n + k];
+				}
+			}
+
+			++i;
+		}
+		++j;
+	}
+
+	for (auto i = m - 2; i >= 0; --i)
+	{
+		for (auto j = i + 1; j < n - 1; ++j)
+		{
+			input[i * n + m] -= input[i * n + j] * input[j * n + m];
+		}
+	}
+}
+
+glm::mat4 ofApp::getPerspectiveTransformMatrix(const glm::vec2 src[4], const glm::vec2 dst[4])
+{
+	float p[8][9] = 
+	{
+		{ -src[0][0], -src[0][1], -1, 0, 0, 0, src[0][0] * dst[0][0], src[0][1] * dst[0][0], -dst[0][0] }, // h11
+		{ 0, 0, 0, -src[0][0], -src[0][1], -1, src[0][0] * dst[0][1], src[0][1] * dst[0][1], -dst[0][1] }, // h12
+		{ -src[1][0], -src[1][1], -1, 0, 0, 0, src[1][0] * dst[1][0], src[1][1] * dst[1][0], -dst[1][0] }, // h13
+		{ 0, 0, 0, -src[1][0], -src[1][1], -1, src[1][0] * dst[1][1], src[1][1] * dst[1][1], -dst[1][1] }, // h21
+		{ -src[2][0], -src[2][1], -1, 0, 0, 0, src[2][0] * dst[2][0], src[2][1] * dst[2][0], -dst[2][0] }, // h22
+		{ 0, 0, 0, -src[2][0], -src[2][1], -1, src[2][0] * dst[2][1], src[2][1] * dst[2][1], -dst[2][1] }, // h23
+		{ -src[3][0], -src[3][1], -1, 0, 0, 0, src[3][0] * dst[3][0], src[3][1] * dst[3][0], -dst[3][0] }, // h31
+		{ 0, 0, 0, -src[3][0], -src[3][1], -1, src[3][0] * dst[3][1], src[3][1] * dst[3][1], -dst[3][1] }, // h32
+	};
+
+	gaussianElimination(&p[0][0], 9);
+
+	return glm::mat4(p[0][8], p[3][8], 0, p[6][8], 
+					 p[1][8], p[4][8], 0, p[7][8], 
+					 0, 0, 1, 0, 
+					 p[2][8], p[5][8], 0, 1);
+}
+
 ofPolyline ofApp::polyLineTransform(const ofPolyline& poly, ofMatrix4x4 xform){
 	ofPolyline tempPoly;
 	for (auto& p:poly){
@@ -136,7 +230,24 @@ ofPolyline ofApp::polyLineTransform(const ofPolyline& poly, ofMatrix4x4 xform){
 	return tempPoly;
 }
 
+ofPolyline ofApp::makePolygon(int num,float diam){
+	ofPolyline poly;
+	float step=PI*2/num;
+	for (int i=0;i<=num;i++){
+		poly.addVertex(cos(step*i)*diam,sin(step*i)*diam);
+	}
+	return poly;
+}
 
+void ofApp::drawPoly(ofPolyline poly,float x,float y){
+	glPushMatrix();
+	ofTranslate(x,y);
+	poly.draw();
+	for (int i=0;i<poly.size();i++){
+		ofDrawBitmapString(poly.getDegreesAtIndex(i),poly[i].x+10,poly[i].y+10,0);
+	}
+	glPopMatrix();
+}
 
 //--------------------------------------------------------------	
 void ofApp::draw(){
@@ -146,19 +257,27 @@ void ofApp::draw(){
 	int segmentsdrawn=0;
 	int pointsdrawn=0;
 
-	float phase=fmod(ofGetElapsedTimef()/10,1);
+	float phase=fmod(ofGetElapsedTimef()/3,1);
 
 	//movie.draw(0,0,ofGetWidth(),ofGetHeight());
 
 	//transform points of segmenter before intersecting with mask
 
-	vector <colourPolyline> lasershapes;
+	vector <ofPolyline> lasershapes;
 
 	switch (mode){
+		case 2:{				
+			for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
+				lasershapes.push_back(shape->getPoly());
+			}
+			break;
+		}
 		case 0:{
-			//int s=((int)ofGetElapsedTimef())%segmenters.size();
-			//lasershapes.push_back(segmenters[s].getPoly());
-				
+			int s=((int)(ofGetElapsedTimef()*10))%segmenters.size();
+			lasershapes.push_back(segmenters[s].getPoly());
+			break;
+		}
+		case 1:{	
 			for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
 				auto segments=shape->getSegments(numsegments,coverage,phase);
 
@@ -170,7 +289,7 @@ void ofApp::draw(){
 
 			break;
 		}
-		case 1:{
+		case 11:{
 			vector <ofPolyline> shapes;
 			for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
 				auto segments=shape->getSegments(numsegments,coverage,phase);
@@ -188,7 +307,7 @@ void ofApp::draw(){
 		    }
 		    break;
 		}
-		case 2:{
+		case 12:{
 			vector <ofPolyline> shapes;
 			for (auto shape=segmenters.begin();shape!=segmenters.end();shape++){
 				auto segments=shape->getSegments(numsegments,coverage,phase);
@@ -382,13 +501,41 @@ void ofApp::draw(){
 	vector <ofPath> paths= svg.getPaths();
 	for (auto& l:paths) l.draw();
 	*/
+
+	
+
+	glm::vec2 src[]={
+    	glm::vec2(0,0),
+    	glm::vec2(ofGetWidth(),0),
+    	glm::vec2(ofGetWidth(),ofGetHeight()),
+    	glm::vec2(0,ofGetHeight())
+    };
+
+    glm::vec2 mp=glm::vec2(ofGetWidth()/2,ofGetHeight()/2);
+
+    glm::vec2 scaled_dest[]={
+    	((warpframe[0]-mp)*mapping_scale)+mp,
+    	((warpframe[1]-mp)*mapping_scale)+mp,
+    	((warpframe[2]-mp)*mapping_scale)+mp,
+    	((warpframe[3]-mp)*mapping_scale)+mp
+    };
+
+    ofMatrix4x4 warp =getPerspectiveTransformMatrix(src,scaled_dest);
+
+    vector <ofPolyline> warpedshapes;
+
+    for (auto s:lasershapes){
+    	warpedshapes.push_back(polyLineTransform(s,warp));
+    }
 	
-	int num = laser.draw(lasershapes);
+	int num = laser.draw(warpedshapes);
 
 	for (auto& shape:lasershapes){
 		shape.draw();
 	}
 
+	if (bDrawFrame) drawWarpFrame();
+
     if (num>0){
         ofSetWindowTitle(ofToString(ofGetFrameRate(), 2)+" fps laser points: "+ofToString(num));
     }
@@ -472,6 +619,10 @@ void ofApp::keyReleased(int key){
 		        ofSetWindowTitle("No Server");
 		    }
 		}
+		case 'w':{
+			bDrawFrame=!bDrawFrame;
+			break;
+		}
 	}
 	
 }
@@ -483,17 +634,23 @@ void ofApp::mouseMoved(int x, int y ){
 
 //--------------------------------------------------------------
 void ofApp::mouseDragged(int x, int y, int button){
-	
+	if (select_warpframe>-1){
+		warpframe[select_warpframe]=glm::vec2(x,y);
+	}
 }
 
 //--------------------------------------------------------------
 void ofApp::mousePressed(int x, int y, int button){
-	
+	for (int i=0;i<4;i++){
+		if (ofPoint(x,y).distance(warpframe[i])<25){
+			select_warpframe=i;
+		}
+	}
 }
 
 //--------------------------------------------------------------
 void ofApp::mouseReleased(int x, int y, int button){
-
+	select_warpframe=-1;
 }
 
 //--------------------------------------------------------------
diff --git a/drawing/src/ofApp.h b/drawing/src/ofApp.h
index 13b3a0b..3cf9de8 100644
--- a/drawing/src/ofApp.h
+++ b/drawing/src/ofApp.h
@@ -35,8 +35,6 @@ class ofApp : public ofBaseApp{
 		void dragEvent(ofDragInfo dragInfo);
 		void gotMessage(ofMessage msg);
 
-		ofPolyline polyLineTransform(const ofPolyline& poly, ofMatrix4x4 xform);
-
 		vector <lineSegmenter> segmenters;
 		vector <ofPolyline> mask;
 		
@@ -73,4 +71,20 @@ class ofApp : public ofBaseApp{
         ofFbo syphonFbo;
 
         ofxHelios laser;
+
+        void drawWarpFrame();
+
+        void gaussianElimination(float * input, int n);
+		glm::mat4 getPerspectiveTransformMatrix(const glm::vec2 src[4], const glm::vec2 dst[4]);
+		ofPolyline polyLineTransform(const ofPolyline& poly, ofMatrix4x4 xform);
+		ofPolyline makePolygon(int num,float diam);
+		void drawPoly(ofPolyline poly,float x,float y);
+
+		glm::vec2 warpframe[4];
+		int select_warpframe;
+		float mapping_scale;
+
+		bool bDrawFrame;
+
+
 };