Пример #1
9
    /// @overload QGLWidget
    void paintGL(){
        vao.bind();
        program.bind();
        {
            
        ///--- Update modelview
#ifdef WITH_QGLVIEWER
            /// use the trackball to specify the matrices
            setup_modelview(camera(), program);
#else
            ///--- simple unit cube orthographic view
            static Eigen::Matrix4f M = Eigen::Matrix4f::Identity();
            static Eigen::Matrix4f P = Eigen::ortho(-1.0f, +1.0f, -1.0f, +1.0f, -1.0f, +1.0f);
            static Eigen::Matrix4f V = Eigen::Matrix4f::Identity();
            static Eigen::Matrix4f MV = V*M;
            static Eigen::Matrix4f MVP = P*MV;
            GLint MVP_id = glGetUniformLocation(program.programId(), "MVP");
            glUniformMatrix4fv(MVP_id, 1, GL_FALSE, MVP.data());
            GLint MV_id = glGetUniformLocation(program.programId(), "MV");
            glUniformMatrix4fv(MV_id, 1, GL_FALSE, MV.data());
#endif      
                        
            ///--- clear & draw
            glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
            glDrawElements(GL_TRIANGLES, triangles.size(), GL_UNSIGNED_INT, 0);
        }
        vao.release();
        program.release();
    }
