Camera::Ptr AddCamera(kge::Scene& scene, const Rectf& viewport) { GameObject::Ptr gameObject = scene.CreateGameObject().lock(); Camera::Ptr camera = gameObject->AddComponent<Camera>().lock(); camera->SetPerspectiveLens(0.05f, 20.0f, Degreesf(90.0f)); camera->SetViewport(viewport, Rangef(0.0f, 1.0f)); return camera; }
void on_passive_motion(int x, int y) { if (paused_) return; double pitch = -(0.5-(double)y/window_height_)*M_PI; // in window coordinates positive y-axis is down double yaw = (0.5-(double)x/window_width_)*M_PI*2; camera_->set_pitch(pitch); camera_->set_yaw(yaw); }
void RayTracerController::start() { if (isRunning()) return; Camera::Ptr camera = m_rt.camera(); if (!camera) throw cxx::exception("There is no camera in the raytracer scene"); m_rt.setProgressCallback([camera, this](float progress, bool, quint64 raysProcessed) { QMutexLocker mtlk(&m_mutex); emit rayTracerImageUpdated(QPixmap::fromImage((*m_imageProcessor)(camera->canvas()).toImage())); emit rayTracerProgress(progress, raysProcessed); }); m_rtThread.start(); }
Camera::Ptr HouScene::loadCamera( QJsonObject &obj ) { Camera::Ptr camera = std::make_shared<Camera>(); math::V2i res(int(obj.value("resx").toDouble()), int(obj.value("resy").toDouble())); camera->setRaster( res.x, res.y, float(res.x)/float(res.y) ); math::M44f translation = math::M44f::TranslationMatrix(obj.value("transform.tx").toDouble(), obj.value("transform.ty").toDouble(), obj.value("transform.tz").toDouble()); math::M44f rotationX = math::M44f::RotationMatrixX( -math::degToRad(obj.value("transform.rx").toDouble()) ); math::M44f rotationY = math::M44f::RotationMatrixY( -math::degToRad(obj.value("transform.ry").toDouble()) ); math::M44f rotationZ = math::M44f::RotationMatrixZ( -math::degToRad(obj.value("transform.rz").toDouble()) ); camera->setViewToWorld( rotationX*rotationY*rotationZ*translation ); return camera; }
void initialize (int argc, char** argv) { const GLubyte* version = glGetString (GL_VERSION); print_info ("OpenGL Version: %s\n", version); // works well for MIT CSAIL model 2nd floor: camera_->set (27.4503, 37.383, 4.30908, 0.0, 0.0654498, -2.25802); if (argc > 1) loadPolygonMeshModel (argv[1]); }
void initialize (int argc, char** argv) { const GLubyte* version = glGetString (GL_VERSION); std::cout << "OpenGL Version: " << version << std::endl; // works for small files: camera_->set(-5.0, 0.0, 1.0, 0.0, 0.0, 0.0); pcl::console::print_info("About to read: %s", argv[2]); loadPolygonMeshModel (argv[2]); }
// Handle normal keys void on_keyboard (unsigned char key, int x, int y) { double speed = 0.1; if (key == 27) exit(0); else if (key == 'w' || key == 'W') camera_->move(speed,0,0); else if (key == 's' || key == 'S') camera_->move(-speed,0,0); else if (key == 'a' || key == 'A') camera_->move(0,speed,0); else if (key == 'd' || key == 'D') camera_->move(0,-speed,0); else if (key == 'q' || key == 'Q') camera_->move(0,0,speed); else if (key == 'z' || key == 'Z') camera_->move(0,0,-speed); else if (key == 'p' || key == 'P') paused_ = !paused_; else if (key == 'v' || key == 'V') write_file_ = 1; // Use glutGetModifiers for modifiers // GLUT_ACTIVE_SHIFT, GLUT_ACTIVE_CTRL, GLUT_ACTIVE_ALT }
void initialize (int argc, char** argv) { const GLubyte* version = glGetString (GL_VERSION); std::cout << "OpenGL Version: " << version << std::endl; // works well for MIT CSAIL model 3rd floor: //camera_->set(4.04454, 44.9377, 1.1, 0.0, 0.0, -2.00352); // works well for MIT CSAIL model 2nd floor: // camera_->set (27.4503, 37.383, 4.30908, 0.0, 0.0654498, -2.25802); // works for small files: //camera_->set(-5.0, 0.0, 1.0, 0.0, 0.0, 0.0); camera_->set( 1.31762, 0.382931, 1.89533, 0, 0.20944, -9.14989); camera_->setPitch(0.20944); // not sure why this is here: //camera_->set(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); cout << "About to read: " << argv[1] << endl; load_PolygonMesh_model (argv[1]); paused_ = false; }
void initialize(int argc, char** argv) { const GLubyte* version = glGetString(GL_VERSION); std::cout << "OpenGL Version: " << version << std::endl; // works well for MIT CSAIL model 3rd floor: // camera_->set(4.04454, 44.9377, 1.1, 0.0, 0.0, -2.00352); // works for small files: //camera_->set(-5.0, 0.0, 1.0, 0.0, 0.0, 0.0); camera_->set(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); cout << "About to read: " << argv[1] << endl; load_PolygonMesh_model(argv[1]); paused_ = false; }
void capture (Eigen::Isometry3d pose_in) { // No reference image - but this is kept for compatibility with range_test_v2: float* reference = new float[range_likelihood_->getRowHeight() * range_likelihood_->getColWidth()]; const float* depth_buffer = range_likelihood_->getDepthBuffer(); // Copy one image from our last as a reference. for (int i=0, n=0; i<range_likelihood_->getRowHeight(); ++i) { for (int j=0; j<range_likelihood_->getColWidth(); ++j) { reference[n++] = depth_buffer[i*range_likelihood_->getWidth() + j]; } } std::vector<Eigen::Isometry3d, Eigen::aligned_allocator<Eigen::Isometry3d> > poses; std::vector<float> scores; poses.push_back (pose_in); range_likelihood_->computeLikelihoods (reference, poses, scores); std::cout << "score: "; for (size_t i = 0; i<scores.size (); ++i) { std::cout << " " << scores[i]; } std::cout << std::endl; std::cout << "camera: " << camera_->getX () << " " << camera_->getY () << " " << camera_->getZ () << " " << camera_->getRoll () << " " << camera_->getPitch () << " " << camera_->getYaw () << std::endl; delete [] reference; // Benchmark Values for // 27840 triangle faces // 13670 vertices // 45.00Hz: simuation only // 1.28Hz: simuation, addNoise? , getPointCloud, writeASCII // 33.33Hz: simuation, getPointCloud // 23.81Hz: simuation, getPointCloud, writeBinary // 14.28Hz: simuation, addNoise, getPointCloud, writeBinary // MODULE TIME FRACTION // simuation 0.02222 31% // addNoise 0.03 41% // getPointCloud 0.008 11% // writeBinary 0.012 16% // total 0.07222 pcl::PointCloud<pcl::PointXYZRGB>::Ptr pc_out (new pcl::PointCloud<pcl::PointXYZRGB>); }
void initialize(int argc, char** argv) { const GLubyte* version = glGetString(GL_VERSION); std::cout << "OpenGL Version: " << version << std::endl; // camera_->set(-5.0, 0.0, 1.0, 0.0, 0.0, 0.0); camera_->set(4.04454, 44.9377, 1.1, 0.0, 0.0, -2.00352); std::vector<std::string> files; for (int i=1; i<argc; ++i) files.push_back(argv[i]); //load_rwx_models(files); load_model(files); int i; for (i=0; i<2048; i++) { float v = i/2048.0; v = powf(v, 3)* 6; t_gamma[i] = v*6*256; } paused_ = false; }
void capture (Eigen::Isometry3d pose_in, string point_cloud_fname) { // No reference image - but this is kept for compatability with range_test_v2: float* reference = new float[range_likelihood_->getRowHeight() * range_likelihood_->getColWidth()]; const float* depth_buffer = range_likelihood_->getDepthBuffer(); // Copy one image from our last as a reference. for (int i=0, n=0; i<range_likelihood_->getRowHeight(); ++i) { for (int j=0; j<range_likelihood_->getColWidth(); ++j) { reference[n++] = depth_buffer[i*range_likelihood_->getWidth() + j]; } } std::vector<Eigen::Isometry3d, Eigen::aligned_allocator<Eigen::Isometry3d> > poses; std::vector<float> scores; poses.push_back (pose_in); range_likelihood_->computeLikelihoods (reference, poses, scores); std::cout << "score: "; for (size_t i = 0; i<scores.size (); ++i) { std::cout << " " << scores[i]; } std::cout << std::endl; std::cout << "camera: " << camera_->getX () << " " << camera_->getY () << " " << camera_->getZ () << " " << camera_->getRoll () << " " << camera_->getPitch () << " " << camera_->getYaw () << std::endl; delete [] reference; // Benchmark Values for // 27840 triangle faces // 13670 vertices // 45.00Hz: simuation only // 1.28Hz: simuation, addNoise? , getPointCloud, writeASCII // 33.33Hz: simuation, getPointCloud // 23.81Hz: simuation, getPointCloud, writeBinary // 14.28Hz: simuation, addNoise, getPointCloud, writeBinary // MODULE TIME FRACTION // simuation 0.02222 31% // addNoise 0.03 41% // getPointCloud 0.008 11% // writeBinary 0.012 16% // total 0.07222 pcl::PointCloud<pcl::PointXYZRGB>::Ptr pc_out (new pcl::PointCloud<pcl::PointXYZRGB>); bool write_cloud = true; if (write_cloud) { // Read Color Buffer from the GPU before creating PointCloud: // By default the buffers are not read back from the GPU range_likelihood_->getColorBuffer (); range_likelihood_->getDepthBuffer (); // Add noise directly to the CPU depth buffer range_likelihood_->addNoise (); // Optional argument to save point cloud in global frame: // Save camera relative: //range_likelihood_->getPointCloud(pc_out); // Save in global frame - applying the camera frame: //range_likelihood_->getPointCloud(pc_out,true,camera_->pose()); // Save in local frame range_likelihood_->getPointCloud (pc_out,false,camera_->getPose ()); // TODO: what to do when there are more than one simulated view? std::cout << pc_out->points.size() << " points written to file\n"; pcl::PCDWriter writer; //writer.write (point_cloud_fname, *pc_out, false); /// ASCII writer.writeBinary (point_cloud_fname, *pc_out); //cout << "finished writing file\n"; } // Disabled all OpenCV stuff for now: dont want the dependency /* bool demo_other_stuff = false; if (demo_other_stuff && write_cloud) { write_score_image (range_likelihood_->getScoreBuffer ()); write_rgb_image (range_likelihood_->getColorBuffer ()); write_depth_image (range_likelihood_->getDepthBuffer ()); // Demo interacton with RangeImage: pcl::RangeImagePlanar rangeImage; range_likelihood_->getRangeImagePlanar (rangeImage); // display viewer: (currently seqfaults on exit of viewer) if (1==0){ boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer; viewer = simpleVis(pc_out); while (!viewer->wasStopped ()){ viewer->spinOnce (100); boost::this_thread::sleep (boost::posix_time::microseconds (100000)); } } } */ }
void display () { float* reference = new float[range_likelihood_->getRowHeight () * range_likelihood_->getColWidth ()]; const float* depth_buffer = range_likelihood_->getDepthBuffer (); // Copy one image from our last as a reference. for (int i = 0, n = 0; i < range_likelihood_->getRowHeight (); ++i) { for (int j = 0; j < range_likelihood_->getColWidth (); ++j) { reference[n++] = depth_buffer[ (i + range_likelihood_->getRowHeight () * range_likelihood_->getRows () / 2) * range_likelihood_->getWidth () + j + range_likelihood_->getColWidth () * range_likelihood_->getCols () / 2]; } } float* reference_vis = new float[range_likelihood_visualization_->getRowHeight () * range_likelihood_visualization_->getColWidth ()]; const float* depth_buffer_vis = range_likelihood_visualization_->getDepthBuffer (); // Copy one image from our last as a reference. for (int i = 0, n = 0; i < range_likelihood_visualization_->getRowHeight (); ++i) { for (int j = 0; j < range_likelihood_visualization_->getColWidth (); ++j) { reference_vis[n++] = depth_buffer_vis[i*range_likelihood_visualization_->getWidth () + j]; } } std::vector<Eigen::Isometry3d, Eigen::aligned_allocator<Eigen::Isometry3d> > poses; std::vector<float> scores; // Render a single pose for visualization poses.clear (); poses.push_back (camera_->getPose ()); range_likelihood_visualization_->computeLikelihoods (reference_vis, poses, scores); glDrawBuffer (GL_BACK); glReadBuffer (GL_BACK); // Draw the resulting images from the range_likelihood glViewport (range_likelihood_visualization_->getWidth (), 0, range_likelihood_visualization_->getWidth (), range_likelihood_visualization_->getHeight ()); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); // Draw the color image glColorMask (true, true, true, true); glClearColor (0, 0, 0, 0); glClearDepth (1); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glDisable (GL_DEPTH_TEST); glRasterPos2i (-1,-1); glDrawPixels (range_likelihood_visualization_->getWidth (), range_likelihood_visualization_->getHeight (), GL_RGB, GL_UNSIGNED_BYTE, range_likelihood_visualization_->getColorBuffer ()); // Draw the depth image glViewport (0, 0, range_likelihood_visualization_->getWidth (), range_likelihood_visualization_->getHeight ()); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); display_depth_image (range_likelihood_visualization_->getDepthBuffer (), range_likelihood_visualization_->getWidth (), range_likelihood_visualization_->getHeight ()); poses.clear (); for (int i = 0; i < range_likelihood_->getRows (); ++i) { for (int j = 0; j < range_likelihood_->getCols (); ++j) { Camera camera (*camera_); camera.move ((j - range_likelihood_->getCols () / 2.0) * 0.1, (i - range_likelihood_->getRows () / 2.0) * 0.1, 0.0); poses.push_back (camera.getPose ()); } } std::cout << std::endl; TicToc tt; tt.tic(); range_likelihood_->computeLikelihoods (reference, poses, scores); tt.toc(); tt.toc_print(); if (gllib::getGLError () != GL_NO_ERROR) { std::cerr << "GL Error: RangeLikelihood::computeLikelihoods: finished" << std::endl; } #if 0 std::cout << "score: "; for (size_t i = 0; i < scores.size (); ++i) { std::cout << " " << scores[i]; } std::cout << std::endl; #endif std::cout << "camera: " << camera_->getX () << " " << camera_->getY () << " " << camera_->getZ () << " " << camera_->getRoll () << " " << camera_->getPitch () << " " << camera_->getYaw () << std::endl; delete [] reference_vis; delete [] reference; if (gllib::getGLError () != GL_NO_ERROR) { std::cerr << "GL Error: before buffers" << std::endl; } glBindFramebuffer (GL_FRAMEBUFFER, 0); glDrawBuffer (GL_BACK); glReadBuffer (GL_BACK); if (gllib::getGLError () != GL_NO_ERROR) { std::cerr << "GL Error: after buffers" << std::endl; } glMatrixMode (GL_PROJECTION); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); if (gllib::getGLError () != GL_NO_ERROR) { std::cerr << "GL Error: before viewport" << std::endl; } // Draw the score image for the particles glViewport (0, range_likelihood_visualization_->getHeight (), range_likelihood_visualization_->getWidth (), range_likelihood_visualization_->getHeight ()); if (gllib::getGLError () != GL_NO_ERROR) { std::cerr << "GL Error: after viewport" << std::endl; } display_score_image (range_likelihood_->getScoreBuffer ()); // Draw the depth image for the particles glViewport (range_likelihood_visualization_->getWidth (), range_likelihood_visualization_->getHeight (), range_likelihood_visualization_->getWidth (), range_likelihood_visualization_->getHeight ()); display_score_image (range_likelihood_->getDepthBuffer ()); glutSwapBuffers (); }
void display () { float* reference = new float[range_likelihood_->getRowHeight() * range_likelihood_->getColWidth()]; const float* depth_buffer = range_likelihood_->getDepthBuffer(); // Copy one image from our last as a reference. for (int i=0, n=0; i<range_likelihood_->getRowHeight(); ++i) { for (int j=0; j<range_likelihood_->getColWidth(); ++j) { reference[n++] = depth_buffer[i*range_likelihood_->getWidth() + j]; } } std::vector<Eigen::Isometry3d, Eigen::aligned_allocator<Eigen::Isometry3d> > poses; std::vector<float> scores; int n = range_likelihood_->getRows ()*range_likelihood_->getCols (); for (int i = 0; i < n; ++i) { Camera camera(*camera_); camera.move(0.0,i*0.02,0.0); //camera.move(0.0,i*0.02,0.0); poses.push_back (camera.getPose ()); } range_likelihood_->computeLikelihoods (reference, poses, scores); range_likelihood_->computeLikelihoods (reference, poses, scores); std::cout << "score: "; for (size_t i = 0; i<scores.size (); ++i) { std::cout << " " << scores[i]; } std::cout << std::endl; std::cout << "camera: " << camera_->getX () << " " << camera_->getY () << " " << camera_->getZ () << " " << camera_->getRoll () << " " << camera_->getPitch () << " " << camera_->getYaw () << std::endl; delete [] reference; glDrawBuffer (GL_BACK); glReadBuffer (GL_BACK); // Draw the resulting images from the range_likelihood glViewport (range_likelihood_->getWidth (), 0, range_likelihood_->getWidth (), range_likelihood_->getHeight ()); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); // Draw the color image glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColorMask (true, true, true, true); glDisable (GL_DEPTH_TEST); glRasterPos2i (-1,-1); glDrawPixels (range_likelihood_->getWidth (), range_likelihood_->getHeight (), GL_RGB, GL_UNSIGNED_BYTE, range_likelihood_->getColorBuffer ()); // Draw the depth image glViewport (0, 0, range_likelihood_->getWidth (), range_likelihood_->getHeight ()); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); // display_depth_image (range_likelihood_->getDepthBuffer ()); display_depth_image (range_likelihood_->getDepthBuffer (), range_likelihood_->getWidth (), range_likelihood_->getHeight ()); // Draw the score image glViewport (0, range_likelihood_->getHeight (), range_likelihood_->getWidth (), range_likelihood_->getHeight ()); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); display_score_image (range_likelihood_->getScoreBuffer ()); glutSwapBuffers (); if (write_file_) { range_likelihood_->addNoise (); pcl::RangeImagePlanar rangeImage; range_likelihood_->getRangeImagePlanar (rangeImage); pcl::PointCloud<pcl::PointXYZRGB>::Ptr pc_out (new pcl::PointCloud<pcl::PointXYZRGB>); // Optional argument to save point cloud in global frame: // Save camera relative: //range_likelihood_->getPointCloud(pc_out); // Save in global frame - applying the camera frame: //range_likelihood_->getPointCloud(pc_out,true,camera_->pose()); // Save in local frame range_likelihood_->getPointCloud (pc_out,false,camera_->getPose ()); // TODO: what to do when there are more than one simulated view? pcl::PCDWriter writer; writer.write ("simulated_range_image.pcd", *pc_out, false); cout << "finished writing file\n"; // pcl::visualization::CloudViewer viewer ("Simple Cloud Viewer"); // viewer.showCloud (pc_out); boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer; viewer = simpleVis(pc_out); while (!viewer->wasStopped ()) { viewer->spinOnce (100); boost::this_thread::sleep (boost::posix_time::microseconds (100000)); } // doesnt work: // viewer->~PCLVisualizer(); // viewer.reset(); cout << "done\n"; // Problem: vtk and opengl dont seem to play very well together // vtk seems to misbehave after a little while and wont keep the window on the screen // method1: kill with [x] - but eventually it crashes: //while (!viewer.wasStopped ()){ //} // method2: eventually starts ignoring cin and pops up on screen and closes almost // immediately // cout << "enter 1 to cont\n"; // cin >> pause; // viewer.wasStopped (); // method 3: if you interact with the window with keys, the window is not closed properly // TODO: use pcl methods as this time stuff is probably not cross playform // struct timespec t; // t.tv_sec = 100; // //t.tv_nsec = (time_t)(20000000); // short sleep // t.tv_nsec = (time_t)(0); // long sleep - normal speed // nanosleep (&t, NULL); write_file_ = 0; } }
int main(int argc, char* argv[]) { Game game(Graphics::DirectX11, Vector2i(1920, 1080), 60.0f); Auto<Graphics> graphics = game.GetGraphics(); Auto<ResourceManager> resourceManager = game.GetResourceManager(); Auto<WindowRenderTarget> windowRenderTarget = game.GetWindowRenderTarget(); Auto<VertexShader> vertexShader; Auto<PixelShader> pixelShader; Auto<Mesh> meshTest; Auto<Sampler> linearSampler; Auto<Sampler> pointSampler; kge::Scene::Ptr scene = game.CreateScene(); GameObject::Ptr conrellBox = AddObject(scene, "Media/Meshes/CornellBox.obj#Cube", "Media/Materials/CornellBox.json"); conrellBox->GetTransform()->SetLocalOrientation(Quaternionf(Vector3f(0.0f, 1.0f, 0.0f), Degreesf(180.0f))); GameObject::Ptr suzanne = scene->CreateGameObject().lock(); suzanne->GetTransform()->SetLocalOrientation(Quaternionf(Vector3f(0.0f, 1.0f, 0.0f), Degreesf(225.0f))); suzanne->GetTransform()->SetLocalScale(Vector3f(0.6f, 0.6f, 0.6f)); suzanne->GetTransform()->SetLocalPosition(Vector3f(0.0f, -1.0f, 0.0f)); suzanne->AddComponent<SpinBehavior>(); game.GetLuaContext().AddBehaviorScript(resourceManager->LoadResource<LuaScript>("Media/Scripts/Test.lua")); game.GetLuaContext().AddBehaviorScript(resourceManager->LoadResource<LuaScript>("Media/Scripts/BaseTest.lua")); //suzanne->AddComponent<LuaBehavior>().lock()->SetLuaClassName("Test"); Renderer::Ref renderer = suzanne->AddComponent<Renderer>(); scene->GetRenderManager().SetCompositor( RenderManager::DefaultCompositor, Auto<Compositor>(new DeferredCompositor(*graphics, *resourceManager)) ); Camera::Ptr leftEye = AddCamera(*scene, Rectf(0.0f, 0.0f, 1.0f, 1.0f)); //Camera::Ptr rightEye = AddCamera(*scene, Rectf(0.0f, 0.5f, 1.0f, 0.5f)); GameObject::Ptr cameraObject = scene->CreateGameObject().lock(); cameraObject->AddComponent<FlyCamera>(); leftEye->GetGameObject().GetTransform()->SetParent(cameraObject->GetTransform()); leftEye->GetGameObject().GetTransform()->SetLocalPosition(Vector3f(-0.025f, 0.0f, 0.0f)); //rightEye->GetGameObject().GetTransform()->SetParent(cameraObject->GetTransform()); //rightEye->GetGameObject().GetTransform()->SetLocalPosition(Vector3f(0.025f, 0.0f, 0.0f)); GameObject::Ptr cubeTest = AddObject(scene, "Media/Meshes/Cube.obj#Cube", "Media/Materials/Cube.json"); cubeTest->GetTransform()->SetLocalScale(Vector3f(0.1f, 0.1f, 0.1f)); cubeTest->GetTransform()->SetLocalPosition(Vector3f(0.0f, -0.5f, -0.8f)); SpinBehavior::Ptr cubeSpin = cubeTest->AddComponent<SpinBehavior>().lock(); cubeSpin->SetAxis(Vector3f(1.0f, 0.0f, 0.0f)); cubeSpin = cubeTest->AddComponent<SpinBehavior>().lock(); cubeSpin->SetAxis(Vector3f(0.0f, 1.0f, 0.0f)); cubeSpin->SetRotationRate(Degreesf(7.0f)); { GameObject::Ptr lightObject = scene->CreateGameObject().lock(); lightObject->GetTransform()->SetLocalPosition(Vector3f(0.0f, 0.9f, 0.0f)); PointLight::Ptr pointLight = lightObject->AddComponent<PointLight>().lock(); pointLight->SetRange(4.0f); pointLight->SetColor(Colorf(1.0f, 1.0f, 1.0f)); } for (int i = 1; i <= 5; ++i) { for (int j = 0; j < 5; ++j) { AddEmmisiveSphere(scene, Vector3f(0.4f * i - 1.2f, -0.9f, -0.8f + j * 0.4f), Colorf(0.3f, 0.5f + i * 0.3f, 2.0f - j * 0.3f)); } } try { vertexShader = resourceManager->LoadResource<VertexShader>("Media/Shaders/Bundle/VertexShaderTest.shader"); pixelShader = resourceManager->LoadResource<PixelShader>("Media/Shaders/Bundle/PixelShaderTest.shader"); meshTest = resourceManager->LoadResource<Mesh>("Media/Meshes/Suzanne.obj#Suzanne"); SamplerDescription samplerDesc; linearSampler = graphics->CreateSampler(samplerDesc); samplerDesc.minFilter = InterpolationMode::Point; samplerDesc.magFilter = InterpolationMode::Point; samplerDesc.mipFilter = InterpolationMode::Point; pointSampler = graphics->CreateSampler(samplerDesc); Material::Ptr suzanneMaterial = resourceManager->LoadResource<Material>("Media/Materials/Suzanne.json"); Renderer::Ptr rendererPtr = renderer.lock(); rendererPtr->SetMesh(meshTest); rendererPtr->SetMaterial(suzanneMaterial, 0); RenderTargetConfiguration renderTarget; renderTarget.AddRenderTarget(windowRenderTarget); leftEye->SetRenderTargets(renderTarget); //rightEye->SetRenderTargets(renderTarget); cameraObject->GetTransform()->SetLocalPosition(Vector3f(0.0f, 0.0f, -2.0f)); } catch (Exception& exception) { const char* what = exception.what(); std::cerr << what; exit(1); } graphics->SetSampler(pointSampler, 0, ShaderStage::PixelShader); graphics->SetSampler(linearSampler, 1, ShaderStage::PixelShader); game.SetCurrentScene(scene); /* std::ofstream sceneOutput("TestScene.json", std::ios_base::binary); kge::ComponentFactory factory; kge::SceneJsonSerializer serializer(factory, sceneOutput); serializer.SerializeScene(*scene); sceneOutput.close(); std::ostringstream objectStream(std::ios_base::binary); kge::SceneJsonSerializer objectSerialize(factory, objectStream); objectSerialize.SerializePrefab(*suzanne); std::string objectJson = objectStream.str(); std::istringstream inputStream(objectJson, std::ios_base::binary); kge::SceneJsonDeserializer objectDeserialize(factory, *game.GetResourceManager(), inputStream); objectDeserialize.DeserializePrefab(*scene); */ suzanne.reset(); game.MainLoop(); return 0; }
void execute (int argc, char** argv, std::string plyfile) { PtrStepSz<const unsigned short> depth; PtrStepSz<const KinfuTracker::PixelRGB> rgb24; int time_ms = 0; bool has_image = false; // Create simulation environment: int width = 640; int height = 480; for (int i=0; i<2048; i++) { float v = i/2048.0; v = powf(v, 3)* 6; t_gamma[i] = v*6*256; } glutInit (&argc, argv); glutInitDisplayMode (GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB);// was GLUT_RGBA glutInitWindowPosition (10, 10); glutInitWindowSize (10, 10); //glutInitWindowSize (window_width_, window_height_); glutCreateWindow ("OpenGL range likelihood"); GLenum err = glewInit (); if (GLEW_OK != err) { std::cerr << "Error: " << glewGetErrorString (err) << std::endl; exit (-1); } std::cout << "Status: Using GLEW " << glewGetString (GLEW_VERSION) << std::endl; if (glewIsSupported ("GL_VERSION_2_0")) std::cout << "OpenGL 2.0 supported" << std::endl; else { std::cerr << "Error: OpenGL 2.0 not supported" << std::endl; exit(1); } std::cout << "GL_MAX_VIEWPORTS: " << GL_MAX_VIEWPORTS << std::endl; camera_ = Camera::Ptr (new Camera ()); scene_ = Scene::Ptr (new Scene ()); range_likelihood_ = RangeLikelihood::Ptr (new RangeLikelihood (1, 1, height, width, scene_)); // Actually corresponds to default parameters: range_likelihood_->setCameraIntrinsicsParameters (640,480, 576.09757860, 576.09757860, 321.06398107, 242.97676897); range_likelihood_->setComputeOnCPU (false); range_likelihood_->setSumOnCPU (true); range_likelihood_->setUseColor (true); camera_->set(0.471703, 1.59862, 3.10937, 0, 0.418879, -12.2129); camera_->set_pitch(0.418879); // not sure why this is here: cout << "About to read: "<< plyfile << endl; load_PolygonMesh_model (plyfile); // Generate a series of poses: std::vector<Eigen::Isometry3d, Eigen::aligned_allocator<Eigen::Isometry3d> > poses; Eigen::Vector3d focus_center(0,0,1.3); // double halo_r = 4.0; double halo_r = 1.5; double halo_dz = 1.5; // was 2; // 20 is too quick when adding noise: // 50 is ok though int n_poses=50; int n_pose_stop = 10; // above means make a circle of 50 poses, stop after the 10th i.e. 1/5 of a halo ring: generate_halo(poses,focus_center,halo_r,halo_dz,n_poses); unsigned short * disparity_buf_ = new unsigned short[width*height ]; const KinfuTracker::PixelRGB* color_buf_; const uint8_t* color_buf_uint; // loop though and create the mesh: for (int i = 0; !exit_; ++i) { vector<double> tic_toc; tic_toc.push_back(getTime()); double tic_main = getTime(); Eigen::Vector3d t(poses[i].translation()); Eigen::Quaterniond r(poses[i].rotation()); std::stringstream ss; ss << t[0]<<", "<<t[1]<<", "<<t[2]<<" | " <<r.w()<<", "<<r.x()<<", "<<r.y()<<", "<<r.z() ; std::cout << i << ": " << ss.str() << " pose_simulatedposition\n"; capture (poses[i],disparity_buf_, color_buf_uint);//,ss.str()); color_buf_ = (const KinfuTracker::PixelRGB*) color_buf_uint; PtrStepSz<const unsigned short> depth_sim = PtrStepSz<const unsigned short>(height, width, disparity_buf_, 2*width); //cout << depth_sim.rows << " by " << depth_sim.cols << " | s: " << depth_sim.step << "\n"; // RGB-KinFu currently disabled for now - problems with color in KinFu apparently // but this constructor might not be right either: not sure about step size integrate_colors_=false; PtrStepSz<const KinfuTracker::PixelRGB> rgb24_sim = PtrStepSz<const KinfuTracker::PixelRGB>(height, width, color_buf_, width); tic_toc.push_back (getTime ()); if (1==0){ // live capture - probably doesnt work anymore, left in here for comparison: bool has_frame = evaluation_ptr_ ? evaluation_ptr_->grab(i, depth) : capture_.grab (depth, rgb24); if (!has_frame) { cout << "Can't grab" << endl; break; } depth_device_.upload (depth.data, depth.step, depth.rows, depth.cols); if (integrate_colors_) image_view_.colors_device_.upload (rgb24.data, rgb24.step, rgb24.rows, rgb24.cols); { SampledScopeTime fps(time_ms, i); //run kinfu algorithm if (integrate_colors_) has_image = kinfu_ (depth_device_, image_view_.colors_device_); else has_image = kinfu_ (depth_device_); } }else{ //simulate: cout << " color: " << integrate_colors_ << "\n"; // integrate_colors_ seems to be zero depth_device_.upload (depth_sim.data, depth_sim.step, depth_sim.rows, depth_sim.cols); if (integrate_colors_){ image_view_.colors_device_.upload (rgb24_sim.data, rgb24_sim.step, rgb24_sim.rows, rgb24_sim.cols); } tic_toc.push_back (getTime ()); { SampledScopeTime fps(time_ms, i); //run kinfu algorithm if (integrate_colors_) has_image = kinfu_ (depth_device_, image_view_.colors_device_); else has_image = kinfu_ (depth_device_); } } tic_toc.push_back (getTime ()); Eigen::Affine3f k_aff = kinfu_.getCameraPose(); Eigen::Matrix3f k_m; k_m =k_aff.rotation(); Eigen::Quaternionf k_r; k_r = Eigen::Quaternionf(k_m); std::stringstream ss_k; ss_k << k_aff(0,3) <<", "<< k_aff(1,3)<<", "<< k_aff(2,3)<<" | " <<k_r.w()<<", "<<k_r.x()<<", "<<k_r.y()<<", "<<k_r.z() ; std::cout << i << ": " << ss_k.str() << " pose_kinect\n"; // Everything below this is Visualization or I/O: if (i >n_pose_stop){ int pause; cout << "Enter a key to write Mesh file\n"; cin >> pause; scene_cloud_view_.showMesh(kinfu_, integrate_colors_); writeMesh(KinFuApp::MESH_VTK); // writeMesh(KinFuApp::MESH_PLY); if (scan_) { scan_ = false; scene_cloud_view_.show (kinfu_, integrate_colors_); if (scan_volume_) { // download tsdf volume { ScopeTimeT time ("tsdf volume download"); cout << "Downloading TSDF volume from device ... " << flush; // kinfu_.volume().downloadTsdfAndWeighs (tsdf_volume_.volumeWriteable (), tsdf_volume_.weightsWriteable ()); kinfu_.volume ().downloadTsdfAndWeighsLocal (); // tsdf_volume_.setHeader (Eigen::Vector3i (pcl::device::VOLUME_X, pcl::device::VOLUME_Y, pcl::device::VOLUME_Z), kinfu_.volume().getSize ()); kinfu_.volume ().setHeader (Eigen::Vector3i (pcl::device::VOLUME_X, pcl::device::VOLUME_Y, pcl::device::VOLUME_Z), kinfu_.volume().getSize ()); // cout << "done [" << tsdf_volume_.size () << " voxels]" << endl << endl; cout << "done [" << kinfu_.volume ().size () << " voxels]" << endl << endl; } { ScopeTimeT time ("converting"); cout << "Converting volume to TSDF cloud ... " << flush; // tsdf_volume_.convertToTsdfCloud (tsdf_cloud_ptr_); kinfu_.volume ().convertToTsdfCloud (tsdf_cloud_ptr_); cout << "done [" << tsdf_cloud_ptr_->size () << " points]" << endl << endl; } } else cout << "[!] tsdf volume download is disabled" << endl << endl; } if (scan_mesh_) { scan_mesh_ = false; scene_cloud_view_.showMesh(kinfu_, integrate_colors_); } if (has_image) { Eigen::Affine3f viewer_pose = getViewerPose(scene_cloud_view_.cloud_viewer_); // image_view_.showScene (kinfu_, rgb24, registration_, independent_camera_ ? &viewer_pose : 0); image_view_.showScene (kinfu_, rgb24_sim, registration_, independent_camera_ ? &viewer_pose : 0); } if (current_frame_cloud_view_) current_frame_cloud_view_->show (kinfu_); image_view_.showDepth (depth_sim); //image_view_.showDepth (depth); // image_view_.showGeneratedDepth(kinfu_, kinfu_.getCameraPose()); if (!independent_camera_) setViewerPose (scene_cloud_view_.cloud_viewer_, kinfu_.getCameraPose()); scene_cloud_view_.cloud_viewer_.spinOnce (3); // As of April 2012, entering a key will end this program... cout << "Paused after view\n"; cin >> pause; } double elapsed = (getTime() -tic_main); cout << elapsed << " sec elapsed [" << (1/elapsed) << "]\n"; tic_toc.push_back (getTime ()); display_tic_toc (tic_toc, "kinfu_app_sim"); }
void display() { glViewport(range_likelihood_->width(), 0, range_likelihood_->width(), range_likelihood_->height()); float* reference = new float[range_likelihood_->row_height() * range_likelihood_->col_width()]; const float* depth_buffer = range_likelihood_->depth_buffer(); // Copy one image from our last as a reference. for (int i=0, n=0; i<range_likelihood_->row_height(); ++i) { for (int j=0; j<range_likelihood_->col_width(); ++j) { reference[n++] = depth_buffer[i*range_likelihood_->width() + j]; } } std::vector<Eigen::Isometry3d, Eigen::aligned_allocator<Eigen::Isometry3d> > poses; std::vector<float> scores; int n = range_likelihood_->rows()*range_likelihood_->cols(); for (int i=0; i<n; ++i) { // This is used when there is Camera camera(*camera_); camera.move(0.0,0.0,0.0); //camera.move(0.0,i*0.02,0.0); poses.push_back(camera.pose()); } float* depth_field =NULL; bool do_depth_field =false; range_likelihood_->compute_likelihoods(reference, poses, scores,depth_field,do_depth_field); // range_likelihood_->compute_likelihoods(reference, poses, scores); delete [] reference; delete [] depth_field; std::cout << "score: "; for (size_t i=0; i<scores.size(); ++i) { std::cout << " " << scores[i]; } std::cout << std::endl; // Draw the depth image // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // glColorMask(true, true, true, true); glDisable(GL_DEPTH_TEST); glViewport(0, 0, range_likelihood_->width(), range_likelihood_->height()); //glViewport(0, 0, range_likelihood_->width(), range_likelihood_->height()); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //glRasterPos2i(-1,-1); //glDrawPixels(range_likelihood_->width(), range_likelihood_->height(), GL_LUMINANCE, GL_FLOAT, range_likelihood_->depth_buffer()); display_depth_image(range_likelihood_->depth_buffer()); glutSwapBuffers(); if (write_file_){ range_likelihood_->addNoise(); pcl::RangeImagePlanar rangeImage; range_likelihood_->getRangeImagePlanar(rangeImage); pcl::PointCloud<pcl::PointXYZRGB>::Ptr pc_out (new pcl::PointCloud<pcl::PointXYZRGB>); // Optional argument to save point cloud in global frame: // Save camera relative: //range_likelihood_->getPointCloud(pc_out); // Save in global frame - applying the camera frame: //range_likelihood_->getPointCloud(pc_out,true,camera_->pose()); // Save in local frame range_likelihood_->getPointCloud(pc_out,false,camera_->pose()); // TODO: what to do when there are more than one simulated view? pcl::PCDWriter writer; writer.write ("simulated_range_image.pcd", *pc_out, false); cout << "finished writing file\n"; pcl::visualization::CloudViewer viewer ("Simple Cloud Viewer"); viewer.showCloud (pc_out); // Problem: vtk and opengl dont seem to play very well together // vtk seems to misbehavew after a little while and wont keep the window on the screen // method1: kill with [x] - but eventually it crashes: //while (!viewer.wasStopped ()){ //} // method2: eventually starts ignoring cin and pops up on screen and closes almost // immediately // cout << "enter 1 to cont\n"; // cin >> pause; // viewer.wasStopped (); // method 3: if you interact with the window with keys, the window is not closed properly // TODO: use pcl methods as this time stuff is probably not cross playform struct timespec t; t.tv_sec = 100; //t.tv_nsec = (time_t)(20000000); // short sleep t.tv_nsec = (time_t)(0); // long sleep - normal speed nanosleep(&t, NULL); write_file_ =0; } }