♻️ refactor: rustify writer utility convert_flash_rotation (#317)

Author: SigureMo

packages/biliass/rust/src/lib.rs

@@ -29,5 +29,6 @@ fn biliass_pyo3(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(python::py_ass_escape, m)?)?;
     m.add_function(wrap_pyfunction!(python::py_convert_color, m)?)?;
     m.add_function(wrap_pyfunction!(python::py_get_zoom_factor, m)?)?;
+    m.add_function(wrap_pyfunction!(python::py_convert_flash_rotation, m)?)?;
     Ok(())
 }

packages/biliass/rust/src/python/mod.rs

@@ -6,4 +6,7 @@ mod writer;
 pub use comment::{PyComment, PyCommentPosition};
 pub use proto::{PyDanmakuElem, PyDmSegMobileReply};
 pub use reader::{py_read_comments_from_protobuf, py_read_comments_from_xml};
-pub use writer::{py_ass_escape, py_convert_color, py_convert_timestamp, py_get_zoom_factor};
+pub use writer::{
+    py_ass_escape, py_convert_color, py_convert_flash_rotation, py_convert_timestamp,
+    py_get_zoom_factor,
+};

packages/biliass/rust/src/python/writer.rs

@@ -25,3 +25,17 @@ pub fn py_get_zoom_factor(
 ) -> PyResult<(f32, f32, f32)> {
     Ok(writer::utils::get_zoom_factor(source_size, target_size))
 }
+
+#[pyfunction(name = "convert_flash_rotation")]
+pub fn py_convert_flash_rotation(
+    rot_y: f64,
+    rot_z: f64,
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+) -> PyResult<(f64, f64, f64, f64, f64, f64, f64)> {
+    Ok(writer::utils::convert_flash_rotation(
+        rot_y, rot_z, x, y, width, height,
+    ))
+}

packages/biliass/rust/src/writer/utils.rs

@@ -103,3 +103,77 @@ pub fn get_zoom_factor(source_size: (u32, u32), target_size: (u32, u32)) -> (f32
         (target_size.0 / source_size.0, 0.0, 0.0)
     }
 }
+
+// Calculation is based on https://github.com/jabbany/CommentCoreLibrary/issues/5#issuecomment-40087282
+//                      and https://github.com/m13253/danmaku2ass/issues/7#issuecomment-41489422
+// ASS FOV = width*4/3.0
+// But Flash FOV = width/math.tan(100*math.pi/360.0)/2 will be used instead
+// Result: (trans_x, trans_y, rot_x, rot_y, rot_z, scale_x, scale_y)
+pub fn convert_flash_rotation(
+    rot_y: f64,
+    rot_z: f64,
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+) -> (f64, f64, f64, f64, f64, f64, f64) {
+    let wrap_angle = |deg: f64| -> f64 { 180.0 - ((180.0 - deg).rem_euclid(360.0)) };
+    let mut rot_y = wrap_angle(rot_y);
+    let rot_z = wrap_angle(rot_z);
+    let pi_angle = std::f64::consts::PI / 180.0;
+    if rot_y == 90.0 || rot_y == -90.0 {
+        rot_y -= 1.0;
+    }
+    let (out_x, out_y, out_z, rot_y, rot_z) = if rot_y == 0. || rot_z == 0. {
+        let out_x = 0.;
+        let out_y = -rot_y; // Positive value means clockwise in Flash
+        let out_z = -rot_z;
+        let rot_y_rad = rot_y * pi_angle;
+        let rot_z_rad = rot_z * pi_angle;
+        (out_x, out_y, out_z, rot_y_rad, rot_z_rad)
+    } else {
+        let rot_y_rad = rot_y * pi_angle;
+        let rot_z_rad = rot_z * pi_angle;
+        let out_y = (-rot_y_rad.sin() * rot_z_rad.cos()).atan2(rot_y_rad.cos()) / pi_angle;
+        let out_z = (-rot_y_rad.cos() * rot_z_rad.sin()).atan2(rot_z_rad.cos()) / pi_angle;
+        let out_x = (rot_y_rad.sin() * rot_z_rad.sin()).asin() / pi_angle;
+        (out_x, out_y, out_z, rot_y_rad, rot_z_rad)
+    };
+    let trans_x = (x * rot_z.cos() + y * rot_z.sin()) / rot_y.cos()
+        + (1.0 - rot_z.cos() / rot_y.cos()) * width / 2.0
+        - rot_z.sin() / rot_y.cos() * height / 2.0;
+    let trans_y = y * rot_z.cos() - x * rot_z.sin()
+        + rot_z.sin() * width / 2.0
+        + (1.0 - rot_z.cos()) * height / 2.0;
+    let trans_z = (trans_x - width / 2.0) * rot_y.sin();
+    let fov = width * (2.0 * std::f64::consts::PI / 9.0).tan() / 2.0;
+    let scale_xy = if fov + trans_z != 0.0 {
+        fov / (fov + trans_z)
+    } else {
+        // eprintln!(
+        //     "Rotation makes object behind the camera: trZ == {:.0}",
+        //     trans_z
+        // );
+        1.
+    };
+    let trans_x = (trans_x - width / 2.0) * scale_xy + width / 2.0;
+    let trans_y = (trans_y - height / 2.0) * scale_xy + height / 2.0;
+    let (scale_xy, out_x, out_y) = if scale_xy < 0. {
+        // eprintln!(
+        //     "Rotation makes object behind the camera: trZ == {:.0} < {:.0}",
+        //     trans_z, fov
+        // );
+        (-scale_xy, out_x + 180., out_y + 180.)
+    } else {
+        (scale_xy, out_x, out_y)
+    };
+    (
+        trans_x,
+        trans_y,
+        wrap_angle(out_x),
+        wrap_angle(out_y),
+        wrap_angle(out_z),
+        scale_xy * 100.,
+        scale_xy * 100.,
+    )
+}

