Evan - ground truths

Author: FoST MacBook Air

.DS_Store

@@ -122,9 +122,10 @@ void BinaryImplementation::iterationProcess() {
 		}	
 	}
 }
-
+/*
 void BinaryImplementation::postIterationsProcess() {
         Rect croppedArea = experiment->getInfrastructure()->getCroppedArea();
+	double width = experiment->getInfrastructure()->getCameraResolution().width/getNumberColumns();
 	for (int y = 0; y < croppedArea.height; y++) {
 		int lastBinaryCode = -1;
 
@@ -134,11 +135,28 @@ void BinaryImplementation::postIterationsProcess() {
 			if (currentBinaryCode != -1 && currentBinaryCode != lastBinaryCode) {
 				
 				double displacement = getDisplacement((double)currentBinaryCode,x);
-				slDepthExperimentResult result(x, y, displacement * this->getScale());
+				slDepthExperimentResult result(currentBinaryCode*width/2, y, displacement * this->getScale());
 				experiment->storeResult(&result);
 
 				lastBinaryCode = currentBinaryCode;
 			}
 		}
 	}
 }
+*/
+double BinaryImplementation::solveCorrespondence(int x, int y) {
+	static int lastBinaryCode = -1;
+
+	if (x == 0) {
+		lastBinaryCode = -1;
+	}
+
+	int currentBinaryCode = getBinaryCode(x,y);
+
+	if (currentBinaryCode != -1 && currentBinaryCode != lastBinaryCode) {
+		lastBinaryCode = currentBinaryCode;
+		return (double)currentBinaryCode;
+	}
+
+	return -1;
+}	

BinaryImplementation.cpp

