diff --git a/src/graphics_gl.rs b/src/graphics_gl.rs index 89787dde69..cdaec01be9 100644 --- a/src/graphics_gl.rs +++ b/src/graphics_gl.rs @@ -17,12 +17,14 @@ use glutin::window::WindowBuilder; use glutin::ContextBuilder; use std::mem::size_of; use std::ptr::null; -use glium::framebuffer::ColorAttachment::Texture; +//use glium::framebuffer::ColorAttachment::Texture; use std::sync::Arc; use sensor_control::CaptureProvider; use point_cloud; use point_cloud::point_cloud_compute_shader::PointCloudComputeShader; use point_cloud::point_cloud_renderer_shader::PointCloudRendererShader; +use point_cloud::point_cloud_visualiser::PointCloudVisualizer; +use point_cloud::viewer_image::ViewerImage; //use shader::Shader; @@ -107,7 +109,7 @@ static TEXTURE_CHECKERBOARD : [GLfloat; 12] = [ 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, ]; -pub fn run(capture_provider: Arc) { +pub fn run(capture_provider: Arc, calibration_data: k4a_sys::k4a_calibration_t) { let event_loop = EventLoop::new(); let window = WindowBuilder::new(); let gl_window = ContextBuilder::new() @@ -120,8 +122,18 @@ pub fn run(capture_provider: Arc) { // Load the OpenGL function pointers gl::load_with(|symbol| gl_window.get_proc_address(symbol)); - let compute_shader = PointCloudComputeShader::new(); - let render_shader = PointCloudRendererShader::new(); + // TODO + // k4a::calibration calib = m_device.get_calibration(m_config.DepthMode, m_config.ColorResolution); + + let mut visualizer = PointCloudVisualizer::new(false, calibration_data); + // TODO - constructed in PointCloudWindow. + /* + // TODO GLenum initResult = m_pointCloudVisualizer.InitializeTexture(&m_texture); + if (initResult != GL_NO_ERROR) + { + CheckVisualizationResult(PointCloudVisualizationResult::OpenGlError); + } + */ // Create GLSL shaders let vs = compile_shader(VERTEX_SHADER_SRC, gl::VERTEX_SHADER); @@ -257,6 +269,14 @@ pub fn run(capture_provider: Arc) { gl::Uniform3f(triangle_color_attr, 1.0, 0.0, 1.0); } + + let mut texture = ViewerImage::create( + 800, + 800, + None, + None + ).expect("ViewerImage texture creation should work"); + event_loop.run(move |event, window, control_flow| { //*control_flow = ControlFlow::Wait; match event { @@ -297,7 +317,7 @@ pub fn run(capture_provider: Arc) { // TODO: This belongs in a worker thread with buffers on both producer and consumer. if let Some(capture) = capture_provider.get_capture() { - if let Ok(image) = capture.get_color_image() { + /*if let Ok(image) = capture.get_color_image() { let width = image.get_width_pixels() as i32; let height = image.get_height_pixels() as i32; println!("Size: {}x{}", width, height); @@ -332,7 +352,10 @@ pub fn run(capture_provider: Arc) { ); } gl_window.swap_buffers().unwrap(); - } + }*/ + + visualizer.update_texture(&texture, &capture); + } }); } diff --git a/src/k4a_sys_wrapper.rs b/src/k4a_sys_wrapper.rs index 075fe46948..1a29b7a150 100644 --- a/src/k4a_sys_wrapper.rs +++ b/src/k4a_sys_wrapper.rs @@ -9,6 +9,7 @@ use k4a_sys; use k4a_sys_wrapper::ImageFormat::ColorMjpg; use glutin::platform::unix::x11::ffi::IconMaskHint; use std::ptr::null_mut; +use std::mem::MaybeUninit; pub fn device_get_installed_count() -> u32 { unsafe { @@ -136,8 +137,6 @@ impl Device { pub fn get_capture_buffered(&self, capture_buffer: &mut k4a_sys::k4a_capture_t, timeout_ms: i32) -> Result<(), GetCaptureError> { - let timeout_millis = 1000; - let result = unsafe { k4a_sys::k4a_device_get_capture(self.device_pointer, capture_buffer, timeout_ms) }; @@ -157,6 +156,50 @@ impl Device { Ok(()) } + + /// Get the camera calibration for the entire Azure Kinect device. + /// + /// The calibration represents the data needed to transform between the camera views and may be + /// different for each operating depth_mode and color_resolution the device is configured to + /// operate in. + /// The calibration output is used as input to all calibration and transformation functions. + pub fn get_calibration(&self, + depth_mode: k4a_sys::k4a_depth_mode_t, + color_resolution: k4a_sys::k4a_color_resolution_t) + -> Result + { + // TODO: Why isn't the way I've been using to init structures before still working? + //let mut calibration_buffer: k4a_sys::k4a_calibration_t = ptr::null_mut(); + /*let mut calibration_buffer: k4a_sys::k4a_calibration_t = k4a_sys::k4a_calibration_t { + color_camera_calibration: 0, + color_resolution: 0, + depth_camera_calibration: 0, + depth_mode: 0, + extrinsics: [0,0,0,0], + };*/ + + unsafe { + let mut calibration_buffer = MaybeUninit::uninit(); + let result = k4a_sys::k4a_device_get_calibration( + self.device_pointer, + depth_mode, + color_resolution, + calibration_buffer.as_mut_ptr(), + ); + + match result { + k4a_sys::k4a_result_t_K4A_RESULT_SUCCEEDED => { /* ok, continue */ }, + k4a_sys::k4a_result_t_K4A_RESULT_FAILED => { + return Err(GetCalibrationError::FailedError); + }, + _ => { + return Err(GetCalibrationError::UnknownError(result)); + }, + } + + Ok(calibration_buffer.assume_init()) + } + } } /// Errors for GetCapture @@ -172,6 +215,14 @@ pub enum CaptureError { NullCapture, } +/// Errors for GetCalibration +#[derive(Debug)] +pub enum GetCalibrationError { + FailedError, + UnknownError(u32), +} + + /// Adapted from k4a-sys. Represents a capture. #[derive(Debug, Clone)] pub struct Capture(pub k4a_sys::k4a_capture_t); @@ -231,6 +282,9 @@ impl Drop for Capture { /// https://users.rust-lang.org/t/solved-how-to-move-non-send-between-threads-or-an-alternative/19928/11 unsafe impl Send for Capture{} +/// TODO: We also need to send device +unsafe impl Send for Device{} + /// Adapted from k4a-sys. Represents an image within a capture. #[derive(Debug)] pub struct Image(pub k4a_sys::k4a_image_t); diff --git a/src/main.rs b/src/main.rs index 9c3a55b981..750598c25d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -62,11 +62,18 @@ pub mod sensor_control; pub mod point_cloud; pub fn main() { + let device = Device::open(0).expect("Device should open"); + + let depth_mode : k4a_sys::k4a_depth_mode_t = 2; //k4a_sys::K4A_DEPTH_MODE_NFOV_UNBINNED; + let color_format: k4a_sys::k4a_color_resolution_t = 1; //k4a_sys::K4A_COLOR_RESOLUTION_720P; + let calibration = device.get_calibration(depth_mode, color_format).unwrap(); + let capture_provider = Arc::new(CaptureProvider::new()); let capture_provider2= capture_provider.clone(); - thread::spawn(move || capture_thread(capture_provider)); + + thread::spawn(move || capture_thread(capture_provider, Some(device))); //graphics_grr::run(capture_provider2).unwrap(); //graphics_glium::run_glium(); - graphics_gl::run(capture_provider2); + graphics_gl::run(capture_provider2, calibration); } diff --git a/src/point_cloud/viewer_image.rs b/src/point_cloud/viewer_image.rs index ad731d178a..262ce01593 100644 --- a/src/point_cloud/viewer_image.rs +++ b/src/point_cloud/viewer_image.rs @@ -79,7 +79,7 @@ impl ViewerImage { pub fn create( width: u32, height: u32, - data: &[uint8_t], + //data: &[uint8_t], format: Option, internal_format: Option) -> Result { @@ -105,9 +105,9 @@ impl ViewerImage { ); } - unsafe { + /*unsafe { viewer_image.update_texture(data)?; - } + }*/ if let Err(err) = gl_get_error() { return Err(ViewerImageError::OpenGlError(err)); diff --git a/src/sensor_control.rs b/src/sensor_control.rs index 9f11cfbdd5..3aed361bc0 100644 --- a/src/sensor_control.rs +++ b/src/sensor_control.rs @@ -70,12 +70,18 @@ impl CaptureProvider { } } -pub fn capture_thread(capture_provider: Arc) { - let installed_devices = device_get_installed_count(); - println!("Installed devices: {}", installed_devices); +pub fn capture_thread(capture_provider: Arc, device: Option) { + let device = match device { + Some(device) => device, + None => { + let installed_devices = device_get_installed_count(); + println!("Installed devices: {}", installed_devices); - let device = Device::open(0).unwrap(); - println!("Device: {:?}", device); + let device = Device::open(0).unwrap(); + println!("Device: {:?}", device); + device + }, + }; let serial_number = device.get_serial_number().unwrap(); println!("Device: {:?}", serial_number); @@ -91,7 +97,6 @@ pub fn capture_thread(capture_provider: Arc) { } } - pub fn capture_thread_to_texture(frame: Arc>>) { let installed_devices = device_get_installed_count(); println!("Installed devices: {}", installed_devices);