Пример #2
0
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();
}
Пример #3
0
void TextureWarpShader::setMVPMatrix(const Eigen::Matrix4f &mvp)
{
	//Transpose to opengl column-major format
    glUseProgram(mProgram.getId());
    glUniformMatrix4fv(mUniformMVPMatrix, 1, false, mvp.data());

    glUseProgram(mProgram_Alpha.getId());
    glUniformMatrix4fv(mUniformMVPMatrix_Alpha, 1, false, mvp.data());

	glUseProgram(mProgram_Color.getId());
	glUniformMatrix4fv(mUniformMVPMatrix_Color, 1, false, mvp.data());
}
Пример #4
0
void stabilityWindow::updateCoM()
{
    if (!comVisu || comVisu->getNumChildren() == 0)
    {
        return;
    }

    // Draw CoM
    Eigen::Matrix4f globalPoseCoM;
    globalPoseCoM.setIdentity();

    if (currentRobotNodeSet)
    {
        globalPoseCoM.block(0, 3, 3, 1) = currentRobotNodeSet->getCoM();
    }
    else if (robot)
    {
        globalPoseCoM.block(0, 3, 3, 1) = robot->getCoMGlobal();
    }

    SoMatrixTransform* m = dynamic_cast<SoMatrixTransform*>(comVisu->getChild(0));

    if (m)
    {
        SbMatrix ma(reinterpret_cast<SbMat*>(globalPoseCoM.data()));
        // mm -> m
        ma[3][0] *= 0.001f;
        ma[3][1] *= 0.001f;
        ma[3][2] *= 0.001f;
        m->matrix.setValue(ma);
    }

    // Draw CoM projection
    if (currentRobotNodeSet && comProjectionVisu && comProjectionVisu->getNumChildren() > 0)
    {
        globalPoseCoM(2, 3) = 0;
        m = dynamic_cast<SoMatrixTransform*>(comProjectionVisu->getChild(0));

        if (m)
        {
            SbMatrix ma(reinterpret_cast<SbMat*>(globalPoseCoM.data()));
            // mm -> m
            ma[3][0] *= 0.001f;
            ma[3][1] *= 0.001f;
            ma[3][2] *= 0.001f;
            m->matrix.setValue(ma);
        }
    }
}
Пример #5
0
void nsgl::sendUniMat4(Program &prog, const std::string & uniName,
                       const Eigen::Matrix4f & mat4) {
    if (prog.getUniform(uniName).isValid()) {
        glUniformMatrix4fv(prog.getUniform(uniName).location, 1, GL_FALSE,
                           mat4.data());
    }
}
Пример #6
0
void nsgl::sendUniMat4v(Program &prog, const std::string & uniName,
                        int numToSend, const Eigen::Matrix4f & firstMat4) {
    if (prog.getUniform(uniName).isValid()) {
        glUniformMatrix4fv(prog.getUniform(uniName).location, numToSend,
                           GL_FALSE, firstMat4.data());
    }
}
Пример #7
0
void stabilityWindow::comTargetMovedX(int value)
{
	if(!currentRobotNodeSet)
		return;

	Eigen::Matrix4f T;
	T.setIdentity();

	m_CoMTarget(0) = value;
	T.block(0, 3, 2, 1) = m_CoMTarget;

	if(comTargetVisu && comTargetVisu->getNumChildren() > 0)
	{
		SoMatrixTransform *m = dynamic_cast<SoMatrixTransform *>(comTargetVisu->getChild(0));
		if(m)
		{
			SbMatrix ma(reinterpret_cast<SbMat*>(T.data()));
            // mm -> m
            ma[3][0] *= 0.001f;
            ma[3][1] *= 0.001f;
            ma[3][2] *= 0.001f;
			m->matrix.setValue(ma);
		}
	}

	performCoMIK();
}
Пример #8
0
void view() {
  // 透視変換を操作するお!と宣言
  glMatrixMode(GL_PROJECTION);
  // 正規行列を読み込む
  glLoadIdentity();
  
  glViewport(0, 0, Width, Height);
  
  // 透視変換行列を作成して適用
  // glFrustum(GLdouble left, GLdouble right,
  //           GLdouble bottom, GLdouble top,
  //           GLdouble near, GLdouble far);
  // 左端の座標、右端の座標
  // 下端の座標、上端の座標
  // 最前面までの距離、最前面までの距離(距離はどちらも0より大きい値)
  /*glFrustum( -1,    1,
   1,   -1,
   0.5, 20.0);*/
  
  // Eigenの行列をOpenGLに渡す
  float aspect = Width / float(Height);
  Eigen::Matrix4f m = perspectiveView(36, aspect, 0.5, 50);
  glMultMatrixf(m.data());
  
  // モデリング行列を操作するお!と宣言
  glMatrixMode(GL_MODELVIEW);
  // 正規行列を読み込む
  glLoadIdentity();
}
Пример #9
0
// had to separate declaration from implementation due to compilation errors on linux
void ObjectRenderer::set_uniform(const char* name, const Eigen::Matrix4f& 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);
    glUniformMatrix4fv(id, 1, GL_FALSE, value.data());
    program.release();
}
HRESULT DX11BuildLinearSystem::applyBL( ID3D11DeviceContext* context, ID3D11ShaderResourceView* inputSRV, ID3D11ShaderResourceView* correspondenceSRV, ID3D11ShaderResourceView* correspondenceNormalsSRV, D3DXVECTOR3& mean, float meanStDev, Eigen::Matrix4f& deltaTransform, unsigned int imageWidth, unsigned int imageHeight, unsigned int level, Matrix6x7f& res, LinearSystemConfidence& conf )
{
	HRESULT hr = S_OK;

	unsigned int dimX = (unsigned int)ceil(((float)imageWidth*imageHeight)/(GlobalCameraTrackingState::getInstance().s_localWindowSize[level]*m_blockSizeBL));

	Eigen::Matrix4f deltaTransformT = deltaTransform.transpose();

	// Initialize Constant Buffer
	D3D11_MAPPED_SUBRESOURCE mappedResource;
	V_RETURN(context->Map(m_constantBufferBL, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource))

	CBufferBL *cbuffer = (CBufferBL*)mappedResource.pData;
	cbuffer->imageWidth = (int)imageWidth;
	cbuffer->imageHeigth = (int)imageHeight;
	memcpy(cbuffer->deltaTransform, deltaTransformT.data(), 16*sizeof(float));
	cbuffer->imageHeigth = (int)imageHeight;
	memcpy(cbuffer->mean, (float*)mean, 3*sizeof(float));
	cbuffer->meanStDevInv = 1.0f/meanStDev;			
	context->Unmap(m_constantBufferBL, 0);

	// Setup Pipeline
	context->CSSetShaderResources(0, 1, &inputSRV);
	context->CSSetShaderResources(1, 1, &correspondenceSRV);
	context->CSSetShaderResources(2, 1, &correspondenceNormalsSRV);
	context->CSSetUnorderedAccessViews(0, 1, &m_pOutputFloatUAV, 0);
	context->CSSetConstantBuffers(0, 1, &m_constantBufferBL);
	context->CSSetShader(m_pComputeShaderBL[level], 0, 0);

	// Start Compute Shader
	context->Dispatch(dimX, 1, 1);
	assert(dimX <= D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION);

	// De-Initialize Pipeline
	ID3D11ShaderResourceView* nullSAV[1] = { NULL };
	ID3D11UnorderedAccessView* nullUAV[1] = { NULL };
	ID3D11Buffer* nullCB[1] = { NULL };

	context->CSSetShaderResources(0, 1, nullSAV);
	context->CSSetShaderResources(1, 1, nullSAV);
	context->CSSetShaderResources(2, 1, nullSAV);
	context->CSSetUnorderedAccessViews(0, 1, nullUAV, 0);
	context->CSSetConstantBuffers(0, 1, nullCB);
	context->CSSetShader(0, 0, 0);

	// Copy to CPU
	context->CopyResource(m_pOutputFloatCPU, m_pOutputFloat);
	V_RETURN(context->Map(m_pOutputFloatCPU, 0, D3D11_MAP_READ, 0, &mappedResource));
	res = reductionSystemCPU((float*)mappedResource.pData, dimX, conf);

	context->Unmap(m_pOutputFloatCPU, 0);

	return hr;
}
Пример #11
0
bool ShaderProgram::setUniformValue(const std::string& name,
                                    const Eigen::Matrix4f& matrix)
{
  GLint location = static_cast<GLint>(findUniform(name));
  if (location == -1) {
    m_error = "Could not set uniform " + name + ". No such uniform.";
    return false;
  }
  glUniformMatrix4fv(location, 1, GL_FALSE,
                     static_cast<const GLfloat*>(matrix.data()));
  return true;
}
Пример #12
0
void MainCamera::perspView() {
  float f = float(1. / std::tan(toRadians(fovy_) * 0.5));
  float g = -((far_ + near_) / (far_ - near_));
  float h = -((2 * far_ * near_) / (far_ - near_));
  float i = f / aspect_;

  Eigen::Matrix4f m;
  m <<    i, 0.0f, 0.0f, 0.0f,
       0.0f,    f, 0.0f, 0.0f,
       0.0f, 0.0f,    g,    h,
       0.0f, 0.0f,   -1, 0.0f;

  glMultMatrixf(m.data());
}
Пример #13
0
void display_form(int form, Eigen::Matrix4f marker_matrix, float falling){
    glMatrixMode(GL_MODELVIEW);

    glColor4f(1.0, 0.0, 0.0, 1.0);

    //transform to marker
    glLoadTransposeMatrixf(marker_matrix.data());
    glTranslatef(0.0, 0.0, falling);

    //move to marker position
    if(form == 0){
        glutSolidSphere(0.02, 10, 100);
    } else {
        drawCube(0.04);
    }
}
Пример #14
0
void display_fallthrough(Eigen::Matrix4f marker_matrix){

    glClear(GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);

    glColor4f(0.0, 0.0, 0.0, 1.0);
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

    //transform to marker
    glLoadTransposeMatrixf(marker_matrix.data());
    glTranslatef(0.0, 0.0, 0.06);
    drawCube(0.08);

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
Пример #15
0
Eigen::Matrix4f
orthoMatrix(
	GLfloat left,  GLfloat right,
	GLfloat top,   GLfloat bottom,
	GLfloat nearz, GLfloat farz
) {
	GLfloat const tx = -((right + left) / (right - left));
	GLfloat const ty = -((top + bottom) / (top - bottom));
	GLfloat const tz = -((farz + nearz) / (farz - nearz));

	GLfloat const matrix[] = {
		2.0f / (right - left),	0.0f,					0.0f,					tx,	
		0.0f,					2.0f / (top - bottom),	0.0f,					ty,	
		0.0f,					0.0f,					-2.0f / (farz - nearz),	tz,
		0.0f,					0.0f,					0.0f,					1.0f,
	};

	Eigen::Matrix4f result;
	::memcpy(result.data(), matrix, sizeof(matrix));
	result.matrix().transposeInPlace();

	return result;
}
Пример #16
0
void MainCamera::lookToTarget() {
  Vec3f z = getForward() / getForward().length();

  Vec3f b = up_.cross(z);
  Vec3f x = b / b.length();

  Vec3f y = z.cross(x);

  Eigen::Matrix4f R;
  R << x.x,   x.y,  x.z, 0.0f,
       y.x,   y.y,  y.z, 0.0f,
       z.x,   z.y,  z.z, 0.0f,
       0.0f, 0.0f, 0.0f, 1.0f;

  Eigen::Matrix4f T;
  T << 1.0f, 0.0f, 0.0f, -pos_.x,
       0.0f, 1.0f, 0.0f, -pos_.y,
       0.0f, 0.0f, 1.0f, -pos_.z,
       0.0f, 0.0f, 0.0f,    1.0f;

  Eigen::Matrix4f m = R * T;
  glMultMatrixf(m.data());
}
Пример #17
0
bool CameraPoseFinderICP::estimateCameraPose(const DepthFrameData& depth_frame,const ColorFrameData& color_frame)
{
	if(depth_frame.frameId()==0)
	{
		return true;
	}
	//prepare datas
	cudaDownSampleNewVertices();
	cudaDownSampleNewNormals();
	cudaDownSampleModelVertices();
	cudaDownSampleModelNormals();

	Mat44 cur_transform=_pose;
	Mat44 last_transform_inv=_pose.getInverse();
	Eigen::Matrix<float, 6, 1, 0, 6, 1> delta_dof;
	for(int l=_iter_nums.size()-1;l>=0;l--)
	{
		int it_nums=_iter_nums[l];
		while(it_nums--)
		{
		//	findCorresSet(l,cur_transform,last_transform_inv);
			if(false==minimizePointToPlaneErrFunc(l,delta_dof,cur_transform,last_transform_inv)) return false;
			Eigen::Matrix4f t = Eigen::Matrix4f::Identity();
			if (false==vector6ToTransformMatrix(delta_dof,  t) )
			{
				cout<<"camera shaking detected"<<endl;
				return false;
			}
			//eigen matrix to mat44
			Eigen::Matrix4f tt = t.transpose();
			Mat44 mat_t(tt.data());
			cur_transform = mat_t*cur_transform;
		}
	}
	_pose=cur_transform;
	return true;
}
Пример #18
0
Eigen::Matrix4f
perspectiveMatrix(
	GLfloat left,	GLfloat right,
	GLfloat top,	GLfloat bottom,
	GLfloat nearz,	GLfloat farz
) {
	GLfloat const A =  (right + left)    / (right - left);
	GLfloat const B =  (top + bottom)    / (top - bottom);
	GLfloat const C = -(farz + nearz)    / (farz - nearz);
	GLfloat const D = -(2.0f*farz*nearz) / (farz - nearz);

	GLfloat const matrix[] = {
		2.0f * nearz / (right - left),	0.0f,							A,		0.0f,	
		0.0f,							2.0f * nearz / (top - bottom),	B,		0.0f,	
		0.0f,							0.0f,							C,		D,
		0.0f,							0.0f,							-1.0f,	0.0f,
	};

	Eigen::Matrix4f result;
	::memcpy(result.data(), matrix, sizeof(matrix));
	result.matrix().transposeInPlace();

	return result;
}
Пример #19
0
//------------------------------------------------------------------------------
int main(int argc, char** argv) {
//GRAPHICS SETUP
    glfwSetErrorCallback(error_callback);

    if(!glfwInit()) {
        std::cerr << "ERROR - glfwInit" << std::endl;
        exit(EXIT_FAILURE);
    }

    GLFWwindow* window = glfwCreateWindow(800, 600,
                                          "Ray 1!", NULL, NULL);
    if (!window) {
        std::cerr << "ERROR - glfwCreateWindow" << std::endl;
        glfwTerminate();
        exit(EXIT_FAILURE);
    }


    glfwSetKeyCallback(window, key_callback);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    glfwMakeContextCurrent(window);

    gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);

    std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
    std::cout << "GLSL version: "
              << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
    std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
    std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;


//GEOMETRY
    //geometry: textured quad
    float quad[] = {-1.0f,  1.0f, 0.0f, 1.0f,
                    -1.0f, -1.0f, 0.0f, 1.0f,
                     1.0f, -1.0f, 0.0f, 1.0f,
                     1.0f, -1.0f, 0.0f, 1.0f,
                     1.0f,  1.0f, 0.0f, 1.0f,
                    -1.0f,  1.0f, 0.0f, 1.0f};

    float  texcoord[] = {0.0f, 1.0f,
                         0.0f, 0.0f,
                         1.0f, 0.0f,
                         1.0f, 0.0f,
                         1.0f, 1.0f,
                         0.0f, 1.0f};
    //OpenGL >= 3.3 core requires a vertex array object containing multiple attribute
    //buffers
    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    //geometry buffer
    GLuint quadvbo;
    glGenBuffers(1, &quadvbo);
    glBindBuffer(GL_ARRAY_BUFFER, quadvbo);
    glBufferData(GL_ARRAY_BUFFER, 6 * 4 * sizeof(float),
                 &quad[0], GL_STATIC_DRAW);
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);

    glBindBuffer(GL_ARRAY_BUFFER, 0);

    //texture coordinate buffer
    GLuint texbo;
    glGenBuffers(1, &texbo);

    glBindBuffer(GL_ARRAY_BUFFER, texbo);
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float),
                 &texcoord[0], GL_STATIC_DRAW);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glBindVertexArray(0);

