void TextureWarpShader::renderTexture(GLenum mode, GLuint target, GLuint id, const Eigen::Matrix3fr &homography, const Eigen::Vector2i &imageSize, const Eigen::Vector4f *vertices,
const Eigen::Vector2f *textureCoords, int count)
{
assert(target == GL_TEXTURE_2D);
glUseProgram(mProgram.getId());
Eigen::Matrix3f finalH;
finalH = adjustHomography(imageSize, homography);
glUniformMatrix3fv(mUniformHomographyMatrix, 1, false, finalH.data());
// setup uniforms
glActiveTexture(GL_TEXTURE0);
glBindTexture(target, id);
glUniform1i(mUniformTexture, 0);
// drawing quad
glVertexAttribPointer(mAttribPosCoord, 4, GL_FLOAT, GL_FALSE, 0, vertices);
glVertexAttribPointer(mAttribTexCoord, 2, GL_FLOAT, GL_FALSE, 0, textureCoords);
glEnableVertexAttribArray(mAttribPosCoord);
glEnableVertexAttribArray(mAttribTexCoord);
glDrawArrays(mode, 0, count);
glDisableVertexAttribArray(mAttribPosCoord);
glDisableVertexAttribArray(mAttribTexCoord);
}
void ObjectRenderer::set_uniform(const char* name, const Eigen::Matrix3f& value)
{
assert(program.isLinked());
program.bind();
GLuint id = glGetUniformLocation(program.programId(),name);
if(id==-1)
printf("!!!WARNING: shader '%d' does not contain uniform variable '%s'\n", program.programId(), name);
glUniformMatrix3fv(id, 1, GL_FALSE, value.data());
program.release();
}
void Cube::render(const Eigen::Matrix4f& mvMatrix, const Eigen::Matrix4f& prMatrix, const Eigen::Matrix3f& nmMatrix) {
m_prog.use();
m_prog.setUniformMat4("mvM", mvMatrix.data());
m_prog.setUniformMat4("prM", prMatrix.data());
m_prog.setUniformMat3("nmM", nmMatrix.data());
m_geom.bind();
glDrawElements(GL_TRIANGLE_STRIP, 14, GL_UNSIGNED_INT, (char*)NULL);
m_geom.release();
}
bool ShaderProgram::setUniformValue(const std::string& name,
const Eigen::Matrix3f& matrix)
{
GLint location = static_cast<GLint>(findUniform(name));
if (location == -1) {
m_error = "Could not set uniform " + name + ". No such uniform.";
return false;
}
glUniformMatrix3fv(location, 1, GL_FALSE,
static_cast<const GLfloat*>(matrix.data()));
return true;
}
mat3 pca(PointCloud &pc) {
mat3 cov = pc.calcCov();
Eigen::Matrix3f mat = Eigen::Map<Eigen::Matrix3f>(value_ptr(cov));
Eigen::EigenSolver<Eigen::Matrix3f> solver(mat);
Eigen::Vector3f eigenVals = solver.eigenvalues().real();
Eigen::Matrix3f eigenVecs = solver.eigenvectors().real();
// Matrix containing eigenvectors in COLUMNS
mat3 eigM;
memcpy(value_ptr(eigM), eigenVecs.data(), sizeof(mat3));
// Sort on eigenvalues (quick bubble-sort)
float x = 0.0f, y = 0.0f, z = 0.0f;
int xI = 0, yI = 0, zI = 0;
for (int i = 0; i < 3; i++) {
float e = eigenVals[i];
if (e > x) {
// shuffle down
z = y;
zI = yI;
y = x;
yI = xI;
x = e;
xI = i;
}
else if (e > y) {
z = y;
zI = yI;
y = e;
yI = i;
}
else {
z = e;
zI = i;
}
}
// Ordered eigenvectors
mat3 sortedEig;
sortedEig[0] = eigM[xI];
sortedEig[1] = eigM[yI];
sortedEig[2] = eigM[zI];
static mat3 prevEig = sortedEig;
// Stabilization - match up the dot-sign
for (int i = 0; i < 3; i++) {
sortedEig[i] *= (dot(sortedEig[i], prevEig[i]) < 0) ? -1 : 1;
}
prevEig = sortedEig;
return sortedEig;
}
void CUDABuildLinearSystemRGBD::applyBL(CameraTrackingInput cameraTrackingInput, Eigen::Matrix3f& intrinsics, CameraTrackingParameters cameraTrackingParameters, float3 anglesOld, float3 translationOld, unsigned int imageWidth, unsigned int imageHeight, unsigned int level, Matrix6x7f& res, LinearSystemConfidence& conf)
{
unsigned int localWindowSize = 12;
if(level != 0) localWindowSize = max(1, localWindowSize/(4*level));
const unsigned int blockSize = 64;
const unsigned int dimX = (unsigned int)ceil(((float)imageWidth*imageHeight)/(localWindowSize*blockSize));
Eigen::Matrix3f intrinsicsRowMajor = intrinsics.transpose(); // Eigen is col major / cuda is row major
computeNormalEquations(imageWidth, imageHeight, d_output, cameraTrackingInput, intrinsicsRowMajor.data(), cameraTrackingParameters, anglesOld, translationOld, localWindowSize, blockSize);
cutilSafeCall(cudaMemcpy(h_output, d_output, sizeof(float)*30*dimX, cudaMemcpyDeviceToHost));
// Copy to CPU
res = reductionSystemCPU(h_output, dimX, conf);
}
// Eigen types to GLM types
glm::mat3 eigen_matrix3f_to_glm_mat3(const Eigen::Matrix3f &m)
{
return glm::make_mat3x3((const float *)m.data());
}
void WarpPosShader::setHomography(const Eigen::Matrix3f &h)
{
glUseProgram(mProgram.getId());
glUniformMatrix3fv(mUniformHomography, 1, false, h.data());
}