@@ -17,7 +17,7 @@ class BinaryImplementation : public slImplementation {
 		bool hasMoreIterations();
 		virtual Mat generatePattern();
 		virtual void iterationProcess();
-		virtual void postIterationsProcess();
+		//virtual void postIterationsProcess();
 		//Getters and Setters
 		unsigned int getNumberPatterns();
 		unsigned int getNumberColumns();
@@ -34,6 +34,8 @@ class BinaryImplementation : public slImplementation {
 
 		void generateBackground(Mat &pattern, Scalar &colour);
 
+		virtual double solveCorrespondence(int, int);
+
 	protected:
 		unsigned int numberPatterns;
 		unsigned int numberColumns;

BinaryImplementation.h

@@ -3,8 +3,8 @@ ifeq ($(OS),Windows_NT)
 	CV_LIB = /c/opencv/bin
 	CV_VERSION = 300
 else
-	CV_INCLUDE = /usr/local/include
-	CV_LIB = /usr/local/lib
+	CV_INCLUDE = /usr/local/Cellar/opencv3/3.2.0/include
+	CV_LIB = /usr/local/Cellar/opencv3/3.2.0/lib
 	CV_VERSION = 
 endif
 
@@ -30,7 +30,7 @@ $(LIBOBJS):%.o: %.cpp %.h
 	$(CXX) $(CPPFLAGS) -c $< -o $@
 
 clean:
-	-$(RM) $(LIBOBJS) main
+	-$(RM) $(LIBOBJS) slBenchmark
 
 clean_experiments:
 	-$(RM) -r [0-9]*/

GroundTruthImplementation.cpp

@@ -0,0 +1,77 @@
+import bpy
+import math
+import sys
+import os
+import json
+import numpy as np
+from mathutils import Vector
+
+def getDirection(camera):
+	#Y = np.tan(np.deg2rad(camera.angle_x / 2))
+	#Z = np.tan(np.deg2rad(camera.angle_y / 2))
+	Y = np.tan(bpy.data.cameras['Camera.001'].angle_x / 2)
+	Z = np.tan(bpy.data.cameras['Camera.001'].angle_y / 2)
+
+	return (-1, Y, Z)
+
+def getDirections(obj, camera, cameraWidth, cameraHeight, outputPath):
+	out = open(outputPath, 'w')
+	x, y, z = getDirection(camera)
+
+	for yDirection in np.linspace(-y, y, cameraWidth):
+		for zDirection in np.linspace(z, -z, cameraHeight):
+			dst = Vector((x, yDirection, zDirection)) + camera.location
+			direction = Vector((x, yDirection, zDirection)) 
+
+
+			mw = obj.matrix_world
+			mwi = mw.inverted()
+
+			# src and dst in local space of cb
+
+			origin = mwi * camera.location
+			dest = mwi * dst
+			direction = (dest - origin).normalized()
+
+			result, location, normal, index = obj.ray_cast(origin,  direction)
+
+			#xPixel = int(round(((yDirection + y) / (2 * y)) * cameraWidth))
+			#yPixel = int(round(((-zDirection + z) / (2 * z)) * cameraHeight))
+			xPixel = ((yDirection + y) / (2 * y)) * cameraWidth
+			yPixel = ((-zDirection + z) / (2 * z)) * cameraHeight
+			locationWorld = mw * location
+			fromCamera = locationWorld - camera.location
+
+			if result:
+				out.write(str(xPixel) + " " + str(yPixel) + " " + str(fromCamera.x) + '\n')
+	out.close()
+
+if __name__ == "__main__":
+	argv = sys.argv
+	argv = argv[argv.index("--") + 1:] 
+
+	bpy.ops.wm.open_mainfile(filepath=os.path.abspath(argv[0]))
+
+	outputPath = os.path.abspath(argv[1])
+	cameraWidth = int(argv[2])
+	cameraHeight = int(argv[3])
+
+	singleObject = None
+
+	for ob in bpy.context.scene.objects:
+		if ob.type == 'MESH':
+			ob.select = True
+			bpy.context.scene.objects.active = ob			
+		else:
+			ob.select = False
+
+	bpy.ops.object.join()
+
+	for ob in bpy.context.scene.objects:
+		if ob.type == 'MESH':
+			singleObject = ob
+
+
+	getDirections(singleObject, bpy.context.scene.camera, cameraWidth, cameraHeight, outputPath)
+
+	

GroundTruthImplementation.h

@@ -0,0 +1,90 @@
+#include "RaycastImplementation.h"
+
+RaycastImplementation::RaycastImplementation(): slImplementation(string("RaycastImplementation")) {
+	//this->setScale(250);
+	this->setScale(280);
+}
+
+bool RaycastImplementation::hasMoreIterations() {
+        return experiment->getIterationIndex() == 0;
+}
+
+Mat RaycastImplementation::generatePattern() {
+	Size cameraResolution = experiment->getInfrastructure()->getCameraResolution();
+	
+	int iterationIndex = experiment->getIterationIndex();
+
+	int cameraWidth = (int)cameraResolution.width;
+	int cameraHeight = (int)cameraResolution.height;
+
+	Mat pattern(cameraHeight, cameraWidth, CV_8UC3, Scalar(0, 0, 0));
+	return pattern;
+}
+
+void RaycastImplementation::postIterationsProcess() {
+	stringstream blenderFilename, outputFilename, blenderCommandLine;
+
+	blenderFilename << experiment->getPath() << "slVirtualScene_0.blend";
+	outputFilename << experiment->getPath() << "raycast_depth.xyz";
+
+	Size cameraResolution = experiment->getInfrastructure()->getCameraResolution();
+	Rect croppedArea = experiment->getInfrastructure()->getCroppedArea();
+
+	blenderCommandLine
+		<< "blender -b -P RaycastDepth.py -- "
+			<< blenderFilename.str() << " "
+			<< outputFilename.str() << " "
+			<< (int)cameraResolution.width << " "
+			<< (int)cameraResolution.height;
+
+	DB("blenderCommandLine: " << blenderCommandLine.str())
+
+	int exeResult = system(blenderCommandLine.str().c_str());
+
+	ifstream raycastDepthfile(outputFilename.str());
+	string line;
+
+	while (getline(raycastDepthfile, line)) {
+		stringstream lineStream(line);
+		istream_iterator<string> iterator(lineStream);
+		istream_iterator<string> end;
+		vector<string> results(iterator, end);
+
+		//int x = atoi(results[0].c_str());
+		//int y = atoi(results[1].c_str());
+		double x = atof(results[0].c_str());
+		double y = atof(results[1].c_str());
+		double z = atof(results[2].c_str());
+
+//		if (x >= croppedArea.x && x < (croppedArea.x + croppedArea.width) && y >= croppedArea.y && y < (croppedArea.y + croppedArea.height)) {
+			//slDepthExperimentResult result(x - croppedArea.x, y - croppedArea.y, z * this->getScale());
+			slDepthExperimentResult result(x, y, (z * this->getScale()) + 2660);
+			experiment->storeResult(&result);
+//		}
+	}
+
+	remove(outputFilename.str().c_str());
+/*
+	Rect croppedArea = experiment->getInfrastructure()->getCroppedArea();
+
+	for (int y = 0; y < croppedArea.height; y++) {
+		//int lastBinaryCode = -1;
+
+		for (int x = 0; x < croppedArea.width; x++) {
+			int currentOriginalColumn = originalColumn[(y * croppedArea.width) + x];
+
+			//if (currentBinaryCode != -1 && currentBinaryCode != lastBinaryCode) {
+			if (currentOriginalColumn != -1) {
+				
+				double displacement = 
+					((double)x / (double)croppedArea.width) - ((double)currentOriginalColumn / (double)experiment->getInfrastructure()->getCameraResolution().width);
+
+				slDepthExperimentResult result(x, y, displacement * RAYCAST_Z_SCALE);
+				experiment->storeResult(&result);
+
+				//lastBinaryCode = currentBinaryCode;
+			}
+		}
+	}
+*/	
+}

Makefile

@@ -0,0 +1,18 @@
+#ifndef RAYCAST_IMPLEMENTATION_H
+#define RAYCAST_IMPLEMENTATION_H
+
+#include "slBenchmark.h"
+
+using namespace cv;
+
+class RaycastImplementation : public slImplementation {
+	public:
+		RaycastImplementation();
+		virtual ~RaycastImplementation() {};
+		virtual Mat generatePattern();
+		virtual void postIterationsProcess();
+		bool hasMoreIterations();
+		virtual double solveCorrespondence(int, int) {return 0;}
+};
+
+#endif //RAYCAST_IMPLEMENTATION_H