//OPENGL RENDERING SHADERS

    GLuint glprogram = create_program(vertexShaderSrc, fragmentShaderSrc);

    //enable gl program
    glUseProgram(glprogram);

    //extract ids of shader variables
    GLint mvpID = glGetUniformLocation(glprogram, "MVP");
    assert(mvpID>=0);

    GLint textureID = glGetUniformLocation(glprogram, "cltexture");
    assert(textureID>=0);

    //beckground color
    glClearColor(0.0f, 0.0f, 0.4f, 1.0f);

    g_Backbuffer = std::make_shared<Backbuffer>();
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
    framebuffer_size_callback(window, width, height);

//RENDER LOOP
    //rendering & simulation loop
    while (!glfwWindowShouldClose(window)) {
        // Clear the screen
        glClear(GL_COLOR_BUFFER_BIT);

        //setup OpenGL matrices
        const Eigen::Matrix4f modelView = Eigen::Matrix4f::Identity();
        const Eigen::Matrix4f MVP        = g_Backbuffer->m_Projection * modelView;

        glUniformMatrix4fv(mvpID, 1, GL_FALSE, MVP.data());

        //only need texture unit 0
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, g_Backbuffer->m_Texture);
        glUniform1i(textureID, 0);

        //select geometry to render
        glBindVertexArray(vao);
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
        //draw
        glDrawArrays(GL_TRIANGLES, 0, 6);
        //unbind
        glBindVertexArray(0);
        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);
        glBindTexture(GL_TEXTURE_2D, 0);
        //put pixels on screen
        glfwSwapBuffers(window);
        //query events
        glfwPollEvents();
    }