packages/biliass/src/biliass/_core.pyi

@@ -61,3 +61,6 @@ def convert_timestamp(timestamp: float) -> float: ...
 def ass_escape(text: str) -> str: ...
 def convert_color(rgb: int, width: int = ..., height: int = ...) -> str: ...
 def get_zoom_factor(source_size: tuple[int, int], target_size: tuple[int, int]) -> tuple[float, float, float]: ...
+def convert_flash_rotation(
+    rot_y: float, rot_z: float, x: float, y: float, width: float, height: float
+) -> tuple[float, float, float, float, float, float, float]: ...

packages/biliass/src/biliass/biliass.py

@@ -14,6 +14,7 @@
     CommentPosition,
     ass_escape,
     convert_color,
+    convert_flash_rotation,
     convert_timestamp,
     get_zoom_factor,
     read_comments_from_protobuf,
@@ -221,69 +222,10 @@ def write_comment(
             styleid=styleid,
         )
 
-    def to_file(self, f):
-        f.write(self._text)
-
     def to_string(self):
         return self._text
 
 
-# Calculation is based on https://github.com/jabbany/CommentCoreLibrary/issues/5#issuecomment-40087282
-#                     and https://github.com/m13253/danmaku2ass/issues/7#issuecomment-41489422
-# ASS FOV = width*4/3.0
-# But Flash FOV = width/math.tan(100*math.pi/360.0)/2 will be used instead
-# Result: (transX, transY, rotX, rotY, rotZ, scaleX, scaleY)
-def convert_flash_rotation(rotY, rotZ, X, Y, width, height):
-    def wrap_angle(deg):
-        return 180 - ((180 - deg) % 360)
-
-    rotY = wrap_angle(rotY)
-    rotZ = wrap_angle(rotZ)
-    if rotY in (90, -90):
-        rotY -= 1
-    if rotY == 0 or rotZ == 0:
-        outX = 0
-        outY = -rotY  # Positive value means clockwise in Flash
-        outZ = -rotZ
-        rotY *= math.pi / 180.0
-        rotZ *= math.pi / 180.0
-    else:
-        rotY *= math.pi / 180.0
-        rotZ *= math.pi / 180.0
-        outY = math.atan2(-math.sin(rotY) * math.cos(rotZ), math.cos(rotY)) * 180 / math.pi
-        outZ = math.atan2(-math.cos(rotY) * math.sin(rotZ), math.cos(rotZ)) * 180 / math.pi
-        outX = math.asin(math.sin(rotY) * math.sin(rotZ)) * 180 / math.pi
-    trX = (
-        (X * math.cos(rotZ) + Y * math.sin(rotZ)) / math.cos(rotY)
-        + (1 - math.cos(rotZ) / math.cos(rotY)) * width / 2
-        - math.sin(rotZ) / math.cos(rotY) * height / 2
-    )
-    trY = Y * math.cos(rotZ) - X * math.sin(rotZ) + math.sin(rotZ) * width / 2 + (1 - math.cos(rotZ)) * height / 2
-    trZ = (trX - width / 2) * math.sin(rotY)
-    FOV = width * math.tan(2 * math.pi / 9.0) / 2
-    try:
-        scaleXY = FOV / (FOV + trZ)
-    except ZeroDivisionError:
-        logging.error(f"Rotation makes object behind the camera: trZ == {trZ:.0f}")
-        scaleXY = 1
-    trX = (trX - width / 2) * scaleXY + width / 2
-    trY = (trY - height / 2) * scaleXY + height / 2
-    if scaleXY < 0:
-        scaleXY = -scaleXY
-        outX += 180
-        outY += 180
-        logging.error(f"Rotation makes object behind the camera: trZ == {trZ:.0f} < {FOV:.0f}")
-    return (
-        trX,
-        trY,
-        wrap_angle(outX),
-        wrap_angle(outY),
-        wrap_angle(outZ),
-        scaleXY * 100,
-        scaleXY * 100,
-    )
-
-
 def process_comments(
     comments,
     width,