feat(ctm): TextObject CTM implementation

Author: hualet

learning/ofd_notes.md

@@ -6,6 +6,9 @@
 
 参考： [http://wiki.easyofd.cn/OFD标准/页面描述](http://wiki.easyofd.cn/OFD%E6%A0%87%E5%87%86/%E9%A1%B5%E9%9D%A2%E6%8F%8F%E8%BF%B0) 中的 “变换矩阵 CTM” 部分。
 
+
+理解矩阵变换: [Transformation with cairo](https://gist.github.com/bert/1164354/c0391388afffc4b287c46ac79287f77e94c712e3)
+
 ### TextObject
 
 > pdf page 63

src/elements.rs

@@ -338,6 +338,8 @@ pub struct PathObject {
     pub line_width: f64,
     pub stroke: Option<bool>,
     pub stroke_color: Option<Color>,
+    #[serde(rename = "CTM")]
+    pub ctm: Option<String>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -378,6 +380,8 @@ pub struct TextObject {
     pub size: f64,
     pub fill_color: Option<Color>,
     pub text_code: TextCode,
+    #[serde(rename = "CTM")]
+    pub ctm: Option<String>,
 }
 
 #[derive(Debug, Deserialize, Clone)]

src/render.rs

@@ -42,6 +42,7 @@ impl Renderable for PathObject {
         _ofd: &mut Ofd, _document: &Document) -> Result<(), Error> {
         context.save()?;
 
+        // TODO(hualet): implement ctm.
         let boundary = ct::Box::from(self.boundary.clone()).to_pixel();
         let color = ct::Color::from(
             self.stroke_color.as_ref().unwrap().value.clone());
@@ -89,8 +90,21 @@ impl Renderable for TextObject {
         context.set_source_rgb(fill_color.value[0] as f64 / 255.0,
             fill_color.value[1] as f64 / 255.0,
             fill_color.value[2] as f64 / 255.0);
-        context.move_to(boundary.x as f64 + mmtopx(self.text_code.x),
+
+        // NOTE(hualet): transform should be used together with translate,
+        // so the coordinate system is correct.
+        // THEY ARE BOTH TRANSFORMATIONS!
+        context.translate(boundary.x as f64 + mmtopx(self.text_code.x),
             boundary.y as f64 + mmtopx(self.text_code.y));
+        if let Some(ctm) = self.ctm.as_ref() {
+            debug!("render text object:{:?} with ctm: {:?}",
+                self.text_code.value, ctm);
+            let matrix = ct::Matrix::from(ctm.clone());
+            let cairo_matrix: cairo::Matrix = matrix.into();
+            context.transform(cairo_matrix);
+        }
+
+        context.move_to(0., 0.);
         context.show_text(self.text_code.value.as_str())?;
 
         context.restore()
@@ -103,6 +117,7 @@ impl Renderable for ImageObject {
         ofd: &mut Ofd, document: &Document) -> Result<(), Error> {
         context.save()?;
 
+        // TODO(hualet): implement ctm.
         let boundary = ct::Box::from(self.boundary.clone()).to_pixel();
 
         // find the image file:
@@ -178,4 +193,39 @@ fn _render_page_block(events: Vec<Event>, context: &mut cairo::Context,
     }
 
     Ok(())
+}
+
+/*
+    ct::Matrix
+
+    | a b 0 |
+    | c d 0 |
+    | e f 1 |
+
+    x'=ax+cy+e
+    y'=bx+dy+f
+
+
+    cairo::Matrix
+
+    typedef struct {
+        double xx; double yx;
+        double xy; double yy;
+        double x0; double y0;
+    } cairo_matrix_t;
+
+    x_new = xx * x + xy * y + x0;
+    y_new = yx * x + yy * y + y0;
+*/
+impl From<ct::Matrix> for cairo::Matrix {
+    fn from(value: ct::Matrix) -> Self {
+        Self::new(
+            value.a, // xx
+            value.b, // yx
+            value.c, // xy
+            value.d, // yy
+            value.e, // x0
+            value.f  // y0
+        )
+    }
 }

src/types.rs

@@ -35,6 +35,16 @@ pub mod ct {
         pub alpha: i32,
     }
 
+    #[derive(Debug)]
+    pub struct Matrix {
+        pub a: f64,
+        pub b: f64,
+        pub c: f64,
+        pub d: f64,
+        pub e: f64,
+        pub f: f64,
+    }
+
     // implement string to PageArea
     impl From<String> for PageArea {
         fn from(value: String) -> Self {
@@ -59,6 +69,23 @@ pub mod ct {
         }
     }
 
+    impl From<String> for Matrix {
+        fn from(value: String) -> Self {
+            let parts: Vec<f64> = value.split_whitespace().map(|s| s.parse().unwrap()).collect();
+            // According to the spec, the matrix should be 6 elements long.
+            assert_eq!(parts.len(), 6);
+
+            Matrix {
+                a: parts[0],
+                b: parts[1],
+                c: parts[2],
+                d: parts[3],
+                e: parts[4],
+                f: parts[5]
+            }
+        }
+    }
+
     // implement string to Box
     impl From<String> for Box {
         fn from(value: String) -> Self {