//CLEANUP
    glDeleteBuffers(1, &quadvbo);
    glDeleteBuffers(1, &texbo);
    glDeleteVertexArrays(1, &vao);

    g_Backbuffer.reset();

    glfwDestroyWindow(window);
    glfwTerminate();
    exit(EXIT_SUCCESS);
    return 0;
}
Пример #20
0
void Scene::DrawScene(ParticleSystem* m, double strainSize, bool drawPoints) {
  int pSize;
  int cSize;
  //float* points = m->GetPositions3d(&pSize);
  //float* colors = m->GetColors(&cSize, strainSize);

  float *points, *colors;
  switch(drawMode) {
    case 0:
      points = m->GetSurfaceTriangles3d(&pSize);
      colors = m->GetTriColors(&cSize, strainSize);
      break;
    case 1:
      points = m->GetPositions3d(&pSize, prevMode);
      colors = m->GetColors(&cSize, strainSize, xpos, ypos, zpos);
      break;
    case 2:
      points = m->GetSurfaceTriangles3d(&pSize);
      colors = m->GetStrainSurfaceTriColors(&cSize, strainSize);
      break;
    case 3:
      points = m->GetTetCenter(&pSize);
      colors = m->GetCenterColors(&cSize, strainSize);
      break;
    case 4:
      points = m->GetAllTriangles3d(&pSize);
      colors = m->GetStrainAllTriColors(&cSize, strainSize);
      break;
  }

  Eigen::Matrix4f rotationMatrix;
  Eigen::Matrix4f projectionMatrix;
  rotationMatrix.setZero();
  projectionMatrix.setZero();
  Eigen::Vector3f pos, target, up;
  pos << xpos, ypos, zpos;
  m->GetCameraPosAndSize(&xtarg, &ytarg, &ztarg);
  target << xtarg, ytarg, ztarg;
  up << 0, -1, 0;
  RotationMatrix(pos, target, up, rotationMatrix);
  PerspectiveMatrix((65*PI)/180.0, ((float)DDWIDTH)/DDHEIGHT, .5, 100, projectionMatrix);
  g_viewMatrix = projectionMatrix * rotationMatrix;


  DrawDelegate::BeginFrame();
  DrawDelegate::SetViewMatrix(g_viewMatrix.data());
  Scene::DrawGrid(1, m->groundLevel);
  if (drawPoints) {
     DrawDelegate::SetLineSize(3);

     switch(drawMode) {
       case 0:
         DrawDelegate::DrawTriangles(points, pSize, colors, cSize);
         break;
       case 1:
         DrawDelegate::DrawLines(points, pSize, colors, cSize);
         break;
       case 2:
         DrawDelegate::DrawTriangles(points, pSize, colors, cSize);
         break;
       case 3:
         DrawDelegate::DrawPoints(points, pSize, colors, cSize);
         break;
       case 4:
         DrawDelegate::DrawTriangles(points, pSize, colors, cSize);
         break;
     }
  }
}
Пример #21
0
glm::mat4 eigen_matrix4f_to_glm_mat4(const Eigen::Matrix4f &m)
{
    return glm::make_mat4x4((const float *)m.data());
}
Пример #22
0
int main() {
  if (!glfwInit()) return -1;
  
  GLFWwindow* window = glfwCreateWindow(Width, Height,
                                        "08 Matrix",
                                        nullptr, nullptr);
  
  if (!window) {
    glfwTerminate();
    return -1;
  }
  
  glfwMakeContextCurrent(window);
  
  // Windowのサイズが変更された際に呼ばれる関数を設定
  glfwSetWindowSizeCallback(window, resize);
  
  glfwSwapInterval(1);
  
  float angle = 0.0f;
  
  while (!glfwWindowShouldClose(window)) {
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    
    view();
    
    glTranslatef(0.0f, 0.0f, -1.5f);
    // 回転行列を適用
    // angle: 回転量(単位:degrees)  一周360c
    // x, y, z: 回転軸を表すベクトル(単位ベクトルでなくてよい)
    glRotatef(angle, 0.0f, 1.0f, 0.0f);
    //angle += 1.0f;
    
    drawCircle(Vec2f(0, 0), 5, 0.4, Color(1, 1, 1));
    
    view();
    
    
    static Eigen::Vector3f camera_pos(0, 0, 2.0);
    static Eigen::Vector3f target_pos(0, 0, 0);
    static Eigen::Vector3f camera_up(0, 1, 0);
    
    Eigen::Matrix4f cm = lookAt(camera_pos, target_pos, camera_up);
    glMultMatrixf(cm.data());
    
    static Eigen::Vector3f camera_rotate(0, 0, 0);
    
    //camera_rotate.x() += 0.1f;
    camera_rotate.y() += 0.1f;
    
    glRotatef(-camera_rotate.x(), 1.0f, 0.0f, 0.0f);
    glRotatef(-camera_rotate.y(), 0.0f, 1.0f, 0.0f);
    glRotatef(-camera_rotate.z(), 0.0f, 0.0f, 1.0f);
    
    glTranslatef(-camera_pos.x(), -camera_pos.y(), -camera_pos.z());
    
    drawCircle(Vec2f(0, 0), 5, 0.2, Color(0, 0, 1));
    
    glfwSwapBuffers(window);
    
    glfwPollEvents();
  }
  
  glfwTerminate();
  
  return 0;
}
Пример #23
0
void OpenGLRenderer::SetProjectionMatrix(const Eigen::Matrix4f& m) {
  glMatrixMode(GL_PROJECTION);
  glLoadMatrixf(m.data());
}
Пример #24
0
Matrix4 Helper::convertFromEigenMatrix(const Eigen::Matrix4f &M)
{
    Matrix4 mat = *(Matrix4 *)M.data();
    return mat;
}
Пример #25
0
void glsl_program::set_uniform(unsigned loc, const Eigen::Matrix4f& value) const
{
    if (used_program != this)
	throw runtime_error("glsl_program::set_uniform, program not bound!");
    glUniformMatrix4fv(loc, 1, false, value.data());
}
Пример #26
0
int volumetric_knt_cuda(int argc, char **argv)
{
	Timer timer;
	int vol_size = vx_count * vx_size;
	float half_vol_size = vol_size * 0.5f;

	Eigen::Vector3i voxel_size(vx_size, vx_size, vx_size);
	Eigen::Vector3i volume_size(vol_size, vol_size, vol_size);
	Eigen::Vector3i voxel_count(vx_count, vx_count, vx_count);
	int total_voxels = voxel_count.x() * voxel_count.y() * voxel_count.z();


	std::cout << std::fixed
		<< "Voxel Count  : " << voxel_count.transpose() << std::endl
		<< "Voxel Size   : " << voxel_size.transpose() << std::endl
		<< "Volume Size  : " << volume_size.transpose() << std::endl
		<< "Total Voxels : " << total_voxels << std::endl
		<< std::endl;

	timer.start();
	KinectFrame knt(filepath);
	timer.print_interval("Importing knt frame : ");

	Eigen::Affine3f grid_affine = Eigen::Affine3f::Identity();
	grid_affine.translate(Eigen::Vector3f(0, 0, half_vol_size));
	grid_affine.scale(Eigen::Vector3f(1, 1, -1));	// z is negative inside of screen
	Eigen::Matrix4f grid_matrix = grid_affine.matrix();

	float knt_near_plane = 0.1f;
	float knt_far_plane = 10240.0f;
	Eigen::Matrix4f projection = perspective_matrix<float>(KINECT_V2_FOVY, KINECT_V2_DEPTH_ASPECT_RATIO, knt_near_plane, knt_far_plane);
	Eigen::Matrix4f projection_inverse = projection.inverse();
	Eigen::Matrix4f view_matrix = Eigen::Matrix4f::Identity();

	std::vector<float4> vertices(knt.depth.size(), make_float4(0, 0, 0, 1));
	std::vector<float4> normals(knt.depth.size(), make_float4(0, 0, 1, 1));
	std::vector<Eigen::Vector2f> grid_voxels_params(total_voxels);

	// 
	// setup image parameters
	//
	unsigned short image_width = 2;
	unsigned short image_height = 2;
	uchar4* image_data = new uchar4[image_width * image_height];
	memset(image_data, 0, image_width * image_height * sizeof(uchar4));
	float4* debug_buffer = new float4[image_width * image_height];
	memset(debug_buffer, 0, image_width * image_height * sizeof(float4));

	knt_cuda_setup(
		vx_count, vx_size, 
		grid_matrix.data(), 
		projection.data(), 
		projection_inverse.data(),
		*grid_voxels_params.data()->data(),
		KINECT_V2_DEPTH_WIDTH, 
		KINECT_V2_DEPTH_HEIGHT,
		KINECT_V2_DEPTH_MIN,
		KINECT_V2_DEPTH_MAX,
		vertices.data()[0],
		normals.data()[0],
		image_width,
		image_height,
		*image_data,
		*debug_buffer
		);

	timer.start();
	knt_cuda_allocate();
	knt_cuda_init_grid();
	timer.print_interval("Allocating gpu      : ");

	timer.start();
	knt_cuda_copy_host_to_device();
	knt_cuda_copy_depth_buffer_to_device(knt.depth.data());
	timer.print_interval("Copy host to device : ");

	timer.start();
	knt_cuda_normal_estimation();
	timer.print_interval("Normal estimation   : ");

	timer.start();
	knt_cuda_update_grid(view_matrix.data());
	timer.print_interval("Update grid         : ");
	
	timer.start();
	knt_cuda_grid_params_copy_device_to_host();
	knt_cuda_copy_device_to_host();
	timer.print_interval("Copy device to host : ");

	timer.start();
	knt_cuda_free();
	timer.print_interval("Cleanup gpu         : ");


	timer.start();
	Eigen::Affine3f grid_affine_2 = Eigen::Affine3f::Identity();
	grid_affine_2.translate(Eigen::Vector3f(-half_vol_size, -half_vol_size, -vol_size));
		
	export_volume(
		"../../data/grid_volume_gpu_knt.obj",
		voxel_count,
		voxel_size,
		grid_voxels_params);
		//grid_affine_2.matrix());

	export_obj_with_colors("../../data/knt_grid_frame_normals.obj", vertices, normals);

	timer.print_interval("Exporting volume    : ");

	return 0;
}
Пример #27
0
void AutoBlend::init()
{
    // Add widget
    auto toolsWidgetContainer = new QWidget();
    widget = new Ui::AutoBlendWidget();
    widget->setupUi(toolsWidgetContainer);
    widgetProxy = new QGraphicsProxyWidget(this);
    widgetProxy->setWidget(toolsWidgetContainer);

    // Place at bottom left corner
    auto delta = widgetProxy->sceneBoundingRect().bottomLeft() -
    scene()->views().front()->rect().bottomLeft();
    widgetProxy->moveBy(-delta.x(), -delta.y());

    // Fill categories box
    {
        for(auto cat : document->categories.keys()){
            widget->categoriesBox->insertItem(widget->categoriesBox->count(), cat);
        }

        int idx = widget->categoriesBox->findText(document->categoryOf(document->firstModelName()));
        widget->categoriesBox->setCurrentIndex(idx);
    }

    // Create gallery of shapes
    gallery = new Gallery(this, QRectF(0,0,this->bounds.width(), 220));

    // Create container that holds results
    results = new Gallery(this, QRectF(0,0, this->bounds.width(),
                          bounds.height() - gallery->boundingRect().height()),
                          QRectF(0,0,256,256), true);

    results->moveBy(0, gallery->boundingRect().height());

    // Gallery on top of results
    gallery->setZValue(results->zValue() + 10);

    auto dropShadow = new QGraphicsDropShadowEffect();
	dropShadow->setOffset(0, 5);
    dropShadow->setColor(QColor(0, 0, 0, 150));
	dropShadow->setBlurRadius(10);
	gallery->setGraphicsEffect(dropShadow);

	// Connect UI with actions
	{
		connect(widget->categoriesBox, &QComboBox::currentTextChanged, [&](QString text){
			document->currentCategory = text;
		});

        connect(widget->analyzeButton, &QPushButton::pressed, [&](){
            document->computePairwise(widget->categoriesBox->currentText());
		});

		// Default view angle
		{
			// Camera target and initial position
			auto camera = new Eigen::Camera();
			auto frame = camera->frame();
			frame.position = Eigen::Vector3f(-1, 0, 0.5);
			camera->setTarget(Eigen::Vector3f(0, 0, 0.5));
            camera->setFrame(frame);

            int deltaZoom = document->extent().length() * 1.0;

            // Default view angle
            double theta1 = acos(-1) * 0.75;
            double theta2 = acos(-1) * 0.10;
            camera->rotateAroundTarget(Eigen::Quaternionf(Eigen::AngleAxisf(theta1, Eigen::Vector3f::UnitY())));
            camera->zoom(-(4+deltaZoom));
            camera->rotateAroundTarget(Eigen::Quaternionf(Eigen::AngleAxisf(theta2, Eigen::Vector3f::UnitX())));
			auto cp = camera->position();
			cameraPos = QVector3D(cp[0], cp[1], cp[2]);

			// Camera settings
			camera->setViewport(128, 128);
			Eigen::Matrix4f p = camera->projectionMatrix();
			Eigen::Matrix4f v = camera->viewMatrix().matrix();
			p.transposeInPlace();
			v.transposeInPlace();
			cameraMatrix = QMatrix4x4(p.data()) * QMatrix4x4(v.data());
        }

		connect(document, &Document::categoryAnalysisDone, [=](){
			if (gallery == nullptr) return;

			// Fill gallery
			gallery->clearThumbnails();

			auto catModels = document->categories[document->currentCategory].toStringList();
			for (auto targetName : catModels)
			{
				auto targetModel = document->cacheModel(targetName);
				auto t = gallery->addTextItem(targetName);

				QVariantMap data = t->data;
				data["targetName"].setValue(targetName);
				t->setData(data);

				t->setCamera(cameraPos, cameraMatrix);
				t->setFlag(QGraphicsItem::ItemIsSelectable);

				// Add parts of target shape
				for (auto n : targetModel->nodes){
					t->addAuxMesh(toBasicMesh(targetModel->getMesh(n->id), n->vis_property["color"].value<QColor>()));
				}

                scene()->update(t->sceneBoundingRect());
            }

            scene()->update(this->sceneBoundingRect());
            QTimer::singleShot(500, [=]{ gallery->update(); });
		});

		// Do blend
		connect(widget->blendButton, SIGNAL(pressed()), SLOT(doBlend())); 
    }
}
Пример #28
0
void set_uniform_matrix(GLuint programID, const char* NAME, const Eigen::Matrix4f& matrix) {
    GLuint matrix_id = glGetUniformLocation(programID, NAME);
    glUniformMatrix4fv(matrix_id, 1, GL_FALSE, matrix.data());
}
Пример #29
0
void WarpPosShader::setMVPMatrix(const Eigen::Matrix4f &mvp)
{
    glUseProgram(mProgram.getId());
    glUniformMatrix4fv(mUniformMVPMatrix, 1, false, mvp.data());
}
Пример #30
0
void OpenGLRenderer::SetModelViewMatrix(const Eigen::Matrix4f& m) {
  glMatrixMode(GL_MODELVIEW);
  glLoadMatrixf(m.data());
}