diff --git a/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o b/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o
index 59809c72e6c2d7826035549e2235d96de11d102c..b6aa8bee2599dffe58502ea20650860108c1b484 100644
Binary files a/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o and b/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o differ
diff --git a/apps/specular_estimation/src/CookTorrance.fragmentshader b/apps/specular_estimation/src/CookTorrance.fragmentshader
new file mode 100644
index 0000000000000000000000000000000000000000..ecfae888279923a0c70f65dddd5ab80dfdd2cb2e
--- /dev/null
+++ b/apps/specular_estimation/src/CookTorrance.fragmentshader
@@ -0,0 +1,188 @@
+#version 330 core
+// https://stackoverflow.com/a/39684336
+
+// Interpolated values from the vertex shaders
+in vec2 UV;
+in vec3 Normal_cameraspace;
+in vec3 EyeDirection_cameraspace;
+in vec3 LightDirection_cameraspace;
+in vec4 ShadowCoord;
+//in vec3 Position_worldspace;
+
+// Ouput data
+layout(location = 0) out vec3 color;
+
+// Values that stay constant for the whole mesh.
+uniform sampler2D myTextureSampler;
+//uniform sampler2D mySpecularSampler;
+uniform mat4 MV;
+uniform sampler2DShadow shadowMap;
+//uniform vec3 LightPosition_worldspace;
+uniform float specularIntensity;
+uniform float specularPower;
+
+vec2 poissonDisk[16] = vec2[](
+ vec2( -0.94201624, -0.39906216 ),
+ vec2( 0.94558609, -0.76890725 ),
+ vec2( -0.094184101, -0.92938870 ),
+ vec2( 0.34495938, 0.29387760 ),
+ vec2( -0.91588581, 0.45771432 ),
+ vec2( -0.81544232, -0.87912464 ),
+ vec2( -0.38277543, 0.27676845 ),
+ vec2( 0.97484398, 0.75648379 ),
+ vec2( 0.44323325, -0.97511554 ),
+ vec2( 0.53742981, -0.47373420 ),
+ vec2( -0.26496911, -0.41893023 ),
+ vec2( 0.79197514, 0.19090188 ),
+ vec2( -0.24188840, 0.99706507 ),
+ vec2( -0.81409955, 0.91437590 ),
+ vec2( 0.19984126, 0.78641367 ),
+ vec2( 0.14383161, -0.14100790 )
+);
+
+// Returns a random number based on a vec3 and an int.
+float random(vec3 seed, int i) {
+ vec4 seed4 = vec4(seed, i);
+ float dot_product = dot(seed4, vec4(12.9898,78.233,45.164,94.673));
+ return fract(sin(dot_product) * 43758.5453);
+}
+
+
+
+float D(float m, float c) {
+ float c2 = c*c, m2 = m*m, c2m2 = c2*m2;
+ return exp((c2 - 1)/c2m2)/(3.14159*c2m2*c2);
+}
+float F(float R0, float NV) { return R0 + (1 - R0)*pow(1 - NV, 5); }
+float G(float NL, float NV, float NH, float HV) { return min(1, 2*NH*min(NV, NL)/HV); }
+
+
+void accumulate_light(special3 tangent, vec3 viewDir, float roughness, PerLight light, inout vec3 diffuse, inout vec3 specular) {
+ vec3 lightDir = quat_apply(tangent.q, light.position);
+
+ if(lightDir.z > 0)
+ {
+ lightDir = normalize(lightDir);
+ float NL = lightDir.z;
+ diffuse += NL * light.color;
+
+ float NV = viewDir.z;
+ if(NV > 0)
+ {
+ vec3 halfDir = normalize(lightDir + viewDir);
+ float NH = halfDir.z;
+ float HV = dot(halfDir, viewDir);
+ specular += D(roughness, NH)*F(0.034, NV)*G(NL, NV, NH, HV)/(4*NV*NL) * light.color;
+ }
+ }
+}
+
+void main() {
+ special3 tangent = {
+ vec3(0),
+ texture(u_bump, IN.UV.xy)
+ };
+
+ tangent = special_mul(IN.pos, tangent);
+ tangent = special_inverse(tangent);
+
+ const vec3 viewDir = normalize(tangent.v);
+
+ vec3 diffuse = texture( myTextureSampler, UV ).rgb;
+ vec3 specular = vec3(0);
+ float roughness = max(0.215 + texture(u_roughness, IN.IV.xy).r - .5, 0.001);
+ for(int i = 0; i < LIGHTS.nlights; ++i)
+ accumulate_light(tangent, viewDir, roughness, LIGHTS.lights[i], diffuse, specular);
+
+ OUT = vec4(diffuse*IN.diffuse.rgb + specular, IN.diffuse.a);
+}
+
+
+/*
+void main() {
+
+ // Light emission properties
+ vec3 LightColor = vec3(1, 1, 1);
+
+ // The power and colour of each light could be obtained from either the chrome sphere reflection or the Macbeth colour chart
+ float LightPower = 1.0f;
+
+ // Material properties
+ float ambientPower = 0.0f;
+ vec3 MaterialDiffuseColor = texture( myTextureSampler, UV ).rgb;
+ vec3 MaterialAmbientColor = vec3(ambientPower, ambientPower, ambientPower) * MaterialDiffuseColor;
+
+ vec3 MaterialSpecularColor = vec3(specularIntensity, specularIntensity, specularIntensity);
+ //vec3 MaterialSpecularColor = texture( myTextureSampler, UV ).rgb;
+
+ // Distance to the light
+ //float distance = length( LightPosition_worldspace - Position_worldspace );
+
+ // Normal of the computed fragment, in camera space
+ vec3 n = normalize( Normal_cameraspace );
+ // Direction of the light (from the fragment to the light)
+ vec3 l = normalize( LightDirection_cameraspace );
+ // Cosine of the angle between the normal and the light direction,
+ // clamped above 0
+ // - light is at the vertical of the triangle -> 1
+ // - light is perpendiular to the triangle -> 0
+ // - light is behind the triangle -> 0
+ float cosTheta = clamp( dot( n, l ), 0, 1 );
+
+ // Eye vector (towards the camera)
+ vec3 E = normalize(EyeDirection_cameraspace);
+ // Direction in which the triangle reflects the light
+ vec3 R = reflect(-l, n);
+ // Cosine of the angle between the Eye vector and the Reflect vector, clamped to 0
+ // - Looking into the reflection -> 1
+ // - Looking elsewhere -> <1
+ float cosAlpha = clamp( dot( E, R ), 0, 1 );
+
+ float visibility = 1.0f;
+
+ // Fixed bias
+ //float bias = 0.005;
+
+ // Variable bias, which reduces shadow acne by modifying the bias according to the slope.
+ float bias = 0.005*tan(acos(cosTheta));
+ bias = clamp(bias, 0, 0.01);
+
+ int samples = 16;
+ float darkness = 1.0 - ambientPower;
+
+ // Sample the shadow map 16 times
+ for (int i = 0; i < samples; i++) {
+ // use either :
+ // - Always the same samples. Gives a fixed pattern in the shadow, but no noise
+ // int index = i;
+ // - A random sample, based on the pixel's screen location. No banding, but the shadow moves with the camera, causing shimmering.
+ // int index = int(16.0*random(gl_FragCoord.xyy, i))%16;
+ // - A random sample, based on the pixel's position in world space. The position is rounded to the millimetre to avoid too much aliasing
+ // int index = int(16.0 * random(floor(Position_worldspace.xyz * 1000.0), i)) % 16;
+
+ // being fully in the shadow will eat up 4*0.2 = 0.8
+ // 0.2 potentially remain, which is quite dark.
+ //visibility -= 0.2*(1.0-texture( shadowMap, vec3(ShadowCoord.xy + poissonDisk[index]/700.0, (ShadowCoord.z-bias)/ShadowCoord.w) ));
+
+ // Orthographic Shadow Projection
+ //visibility -= (darkness/samples)*(1.0-texture( shadowMap, vec3(ShadowCoord.xy + poissonDisk[i]/700.0, (ShadowCoord.z-bias)/ShadowCoord.w) ));
+
+ // Perspective Shadow Projection
+ // texture( shadowMap, ShadowCoord.xy ).z is the distance between the light and the nearest occluder
+ // ShadowCoord.z is the distance between the light and the current fragment
+ visibility -= (darkness/samples)*(1.0-texture( shadowMap, vec3(ShadowCoord.xy/ShadowCoord.w + poissonDisk[i]/700.0, (ShadowCoord.z-bias)/ShadowCoord.w) ));
+ }
+
+ // For spot lights, use either one of these lines instead.
+ // if ( texture( shadowMap, (ShadowCoord.xy/ShadowCoord.w) ).z < (ShadowCoord.z-bias)/ShadowCoord.w )
+ // if ( textureProj( shadowMap, ShadowCoord.xyw ).z < (ShadowCoord.z-bias)/ShadowCoord.w )
+
+ color =
+ // Ambient: simulates indirect lighting
+ MaterialAmbientColor +
+ // Diffuse: "colour" of the object
+ visibility * MaterialDiffuseColor * LightColor * LightPower * cosTheta +
+ // Specular: reflective highlight, like a mirror
+ visibility * MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha, specularPower);
+}
+*/
\ No newline at end of file
diff --git a/apps/specular_estimation/src/OpenGL.h b/apps/specular_estimation/src/OpenGL.h
index 03ad8add82de58016fe0efe427e663d00dcfe740..799d5b60120ff818c959e083a47347fce88fba50 100644
--- a/apps/specular_estimation/src/OpenGL.h
+++ b/apps/specular_estimation/src/OpenGL.h
@@ -52,7 +52,7 @@ void renderPolygons(int windowWidth, int windowHeight, GLuint programID, glm::ve
void renderShadows(GLuint FramebufferName, int shadowResolution, GLuint depthProgramID, glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix, GLuint depthMatrixID, GLuint vertexbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, glm::mat4 depthModelMatrix, glm::mat4 depthMVP);
void renderShadowMap(GLuint quad_programID, GLuint depthTexture, GLuint texID, GLuint quad_vertexbuffer);
//void meanSquaredError(int imageNumber, int windowHeight, int windowWidth, std::string modelPath, std::vector < cv::Mat > textureImages, cv::Mat& residual, cv::Vec3d& residuals, double& sum, double SpecularIntensity, double SpecularPower);
-void meanSquaredError(int imageNumber, int windowHeight, int windowWidth, std::vector <cv::Mat> textureImages, double& sum);
+void meanSquaredError(int imageNumber, int windowHeight, int windowWidth, std::vector<cv::Mat> textureImages, double& sum);
double returnResidual(int imageNumber, int windowHeight, int windowWidth, std::vector<cv::Mat> textureImages, cv::Mat& residual, cv::Vec3d& residuals, double SpecularIntensity, double SpecularPower);
//void computeResiduals(cv::Vec3d& residual, std::vector< cv::Vec3d >& residuals, double& totalResidual, cv::Mat& residualImage, bool calculateResidual, glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix, int width, int height, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, cv::Mat lightDirections, std::vector<cv::Mat> textureImages, int lightNumber, int numberOfLights, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, GLuint programID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, GLuint MatrixID, std::string modelPath);
void viewModel(cv::Vec3d& residual, double& totalResidual, cv::Mat& residualImage, bool calculateResidual, glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix, int width, int height, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, cv::Mat lightDirections, std::vector<cv::Mat> textureImages, int lightNumber, int numberOfLights, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, GLuint programID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, GLuint MatrixID, std::string modelPath);
@@ -60,6 +60,12 @@ void RenderSynthetic(glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix,
void checkForErrors(std::string stage, bool printIfOK);
void calibrateLights(int& windowWidth, int& windowHeight, cv::Mat cv_texture);
+void initialiseOpenGLCT(cv::Mat cv_depth, cv::Mat cv_normals, cv::Mat cv_texture, cv::Mat lightDirections, int& windowWidth, int& windowHeight, glm::mat4& depthProjectionMatrix, glm::mat4& depthViewMatrix, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, GLuint& programID, GLuint& MatrixID, GLuint& ModelMatrixID, GLuint& ViewMatrixID, GLuint& DepthBiasID, GLuint& lightInvDirID, GLuint& Texture, GLuint& TextureID, GLuint& depthTexture, GLuint& ShadowMapID, GLuint& vertexbuffer, GLuint& uvbuffer, GLuint& normalbuffer, GLuint& elementbuffer, std::vector<unsigned int> & indices, GLuint& depthProgramID, GLuint& quad_programID, GLuint& FramebufferName, GLuint& quad_vertexbuffer, GLuint& VertexArrayID, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, int numberOfLights, bool calculateResidual, glm::mat4& depthMVP, glm::mat4& depthModelMatrix, glm::mat4& MVP, glm::mat4& ProjectionMatrix, glm::mat4& ViewMatrix, glm::mat4& ModelMatrix, glm::mat4& depthBiasMVP, glm::mat4& biasMatrix);
+void renderPolygonsCT(int windowWidth, int windowHeight, GLuint programID, glm::vec3 lightInvDir, GLuint MatrixID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, glm::mat4 MVP, glm::mat4 ModelMatrix, glm::mat4 ViewMatrix, glm::mat4 depthBiasMVP, GLuint SpecularIntensityID, double SpecularIntensity, GLuint SpecularPowerID, double SpecularPower);
+void terminateOpenGLCT(GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, GLuint programID, GLuint depthProgramID, GLuint quad_programID, GLuint Texture, GLuint FramebufferName, GLuint depthTexture, GLuint quad_vertexbuffer, GLuint VertexArrayID);
+void viewModelCT(cv::Vec3d& residual, double& totalResidual, cv::Mat& residualImage, bool calculateResidual, glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix, int width, int height, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, cv::Mat lightDirections, std::vector<cv::Mat> textureImages, int lightNumber, int numberOfLights, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, GLuint programID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, GLuint MatrixID, std::string modelPath);
+void RenderSyntheticCT(glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix, int width, int height, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, cv::Mat lightDirections, std::vector<cv::Mat>& textureImages, int numberOfLights, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, GLuint programID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, GLuint MatrixID, std::string modelPath);
+
void initialiseOpenGL(cv::Mat cv_depth, cv::Mat cv_normals, cv::Mat cv_texture, cv::Mat lightDirections, int& windowWidth, int& windowHeight, glm::mat4& depthProjectionMatrix, glm::mat4& depthViewMatrix, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, GLuint& programID, GLuint& MatrixID, GLuint& ModelMatrixID, GLuint& ViewMatrixID, GLuint& DepthBiasID, GLuint& lightInvDirID, GLuint& Texture, GLuint& TextureID, GLuint& depthTexture, GLuint& ShadowMapID, GLuint& vertexbuffer, GLuint& uvbuffer, GLuint& normalbuffer, GLuint& elementbuffer, std::vector<unsigned int> & indices, GLuint& depthProgramID, GLuint& quad_programID, GLuint& FramebufferName, GLuint& quad_vertexbuffer, GLuint& VertexArrayID, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, int numberOfLights, bool calculateResidual, glm::mat4& depthMVP, glm::mat4& depthModelMatrix, glm::mat4& MVP, glm::mat4& ProjectionMatrix, glm::mat4& ViewMatrix, glm::mat4& ModelMatrix, glm::mat4& depthBiasMVP, glm::mat4& biasMatrix) {
// Initialise the GLFW library first
if (!glfwInit()) {
@@ -1508,6 +1514,24 @@ void calibrateLights(int& windowWidth, int& windowHeight, cv::Mat cv_texture) {
//depthProjectionMatrix = glm::perspective<float>(45.0f, 1.0f, 1.0f, 100.0f);
//depthViewMatrix = glm::lookAt(glm::vec3(0, 0, 1), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
+ // Initial position: on +Z
+ glm::vec3 position = glm::vec3(0, 0, 1);
+ // Initial horizontal angle: toward -Z
+ float horizontalAngle = M_PI;
+ // Initial vertical angle: none
+ float verticalAngle = 0.0f;
+ // Initial Field of View
+ float FoV = 60.0f;
+ // Mouse Speed
+ float mouseSpeed = 0.005f;
+
+ bool perspectiveProjection = false, shadowControl = false, calculateResidual = false;
+ int lightNumber = 0;
+
+ glm::mat4 ViewMatrix, ProjectionMatrix;
+
+ double SpecularIntensity = 0.5, SpecularPower = 2;
+
do {
// Render to our framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
@@ -1582,23 +1606,7 @@ void calibrateLights(int& windowWidth, int& windowHeight, cv::Mat cv_texture) {
// Use our shader
glUseProgram(programID);
- // Initial position: on +Z
- glm::vec3 position = glm::vec3(0, 0, 1);
- // Initial horizontal angle: toward -Z
- float horizontalAngle = M_PI;
- // Initial vertical angle: none
- float verticalAngle = 0.0f;
- // Initial Field of View
- float FoV = 60.0f;
- // Mouse Speed
- float mouseSpeed = 0.005f;
- bool perspectiveProjection = false, shadowControl = false, calculateResidual = false;
- int lightNumber = 0;
-
- glm::mat4 ViewMatrix, ProjectionMatrix;
-
- double SpecularIntensity = 0.5, SpecularPower = 2;
// Compute the MVP matrix from keyboard and mouse input
computeMatricesFromInputs(windowWidth, windowHeight, position, horizontalAngle, verticalAngle, FoV, mouseSpeed, ProjectionMatrix, ViewMatrix, lightInvDir, depthProjectionMatrix, depthViewMatrix, perspectiveProjection, shadowControl, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower, calculateResidual);
@@ -1729,8 +1737,7 @@ void calibrateLights(int& windowWidth, int& windowHeight, cv::Mat cv_texture) {
glfwPollEvents();
} // Check if the ESC key was pressed or the window was closed
- while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
- glfwWindowShouldClose(window) == 0 );
+ while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS && glfwWindowShouldClose(window) == 0 );
// Cleanup VBO and shader
glDeleteBuffers(1, &vertexbuffer);
@@ -2513,4 +2520,454 @@ class OpenGL {
return fin_pt;
}*/
+
+void initialiseOpenGLCT(cv::Mat cv_depth, cv::Mat cv_normals, cv::Mat cv_texture, cv::Mat lightDirections, int& windowWidth, int& windowHeight, glm::mat4& depthProjectionMatrix, glm::mat4& depthViewMatrix, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, GLuint& programID, GLuint& MatrixID, GLuint& ModelMatrixID, GLuint& ViewMatrixID, GLuint& DepthBiasID, GLuint& lightInvDirID, GLuint& Texture, GLuint& TextureID, GLuint& depthTexture, GLuint& ShadowMapID, GLuint& vertexbuffer, GLuint& uvbuffer, GLuint& normalbuffer, GLuint& elementbuffer, std::vector<unsigned int> & indices, GLuint& depthProgramID, GLuint& quad_programID, GLuint& FramebufferName, GLuint& quad_vertexbuffer, GLuint& VertexArrayID, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, int numberOfLights, bool calculateResidual, glm::mat4& depthMVP, glm::mat4& depthModelMatrix, glm::mat4& MVP, glm::mat4& ProjectionMatrix, glm::mat4& ViewMatrix, glm::mat4& ModelMatrix, glm::mat4& depthBiasMVP, glm::mat4& biasMatrix) {
+ // Initialise the GLFW library first
+ if (!glfwInit()) {
+ std::cerr << "Failed to initialise GLFW.\n";
+ getchar();
+ return;
+ }
+ std::cout << "Initialised GLFW.\n";
+
+ glfwWindowHint(GLFW_SAMPLES, 4); // 4x antialiasing
+ glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // OpenGL 3.3
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Only needed for macOS
+ glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Disable old OpenGL
+
+ // Set the shadow resolution to 4096x4096
+ int shadowResolution = 4096;
+
+ // Open a window and create its OpenGL context
+ window = glfwCreateWindow(windowWidth, windowHeight, "Window", NULL, NULL);
+ if (window == NULL) {
+ std::cerr << "Failed to open GLFW window. Older Intel GPUs are not OpenGL 3.3 compatible.\n";
+ getchar();
+ glfwTerminate();
+ return;
+ }
+ glfwMakeContextCurrent(window);
+ std::cout << "Opened GLFW window.\n";
+
+ // On macOS with a retina screen it will be windowWidth*2 and windowHeight*2, so the actual framebuffer size is:
+ glfwGetFramebufferSize(window, &windowWidth, &windowHeight);
+
+ // Initialize GLEW
+ glewExperimental = true; // Needed for core profile
+ if (glewInit() != GLEW_OK) {
+ std::cerr << "Failed to initialise GLEW.\n";
+ getchar();
+ glfwTerminate();
+ return;
+ }
+ std::cout << "Initialised GLEW.\n";
+
+ // Ensure that the escape key being pressed can be captured
+ glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
+ // Hide the mouse and enable unlimited mouvement
+ //glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+ // Set the mouse at the center of the screen
+ glfwPollEvents();
+ //glfwSetCursorPos(window, windowWidth / 2, windowHeight / 2);
+
+ // Dark blue background
+ glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
+
+ // Enable depth test, which stores fragments in the Z-buffer
+ glEnable(GL_DEPTH_TEST);
+
+ // Accept fragment if it is closer to the camera than the former one
+ glDepthFunc(GL_LESS);
+
+ // Cull triangles which do not have a normal facing towards the camera
+ glEnable(GL_CULL_FACE);
+
+ // Create a Vertex Array Object (VAO) and set it as the current one
+ //GLuint VertexArrayID;
+ glGenVertexArrays(1, &VertexArrayID);
+ glBindVertexArray(VertexArrayID);
+
+ // Create and compile the GLSL program from the shaders
+ depthProgramID = LoadShaders("/home/thomas/Documents/Minimisation/apps/specular_estimation/src/DepthRTT.vertexshader", "/home/thomas/Documents/Minimisation/apps/specular_estimation/src/DepthRTT.fragmentshader");
+
+ // Get a handle for the "MVP" uniform
+ GLuint depthMatrixID = glGetUniformLocation(depthProgramID, "depthMVP");
+
+ // Load the texture
+ //GLuint Texture = loadDDS("C:/Users/tdwal/Documents/repos/OpenGLTutorials/tutorial16_shadowmaps/uvmap.DDS");
+ Texture = loadMat(cv_texture);
+ std::cout << "Texture loaded.\n\n";
+
+ // Read the .obj file
+ std::vector<glm::vec3> vertices;
+ std::vector<glm::vec2> uvs;
+ std::vector<glm::vec3> normals;
+ //std::vector<unsigned int> indices;
+ //bool res = loadOBJ("/home/thomas/Documents/Minimisation/apps/specular_estimation/src/sphere.obj", vertices, uvs, normals);
+ createMesh(cv_depth, cv_normals, vertices, uvs, normals, indices);
+ //createSphere(100, 100);
+ std::cout << "\nModel created.\n\n";
+
+ // Load it into a VBO
+ //GLuint vertexbuffer; // This will identify the vertex buffer
+ glGenBuffers(1, &vertexbuffer); // Generate 1 buffer, and put the resulting identifier in vertexbuffer
+ glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer); // The following commands will talk about the 'vertexbuffer' buffer
+ glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW); // Give the vertices to OpenGL
+
+ //GLuint uvbuffer;
+ glGenBuffers(1, &uvbuffer);
+ glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
+ glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(glm::vec2), &uvs[0], GL_STATIC_DRAW);
+
+ //GLuint normalbuffer;
+ glGenBuffers(1, &normalbuffer);
+ glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
+ glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(glm::vec3), &normals[0], GL_STATIC_DRAW);
+
+ // Generate a buffer for the indices as well
+ //GLuint elementbuffer;
+ glGenBuffers(1, &elementbuffer);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
+
+
+ // ---------------------------------------------
+ // Render to Texture - specific code begins here
+ // ---------------------------------------------
+
+ // The framebuffer, which regroups 0, 1 or more textures, and 0 or 1 depth buffers
+ FramebufferName = 0;
+ glGenFramebuffers(1, &FramebufferName);
+ glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
+
+ // Depth texture. Slower than a depth buffer, but can be sampled later in the shader
+ //GLuint depthTexture;
+ glGenTextures(1, &depthTexture);
+ glBindTexture(GL_TEXTURE_2D, depthTexture);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, shadowResolution, shadowResolution, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
+
+ glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthTexture, 0);
+
+ // No colour output in the bound framebuffer, only depth.
+ glDrawBuffer(GL_NONE);
+
+ // Always check if there are any errors in the framebuffer
+ if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+ return;
+
+ // The quad's FBO. Used only for visualising the shadowmap.
+ static const GLfloat g_quad_vertex_buffer_data[] = {
+ -1.0f, -1.0f, 0.0f,
+ 1.0f, -1.0f, 0.0f,
+ -1.0f, 1.0f, 0.0f,
+ -1.0f, 1.0f, 0.0f,
+ 1.0f, -1.0f, 0.0f,
+ 1.0f, 1.0f, 0.0f,
+ };
+
+ //GLuint quad_vertexbuffer;
+ glGenBuffers(1, &quad_vertexbuffer);
+ glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
+ glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
+
+ // Create and compile the GLSL program from the shaders
+ quad_programID = LoadShaders("/home/thomas/Documents/Minimisation/apps/specular_estimation/src/Passthrough.vertexshader", "/home/thomas/Documents/Minimisation/apps/specular_estimation/src/SimpleTexture.fragmentshader");
+ std::cout << "Shaders loaded.\n";
+ GLuint texID = glGetUniformLocation(quad_programID, "texture");
+ std::cout << "Uniform Location of texture found.\n";
+
+ // Create and compile the GLSL program from the shaders
+ programID = LoadShaders("/home/thomas/Documents/Minimisation/apps/specular_estimation/src/ShadowMapping.vertexshader", "/home/thomas/Documents/Minimisation/apps/specular_estimation/src/CookTorrance.fragmentshader");
+
+ // Get a handle for the "myTextureSampler" uniform
+ TextureID = glGetUniformLocation(programID, "myTextureSampler");
+ //SpecularID = glGetUniformLocation(programID, "mySpecularSampler");
+
+ SpecularIntensityID = glGetUniformLocation(programID, "specularIntensity");
+ SpecularPowerID = glGetUniformLocation(programID, "specularPower");
+
+ // Get a handle for the "MVP" uniform
+ MatrixID = glGetUniformLocation(programID, "MVP");
+ ViewMatrixID = glGetUniformLocation(programID, "V");
+ ModelMatrixID = glGetUniformLocation(programID, "M");
+ DepthBiasID = glGetUniformLocation(programID, "DepthBiasMVP");
+ ShadowMapID = glGetUniformLocation(programID, "shadowMap");
+
+ // Get a handle for the "LightPosition" uniform
+ lightInvDirID = glGetUniformLocation(programID, "LightInvDirection_worldspace");
+
+ // Compute the MVP matrix from the light's point of view
+ //lightInvDir = glm::vec3(0, 0, 1);
+ depthProjectionMatrix = glm::perspective<float>(45.0f, 1.0f, 1.0f, 100.0f);
+ depthViewMatrix = glm::lookAt(glm::vec3(0, 0, 1), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
+
+ // Initial position: on +Z
+ position = glm::vec3(0, 0, 1);
+ // Initial horizontal angle: toward -Z
+ horizontalAngle = M_PI;
+ // Initial vertical angle: none
+ verticalAngle = 0.0f;
+ // Initial Field of View
+ FoV = 60.0f;
+ // Mouse Speed
+ float mouseSpeed = 0.005f;
+
+ depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;
+ bool perspectiveProjection = false;
+ int lightNumber = 0;
+
+ // Compute the MVP matrix
+ computeMatricesFromLights(windowWidth, windowHeight, position, horizontalAngle, verticalAngle, FoV, ProjectionMatrix, ViewMatrix, lightInvDir, depthProjectionMatrix, depthViewMatrix, perspectiveProjection, lightDirections, lightNumber, numberOfLights, calculateResidual, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower);
+
+ MVP = ProjectionMatrix * ViewMatrix * ModelMatrix;
+ depthBiasMVP = biasMatrix * depthMVP;
+}
+
+
+void renderPolygonsCT(int windowWidth, int windowHeight, GLuint programID, glm::vec3 lightInvDir, GLuint MatrixID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, glm::mat4 MVP, glm::mat4 ModelMatrix, glm::mat4 ViewMatrix, glm::mat4 depthBiasMVP, GLuint SpecularIntensityID, double SpecularIntensity, GLuint SpecularPowerID, double SpecularPower) {
+
+ // Render to the screen
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ glViewport(0, 0, windowWidth, windowHeight); // Render on the whole framebuffer, complete from the lower left corner to the upper right
+
+ glEnable(GL_CULL_FACE);
+ glCullFace(GL_BACK); // Cull back-facing triangles -> draw only front-facing triangles
+
+ // Clear the screen
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ // Use the shader
+ glUseProgram(programID);
+
+ // Send the transformation to the currently bound shader, in the "MVP" uniform
+ glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);
+ glUniformMatrix4fv(ModelMatrixID, 1, GL_FALSE, &ModelMatrix[0][0]);
+ glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &ViewMatrix[0][0]);
+ glUniformMatrix4fv(DepthBiasID, 1, GL_FALSE, &depthBiasMVP[0][0]);
+
+ glUniform1f(SpecularIntensityID, SpecularIntensity);
+ glUniform1f(SpecularPowerID, SpecularPower);
+
+ glUniform3f(lightInvDirID, lightInvDir.x, lightInvDir.y, lightInvDir.z);
+
+ // Bind the texture in Texture Unit 0
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, Texture);
+ // Set the "myTextureSampler" sampler to use Texture Unit 0
+ glUniform1i(TextureID, 0);
+
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D, depthTexture);
+ glUniform1i(ShadowMapID, 1);
+
+ // 1st attribute buffer: vertices
+ glEnableVertexAttribArray(0);
+ glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
+ glVertexAttribPointer(
+ 0, // attribute
+ 3, // size
+ GL_FLOAT, // type
+ GL_FALSE, // normalized?
+ 0, // stride
+ (void*)0 // array buffer offset
+ );
+
+ // 2nd attribute buffer: UVs
+ glEnableVertexAttribArray(1);
+ glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);
+ glVertexAttribPointer(
+ 1, // attribute
+ 2, // size
+ GL_FLOAT, // type
+ GL_FALSE, // normalized?
+ 0, // stride
+ (void*)0 // array buffer offset
+ );
+
+ // 3rd attribute buffer: normals
+ glEnableVertexAttribArray(2);
+ glBindBuffer(GL_ARRAY_BUFFER, normalbuffer);
+ glVertexAttribPointer(
+ 2, // attribute
+ 3, // size
+ GL_FLOAT, // type
+ GL_FALSE, // normalized?
+ 0, // stride
+ (void*)0 // array buffer offset
+ );
+
+ // Index buffer
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
+
+ // Draw the triangles
+ glDrawElements(
+ GL_TRIANGLES, // mode
+ GLsizei(indices.size()), // count
+ GL_UNSIGNED_INT, // type
+ (void*)0 // element array buffer offset
+ );
+
+ glDisableVertexAttribArray(0);
+ glDisableVertexAttribArray(1);
+ glDisableVertexAttribArray(2);
+
+}
+
+void terminateOpenGLCT(GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, GLuint programID, GLuint depthProgramID, GLuint quad_programID, GLuint Texture, GLuint FramebufferName, GLuint depthTexture, GLuint quad_vertexbuffer, GLuint VertexArrayID) {
+
+ // Cleanup VBO and shader
+ glDeleteBuffers(1, &vertexbuffer);
+ glDeleteBuffers(1, &uvbuffer);
+ glDeleteBuffers(1, &normalbuffer);
+ glDeleteBuffers(1, &elementbuffer);
+ glDeleteProgram(programID);
+ glDeleteProgram(depthProgramID);
+ glDeleteProgram(quad_programID);
+ glDeleteTextures(1, &Texture);
+
+ glDeleteFramebuffers(1, &FramebufferName);
+ glDeleteTextures(1, &depthTexture);
+ glDeleteBuffers(1, &quad_vertexbuffer);
+ glDeleteVertexArrays(1, &VertexArrayID);
+
+ // Close OpenGL window and terminate GLFW
+ glfwTerminate();
+}
+
+void viewModelCT(cv::Vec3d& residual, double& totalResidual, cv::Mat& residualImage, bool calculateResidual, glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix, int width, int height, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, cv::Mat lightDirections, std::vector<cv::Mat> textureImages, int lightNumber, int numberOfLights, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, GLuint programID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, GLuint MatrixID, std::string modelPath) {
+ do {
+ // Render the shadows
+ glm::mat4 depthModelMatrix = glm::mat4(1.0);
+ glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;
+ //renderShadows(FramebufferName, shadowResolution, depthProgramID, depthProjectionMatrix, depthViewMatrix, depthMatrixID, vertexbuffer, elementbuffer, indices, depthModelMatrix, depthMVP);
+
+ // Compute the MVP matrix from keyboard and mouse input
+ glm::mat4 ModelMatrix = glm::mat4(1.0);
+ glm::mat4 MVP, ViewMatrix, depthBiasMVP, ProjectionMatrix;
+ bool perspectiveProjection = false, shadowControl;
+ //float mouseSpeed = 0.005f;
+ //computeMatricesFromInputs(width, height, position, horizontalAngle, verticalAngle, FoV, mouseSpeed, ProjectionMatrix, ViewMatrix, lightInvDir, depthProjectionMatrix, depthViewMatrix, perspectiveProjection, shadowControl, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower, calculateResidual);
+ computeMatricesFromLights(width, height, position, horizontalAngle, verticalAngle, FoV, ProjectionMatrix, ViewMatrix, lightInvDir, depthProjectionMatrix, depthViewMatrix, perspectiveProjection, lightDirections, lightNumber, numberOfLights, calculateResidual, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower);
+ MVP = ProjectionMatrix * ViewMatrix * ModelMatrix;
+
+ glm::mat4 biasMatrix(
+ 0.5, 0.0, 0.0, 0.0,
+ 0.0, 0.5, 0.0, 0.0,
+ 0.0, 0.0, 0.5, 0.0,
+ 0.5, 0.5, 0.5, 1.0
+ );
+
+ depthBiasMVP = biasMatrix * depthMVP;
+
+
+ // Render the polygons
+ renderPolygons(width, height, programID, lightInvDir, MatrixID, ModelMatrixID, ViewMatrixID, DepthBiasID, lightInvDirID, Texture, TextureID, depthTexture, ShadowMapID, vertexbuffer, uvbuffer, normalbuffer, elementbuffer, indices, MVP, ModelMatrix, ViewMatrix, depthBiasMVP, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower);
+
+ // Optionally render the shadowmap (for debug only)
+ //void renderShadowMap(GLuint quad_programID, GLuint depthTexture, GLuint texID, GLuint quad_vertexbuffer);
+
+ if (calculateResidual) {
+ double sum = 0;
+ meanSquaredError(lightNumber, height, width, textureImages, sum);
+ //computeResiduals(residual, residuals, totalResidual, residualImage, calculateResidual, depthProjectionMatrix, depthViewMatrix, width, height, position, horizontalAngle, verticalAngle, FoV, lightInvDir, lightDirections, textureImages, lightNumber, numberOfLights, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower, programID, ModelMatrixID, ViewMatrixID, DepthBiasID, lightInvDirID, Texture, TextureID, depthTexture, ShadowMapID, vertexbuffer, uvbuffer, normalbuffer, elementbuffer, indices, MatrixID, modelPath);
+ std::cout << "Light number: " << lightNumber << ", per-pixel residual = " << totalResidual << ", specular intensity = " << SpecularIntensity << ", specular power = " << SpecularPower << std::endl;
+ }
+
+
+ /*
+ // TODO: Check if the viewpoint has been changed
+ if (calculateResidual) {
+ // Compute the residual image and sum of differences
+ cv::Mat residualImage;
+ meanSquaredError(lightNumber, height, width, textureImages, residualImage, residuals, residual, SpecularIntensity, SpecularPower);
+
+ specularMinimisation(SpecularIntensity, SpecularPower, residual);
+ calculateResidual = false;
+ }
+ */
+
+ //totalResidual = returnResidual(lightNumber, height, width, textureImages, residualImage, residuals, SpecularIntensity, SpecularPower);
+ //meanSquaredError(lightNumber, height, width, textureImages, residualImage, residual, totalResidual, SpecularIntensity, SpecularPower);
+ //residuals.push_back(residual);
+
+ // Set up the only cost function (also known as residual). This uses auto-differentiation to obtain the derivative (jacobian).
+ // AutoDiffCostFunction<CostFunctor, (Dimensions of Residual), (Dimensions of Variables)>
+ //CostFunction* cost_function = new AutoDiffCostFunction<CostFunctor, 1, 2>(new CostFunctor);
+ //problem.AddResidualBlock(cost_function, NULL, &SpecularIntensity, &SpecularPower);
+
+ // Swap buffers
+ glfwSwapBuffers(window);
+ glfwPollEvents();
+ } while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0); // Check if the ESC key was pressed or the window was closed
+}
+
+void RenderSyntheticCT(glm::mat4 depthProjectionMatrix, glm::mat4 depthViewMatrix, int width, int height, glm::vec3& position, float& horizontalAngle, float& verticalAngle, float& FoV, glm::vec3& lightInvDir, cv::Mat lightDirections, std::vector<cv::Mat>& textureImages, int numberOfLights, GLuint& SpecularIntensityID, double& SpecularIntensity, GLuint& SpecularPowerID, double& SpecularPower, GLuint programID, GLuint ModelMatrixID, GLuint ViewMatrixID, GLuint DepthBiasID, GLuint lightInvDirID, GLuint Texture, GLuint TextureID, GLuint depthTexture, GLuint ShadowMapID, GLuint vertexbuffer, GLuint uvbuffer, GLuint normalbuffer, GLuint elementbuffer, std::vector<unsigned int> indices, GLuint MatrixID, std::string modelPath) {
+ for(int lightNumber = 0; lightNumber < numberOfLights; lightNumber++) {
+ // Render the shadows
+ glm::mat4 depthModelMatrix = glm::mat4(1.0);
+ glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;
+
+ // Compute the MVP matrix from keyboard and mouse input
+ glm::mat4 ModelMatrix = glm::mat4(1.0);
+ glm::mat4 MVP, ViewMatrix, depthBiasMVP, ProjectionMatrix;
+ bool perspectiveProjection = false, shadowControl, calculateResidual = false;
+ computeMatricesFromLights(width, height, position, horizontalAngle, verticalAngle, FoV, ProjectionMatrix, ViewMatrix, lightInvDir, depthProjectionMatrix, depthViewMatrix, perspectiveProjection, lightDirections, lightNumber, numberOfLights, calculateResidual, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower);
+ MVP = ProjectionMatrix * ViewMatrix * ModelMatrix;
+
+ glm::mat4 biasMatrix(
+ 0.5, 0.0, 0.0, 0.0,
+ 0.0, 0.5, 0.0, 0.0,
+ 0.0, 0.0, 0.5, 0.0,
+ 0.5, 0.5, 0.5, 1.0
+ );
+
+ depthBiasMVP = biasMatrix * depthMVP;
+
+ // Render the polygons
+ renderPolygons(width, height, programID, lightInvDir, MatrixID, ModelMatrixID, ViewMatrixID, DepthBiasID, lightInvDirID, Texture, TextureID, depthTexture, ShadowMapID, vertexbuffer, uvbuffer, normalbuffer, elementbuffer, indices, MVP, ModelMatrix, ViewMatrix, depthBiasMVP, SpecularIntensityID, SpecularIntensity, SpecularPowerID, SpecularPower);
+
+ // Create an empty Mat the same size as the image
+ cv::Mat temp = cv::Mat(height, width, CV_8UC3);
+
+ // Read the image into the Mat as an 8-bit colour image
+ glReadPixels(0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, temp.data);
+
+ // 3D models have the origin in the bottom-left corner, while images have the origin in the top-left corner. The image is flipped to convert between the two.
+ cv::flip(temp, temp, 0);
+
+ //temp = addNoise(temp, 0.1);
+ temp = AddGaussianNoise_Opencv(temp, 0, 0.001);
+ textureImages.push_back(temp);
+
+ std::ostringstream a, b, c;
+ a << lightNumber;
+ b << SpecularIntensity;
+ c << SpecularPower;
+ std::string imageNumber = a.str();
+ std::string specularIntensity = b.str();
+ std::string specularPower = c.str();
+
+ //cv::imwrite(modelPath + "Intensity" + specularIntensity + "Power" + specularPower + imageNumber + ".png", temp);
+ cv::imwrite(modelPath + imageNumber + ".png", temp);
+
+ // Swap buffers
+ glfwSwapBuffers(window);
+ glfwPollEvents();
+ } //while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(window) == 0); // Check if the ESC key was pressed or the window was closed
+}
+
+
+
+
+
+
#endif
diff --git a/apps/specular_estimation/src/ShadowMapping.fragmentshader b/apps/specular_estimation/src/ShadowMapping.fragmentshader
index d63f26fe6251040a4343027955b2721bdc7f6b71..17a335c3258e6fa7bf8ce7fcb8e84b460a696494 100644
--- a/apps/specular_estimation/src/ShadowMapping.fragmentshader
+++ b/apps/specular_estimation/src/ShadowMapping.fragmentshader
@@ -51,14 +51,11 @@ void main() {
// Light emission properties
vec3 LightColor = vec3(1, 1, 1);
- // The power and colour of each light could be obtained from either the chrome sphere reflection
- // or the Macbeth colour chart
+ // The power and colour of each light could be obtained from either the chrome sphere reflection or the Macbeth colour chart
float LightPower = 1.0f;
// Material properties
float ambientPower = 0.0f;
- //specularPower = 5.0f;
- //specularIntensity = 0.5f;
vec3 MaterialDiffuseColor = texture( myTextureSampler, UV ).rgb;
vec3 MaterialAmbientColor = vec3(ambientPower, ambientPower, ambientPower) * MaterialDiffuseColor;
diff --git a/apps/specular_estimation/src/specular_estimation.cc b/apps/specular_estimation/src/specular_estimation.cc
index 9f05e043e8677dad9642f4e73d40916ce1edc339..5a248f4ca5676114b292f6f524bcac3959036250 100644
--- a/apps/specular_estimation/src/specular_estimation.cc
+++ b/apps/specular_estimation/src/specular_estimation.cc
@@ -7,9 +7,9 @@ void denseSyntheticSample(std::string imageName, std::string calibration, double
int main(int argc, char** argv) {
- int windowWidth = 1092, windowHeight = 728;
+ /*int windowWidth = 1092, windowHeight = 728;
cv::Mat black = cv::Mat(windowHeight, windowWidth, CV_8UC3, cv::Scalar::all(0));
- calibrateLights(windowWidth, windowHeight, black);
+ calibrateLights(windowWidth, windowHeight, black);*/
// Required for the Ceres solver
google::InitGoogleLogging(argv[0]);
diff --git a/bin/specular_estimation b/bin/specular_estimation
index dd728f6f6c8af3dcea6eec57052514a615149049..1970896bb6a1733e85e36fa87ad7c8c540bc0e4f 100755
Binary files a/bin/specular_estimation and b/bin/specular_estimation differ