Ability to export camera data as .usd or .jsx

AdrianEddy · AdrianEddy · commit cfe07140c0c9 · 2024-06-25T05:37:14.000+02:00
diff --git a/src/controller.rs b/src/controller.rs
@@ -1917,9 +1917,9 @@ impl Controller {
     }
     fn export_gyro_data(&self, url: QUrl, fields: QJsonObject) {
         let url = util::qurl_to_encoded(url);
-        let is_csv = filesystem::get_filename(&url).ends_with(".csv");
+        let filename = filesystem::get_filename(&url).to_ascii_lowercase();
 
-        let contents = gyroflow_core::gyro_export::export_gyro_data(is_csv, fields.to_json().to_str().unwrap(), &self.stabilizer);
+        let contents = gyroflow_core::gyro_export::export_gyro_data(&filename, fields.to_json().to_str().unwrap(), &self.stabilizer);
         if let Err(e) = filesystem::write(&url, contents.as_bytes()) {
             self.error(QString::from("An error occured: %1"), QString::from(e.to_string()), QString::default());
         }
@@ -2270,7 +2270,7 @@ impl Filesystem {
         let folder = filesystem::get_folder(&current_url);
         let filename = filesystem::get_filename(&current_url);
 
-        let extensions = [ "mp4", "mov", "mxf", "mkv", "webm", "insv", "gyroflow", "braw", "r3d" ];
+        let extensions = [ "mp4", "mov", "mxf", "mkv", "webm", "insv", "braw", "r3d" ];
 
         let list: Vec<(String, String)> = filesystem::list_folder(&folder)
             .into_iter()
diff --git a/src/core/gyro_export.rs b/src/core/gyro_export.rs
@@ -35,19 +35,31 @@ pub fn export_full_metadata(gyro_url: &str, _stab: &Arc<crate::StabilizationMana
     Ok(serde_json::to_string_pretty(&output)?)
 }
 
-pub fn export_gyro_data(is_csv: bool, fields_json: &str, stab: &Arc<crate::StabilizationManager>) -> String {
+pub fn export_gyro_data(filename: &str, fields_json: &str, stab: &Arc<crate::StabilizationManager>) -> String {
     use std::fmt::Write;
     use crate::util::MapClosest;
     const RAD2DEG: f64 = 180.0 / std::f64::consts::PI;
     enum TimestampType {
         Milliseconds(f64),
         Microseconds(i64),
     }
+    #[derive(PartialEq, Eq)]
+    enum Format {
+        Csv, Json, Usd, Jsx
+    }
     fn get(f: Option<[f64; 3]>, i: usize) -> f64 { f.map(|x| x[i]).unwrap_or_default() }
 
+    let format = match filename.split('.').last().unwrap_or_default() {
+        "csv"  => Format::Csv,
+        "json" => Format::Json,
+        "usd"  => Format::Usd,
+        "jsx"  => Format::Jsx,
+        _ => Format::Csv,
+    };
+
     let fields: serde_json::Value = serde_json::from_str(fields_json).unwrap();
 
-    let all_samples = fields.get("export_all_samples").and_then(|x| x.as_bool()).unwrap_or_default();
+    let all_samples = fields.get("export_all_samples").and_then(|x| x.as_bool()).unwrap_or_default() && format != Format::Usd && format != Format::Jsx;
 
     let original    = fields.get("original")  .and_then(|x| x.as_object()).unwrap();
     let stabilized  = fields.get("stabilized").and_then(|x| x.as_object()).unwrap();
@@ -65,19 +77,20 @@ pub fn export_gyro_data(is_csv: bool, fields_json: &str, stab: &Arc<crate::Stabi
     let fovs         = zooming.get("fovs")        .and_then(|x| x.as_bool()).unwrap_or_default();
     let minimal_fovs = zooming.get("minimal_fovs").and_then(|x| x.as_bool()).unwrap_or_default();
 
-    let mut csv = String::from("frame,timestamp_ms");
+    let mut output = String::new();
     let mut json = Vec::<std::collections::HashMap<&str, serde_json::Value>>::new();
-    if is_csv {
-        if oaccl { let _ = write!(csv, ",org_acc_x,org_acc_y,org_acc_z"); }
-        if oeulr { let _ = write!(csv, ",org_pitch,org_yaw,org_roll"); }
-        if ogyro { let _ = write!(csv, ",org_gyro_x,org_gyro_y,org_gyro_z"); }
-        if oquat { let _ = write!(csv, ",org_quat_w,org_quat_x,org_quat_y,org_quat_z"); }
-        if seulr { let _ = write!(csv, ",stab_pitch,stab_yaw,stab_roll"); }
-        if squat { let _ = write!(csv, ",stab_quat_w,stab_quat_x,stab_quat_y,stab_quat_z"); }
-        if focal_length { let _ = write!(csv, ",focal_length"); }
-        if fovs         { let _ = write!(csv, ",fov_scale"); }
-        if minimal_fovs { let _ = write!(csv, ",minimal_fov_scale"); }
-        let _ = write!(csv, "\n");
+    if format == Format::Csv {
+        let _ = write!(output, "frame,timestamp_ms");
+        if oaccl { let _ = write!(output, ",org_acc_x,org_acc_y,org_acc_z"); }
+        if oeulr { let _ = write!(output, ",org_pitch,org_yaw,org_roll"); }
+        if ogyro { let _ = write!(output, ",org_gyro_x,org_gyro_y,org_gyro_z"); }
+        if oquat { let _ = write!(output, ",org_quat_w,org_quat_x,org_quat_y,org_quat_z"); }
+        if seulr { let _ = write!(output, ",stab_pitch,stab_yaw,stab_roll"); }
+        if squat { let _ = write!(output, ",stab_quat_w,stab_quat_x,stab_quat_y,stab_quat_z"); }
+        if focal_length { let _ = write!(output, ",focal_length"); }
+        if fovs         { let _ = write!(output, ",fov_scale"); }
+        if minimal_fovs { let _ = write!(output, ",minimal_fov_scale"); }
+        let _ = write!(output, "\n");
     }
 
     let params = stab.params.read();
@@ -110,6 +123,44 @@ pub fn export_gyro_data(is_csv: bool, fields_json: &str, stab: &Arc<crate::Stabi
             (None, frame, TimestampType::Milliseconds(middle_timestamp), timestamp_ms)
         }).collect()
     };
+    let num_frames = params.frame_count;
+    let fps = params.get_scaled_fps();
+    let frame_times = serde_json::to_string(&(0..num_frames).map(|i| i as f64 / fps).collect::<Vec<_>>()).unwrap();
+
+    if format == Format::Usd {
+        output.push_str(&format!(r#"#usda 1.0
+            (
+                defaultPrim = "root"
+                doc = "Gyroflow"
+                endTimeCode = {num_frames}
+                metersPerUnit = 1
+                startTimeCode = 1
+                timeCodesPerSecond = {fps:.6}
+                upAxis = "Z"
+            )
+            def Xform "root" (
+                customData = {{
+                    dictionary Blender = {{
+                        bool generated = 1
+                    }}
+                }}
+            )
+            {{
+                def Xform "GyroflowCamera"
+                {{
+                    matrix4d xformOp:transform.timeSamples = {{
+            "#
+        ));
+    }
+
+    if format == Format::Jsx {
+        let duration_s = params.duration_ms / 1000.0;
+        output.push_str(&format!(r#"var comp = app.project.activeItem;
+            var GyroflowCamera = comp.layers.addCamera("GyroflowCamera",[0,0]);
+            GyroflowCamera.inPoint = 0.0;
+            GyroflowCamera.outPoint = {duration_s};
+            GyroflowCamera.property("orientation").setValuesAtTimes({frame_times}, ["#));
+    }
 
     let raw_imu = gyro.raw_imu(&file_metadata);
 
@@ -123,12 +174,38 @@ pub fn export_gyro_data(is_csv: bool, fields_json: &str, stab: &Arc<crate::Stabi
         let val_ogyro = [get(raw_imu.gyro, 0), get(raw_imu.gyro, 1), get(raw_imu.gyro, 2)];
         let val_oquat = [quatv[3], quatv[0], quatv[1], quatv[2]];
 
+        if format == Format::Jsx && !(seulr && !oeulr) {
+            output.push_str(&format!("[{},{},{}],\n", val_oeulr[0], -val_oeulr[2], val_oeulr[1]));
+        }
+        if format == Format::Usd && !(seulr && !oeulr) {
+            let matrix = nalgebra::Matrix4::from(quat);
+            output.push_str(&format!("                {}: ( ({},{},{}, 0), ({}, {}, {}, 0), ({}, {}, {}, 0), (7.0, -7.0, 1.5, 1) ),\n",
+                frame + 1,
+                matrix[(0, 0)], matrix[(1, 0)], matrix[(2, 0)],
+                matrix[(0, 1)], matrix[(1, 1)], matrix[(2, 1)],
+                matrix[(0, 2)], matrix[(1, 2)], matrix[(2, 2)]
+            ));
+        }
+
         let quat = match ts { TimestampType::Microseconds(ts) => *gyro.smoothed_quaternions.get(&ts).unwrap(), TimestampType::Milliseconds(ts) => gyro.smoothed_quat_at_timestamp(ts) };
         let quate = quat.euler_angles();
         let quatv = quat.as_vector();
         let val_seulr = [quate.0 * RAD2DEG, quate.1 * RAD2DEG, quate.2 * RAD2DEG];
         let val_squat = [quatv[3], quatv[0], quatv[1], quatv[2]];
 
+        if format == Format::Jsx && (seulr && !oeulr) {
+            output.push_str(&format!("[{},{},{}],\n", val_seulr[0], -val_seulr[2], val_seulr[1]));
+        }
+        if format == Format::Usd && (seulr && !oeulr) {
+            let matrix = nalgebra::Matrix4::from(quat);
+            output.push_str(&format!("                {}: ( ({},{},{}, 0), ({}, {}, {}, 0), ({}, {}, {}, 0), (7.0, -7.0, 1.5, 1) ),\n",
+                frame + 1,
+                matrix[(0, 0)], matrix[(1, 0)], matrix[(2, 0)],
+                matrix[(0, 1)], matrix[(1, 1)], matrix[(2, 1)],
+                matrix[(0, 2)], matrix[(1, 2)], matrix[(2, 2)]
+            ));
+        }
+
         if let Some(val) = file_metadata.lens_params.get_closest(&((timestamp_ms * 1000.0).round() as i64), 100000) { // closest within 100ms
             if let Some(fl) = val.focal_length {
                 focal_length_value = Some(fl as f64);
@@ -138,19 +215,19 @@ pub fn export_gyro_data(is_csv: bool, fields_json: &str, stab: &Arc<crate::Stabi
         let val_fov = *params.fovs.get(frame).unwrap_or(&0.0);
         let val_minimal_fov = *params.minimal_fovs.get(frame).unwrap_or(&0.0);
 
-        if is_csv {
-            let _ = write!(csv, "{frame},{timestamp_ms:.3}");
-            if oaccl { let _ = write!(csv, ",{:.6},{:.6},{:.6}",       val_oaccl[0], val_oaccl[1], val_oaccl[2]); }
-            if oeulr { let _ = write!(csv, ",{:.3},{:.3},{:.3}",       val_oeulr[0], val_oeulr[1], val_oeulr[2]); }
-            if ogyro { let _ = write!(csv, ",{:.6},{:.6},{:.6}",       val_ogyro[0], val_ogyro[1], val_ogyro[2]); }
-            if oquat { let _ = write!(csv, ",{:.6},{:.6},{:.6},{:.6}", val_oquat[0], val_oquat[1], val_oquat[2], val_oquat[3]); }
-            if seulr { let _ = write!(csv, ",{:.3},{:.3},{:.3}",       val_seulr[0], val_seulr[1], val_seulr[2]); }
-            if squat { let _ = write!(csv, ",{:.6},{:.6},{:.6},{:.6}", val_squat[0], val_squat[1], val_squat[2], val_squat[3]); }
-            if focal_length { let _ = write!(csv, ",{val_fl:.3}");  }
-            if fovs         { let _ = write!(csv, ",{val_fov:.3}"); }
-            if minimal_fovs { let _ = write!(csv, ",{val_minimal_fov:.3}"); }
-            let _ = write!(csv, "\n");
-        } else {
+        if format == Format::Csv {
+            let _ = write!(output, "{frame},{timestamp_ms:.3}");
+            if oaccl { let _ = write!(output, ",{:.6},{:.6},{:.6}",       val_oaccl[0], val_oaccl[1], val_oaccl[2]); }
+            if oeulr { let _ = write!(output, ",{:.3},{:.3},{:.3}",       val_oeulr[0], val_oeulr[1], val_oeulr[2]); }
+            if ogyro { let _ = write!(output, ",{:.6},{:.6},{:.6}",       val_ogyro[0], val_ogyro[1], val_ogyro[2]); }
+            if oquat { let _ = write!(output, ",{:.6},{:.6},{:.6},{:.6}", val_oquat[0], val_oquat[1], val_oquat[2], val_oquat[3]); }
+            if seulr { let _ = write!(output, ",{:.3},{:.3},{:.3}",       val_seulr[0], val_seulr[1], val_seulr[2]); }
+            if squat { let _ = write!(output, ",{:.6},{:.6},{:.6},{:.6}", val_squat[0], val_squat[1], val_squat[2], val_squat[3]); }
+            if focal_length { let _ = write!(output, ",{val_fl:.3}");  }
+            if fovs         { let _ = write!(output, ",{val_fov:.3}"); }
+            if minimal_fovs { let _ = write!(output, ",{val_minimal_fov:.3}"); }
+            let _ = write!(output, "\n");
+        } else if format == Format::Json {
             let mut obj = std::collections::HashMap::new();
             obj.insert("frame", frame.into());
             obj.insert("timestamp_ms", timestamp_ms.into());
@@ -166,9 +243,71 @@ pub fn export_gyro_data(is_csv: bool, fields_json: &str, stab: &Arc<crate::Stabi
             json.push(obj);
         }
     }
+    let mut comp_params = crate::stabilization::ComputeParams::from_manager(stab);
+
+    if format == Format::Jsx {
+        output = output.trim_end_matches(",\n").to_string();
+        output.push_str("]);\n");
+
+        let (camera_matrix, _, _, _, _, _) = crate::stabilization::FrameTransform::get_lens_data_at_timestamp(&comp_params, 0.0);
+        output.push_str(&format!("GyroflowCamera.property(\"zoom\").setValue({});\n", camera_matrix[(0, 0)]));
+        if comp_params.gyro.read().file_metadata.read().lens_params.len() > 1 {
+            output.push_str(&format!("GyroflowCamera.property(\"zoom\").setValuesAtTimes({frame_times}, ["));
+            for f in 0..num_frames as i32 {
+                let timestamp = crate::timestamp_at_frame(f, fps);
+                let (camera_matrix, _, _, _, _, _) = crate::stabilization::FrameTransform::get_lens_data_at_timestamp(&comp_params, timestamp);
+                output.push_str(&format!("{},\n", camera_matrix[(0, 0)]));
+            }
+            output = output.trim_end_matches(",\n").to_string();
+            output.push_str("]);\n");
+        }
+    }
+
+    if format == Format::Csv || format == Format::Jsx {
+        output
+    } else if format == Format::Usd {
+        let aspect = params.video_size.0 as f64 / params.video_size.1 as f64;
+        let width_mm = 35.0;
+        let height_mm = width_mm / aspect;
+
+        comp_params.calculate_camera_fovs();
+
+        output.push_str("\n}");
+        let fov = comp_params.camera_diagonal_fovs.first().unwrap();
+        let diagonal_mm = (width_mm.powi(2) + height_mm.powi(2)).sqrt();
+        let focal_length_mm = diagonal_mm / (2.0 * (fov.to_radians() / 2.0).tan()) / 100.0;
+
+        let focal_lengths = {
+            let mut fls = String::new();
+            if comp_params.camera_diagonal_fovs.len() > 1 {
+                fls.push_str("float focalLength.timeSamples = {\n");
+                for (frame, fov) in comp_params.camera_diagonal_fovs.iter().enumerate() {
+                    let focal_length_mm = diagonal_mm / (2.0 * (fov.to_radians() / 2.0).tan()) / 100.0;
+                    fls.push_str(&format!("                {}: {focal_length_mm},\n", frame + 1));
+                }
+                fls.push_str("}");
+            }
+            fls
+        };
+
+        output.push_str(&format!(r#"
+                uniform token[] xformOpOrder = ["xformOp:transform"]
+
+                def Camera "GyroflowCamera"
+                {{
+                    float2 clippingRange = (0.1, 100)
+                    float focalLength = {focal_length_mm}
+                    {focal_lengths}
+                    float horizontalAperture = {}
+                    float horizontalApertureOffset = 0
+                    token projection = "perspective"
+                    float verticalAperture = {}
+                    float verticalApertureOffset = 0
+                }}
+            }}
+        }}"#, width_mm / 100.0, height_mm / 100.0));
 
-    if is_csv {
-        csv
+        output
     } else {
         serde_json::to_string(&json).unwrap()
     }
diff --git a/src/core/gyro_source/sony.rs b/src/core/gyro_source/sony.rs
@@ -300,7 +300,7 @@ pub fn stab_collect(is: &mut ISTemp, tag_map: &GroupedTagMap, _info: &telemetry_
     Some(())
 }
 
-pub fn stab_calc_splines(md: &FileMetadata, is_temp: &ISTemp, sample_rate: f64, _frame_rate: f64, size: (usize, usize)) -> Option<Vec<CameraStabData>> {
+pub fn stab_calc_splines(md: &FileMetadata, is_temp: &ISTemp, sample_rate: f64, _frame_rate: f64, _size: (usize, usize)) -> Option<Vec<CameraStabData>> {
     let num_frames = is_temp.per_frame_exposure.len();
 
     let readout_time = md.frame_readout_time.unwrap_or_default() / is_temp.original_sample_rate * sample_rate * 1000.0;
diff --git a/src/core/stabilization/frame_transform.rs b/src/core/stabilization/frame_transform.rs
@@ -211,7 +211,7 @@ impl FrameTransform {
         } else {
             (1.0, 1.0)
         };
-        let height_scale = params.video_height as f64 / params.height.max(1) as f64;
+        // let height_scale = params.video_height as f64 / params.height.max(1) as f64;
 
         let image_rotation = Matrix3::new_rotation(video_rotation * (std::f64::consts::PI / 180.0));
 
diff --git a/src/ui/menu/MotionData.qml b/src/ui/menu/MotionData.qml
@@ -575,7 +575,7 @@ MenuItem {
                         }
                     }
                     Action {
-                        text: qsTr("Export to CSV or JSON");
+                        text: qsTr("Export camera data (CSV/JSON/USD/AE)");
                         onTriggered: {
                             const el = Qt.createComponent("../SettingsSelector.qml").createObject(window, {
                                 desc: [
@@ -612,7 +612,7 @@ MenuItem {
                             el.opened = true;
                             el.onApply.connect((obj) => {
                                 settings.setValue("CSVExportSelection", JSON.stringify(obj));
-                                exportFileDialog.nameFilters = ["*.csv", "*.json"];
+                                exportFileDialog.nameFilters = ["CSV (*.csv)", "JSON (*.json)", "Universal Scene Description (*.usd)", "After Effects Script (*.jsx)"];
                                 exportFileDialog.exportData = obj;
                                 exportFileDialog.open2();
                             });
@@ -621,15 +621,15 @@ MenuItem {
                     Action {
                         text: qsTr("Export full metadata");
                         onTriggered: {
-                            exportFileDialog.nameFilters = ["*.json"];
+                            exportFileDialog.nameFilters = ["JSON (*.json)"];
                             exportFileDialog.exportData = "full";
                             exportFileDialog.open2();
                         }
                     }
                     Action {
                         text: qsTr("Export parsed metadata");
                         onTriggered: {
-                            exportFileDialog.nameFilters = ["*.json"];
+                            exportFileDialog.nameFilters = ["JSON (*.json)"];
                             exportFileDialog.exportData = "parsed";
                             exportFileDialog.open2();
                         }

Original file line number	Diff line number	Diff line change
`@@ -300,7 +300,7 @@ pub fn stab_collect(is: &mut ISTemp, tag_map: &GroupedTagMap, _info: &telemetry_`
`300`	`300`	`Some(())`
`301`	`301`	`}`
`302`	`302`
`303`		`-pub fn stab_calc_splines(md: &FileMetadata, is_temp: &ISTemp, sample_rate: f64, _frame_rate: f64, size: (usize, usize)) -> Option<Vec<CameraStabData>> {`
	`303`	`+pub fn stab_calc_splines(md: &FileMetadata, is_temp: &ISTemp, sample_rate: f64, _frame_rate: f64, _size: (usize, usize)) -> Option<Vec<CameraStabData>> {`
`304`	`304`	`let num_frames = is_temp.per_frame_exposure.len();`
`305`	`305`
`306`	`306`	`let readout_time = md.frame_readout_time.unwrap_or_default() / is_temp.original_sample_rate * sample_rate * 1000.0;`