refactor image-sampling into filter module

Author: samizdatco

src/context/api.rs

@@ -782,22 +782,23 @@ pub fn putImageData(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 pub fn get_imageSmoothingEnabled(mut cx: FunctionContext) -> JsResult<JsBoolean> {
   let this = cx.argument::<BoxedContext2D>(0)?;
   let mut this = this.borrow_mut();
-  Ok(cx.boolean(this.state.image_smoothing_enabled))
+  // Ok(cx.boolean(this.state.image_smoothing_enabled))
+  Ok(cx.boolean(this.state.image_filter.smoothing))
 }
 
 pub fn set_imageSmoothingEnabled(mut cx: FunctionContext) -> JsResult<JsUndefined> {
   let this = cx.argument::<BoxedContext2D>(0)?;
   let mut this = this.borrow_mut();
   let flag = bool_arg(&mut cx, 1, "imageSmoothingEnabled")?;
 
-  this.state.image_smoothing_enabled = flag;
+  this.state.image_filter.smoothing = flag;
   Ok(cx.undefined())
 }
 
 pub fn get_imageSmoothingQuality(mut cx: FunctionContext) -> JsResult<JsString> {
   let this = cx.argument::<BoxedContext2D>(0)?;
   let mut this = this.borrow_mut();
-  let mode = from_filter_quality(this.state.image_filter_quality);
+  let mode = from_filter_quality(this.state.image_filter.quality);
   Ok(cx.string(mode))
 }
 
@@ -807,7 +808,7 @@ pub fn set_imageSmoothingQuality(mut cx: FunctionContext) -> JsResult<JsUndefine
   let name = string_arg(&mut cx, 1, "imageSmoothingQuality")?;
 
   if let Some(mode) = to_filter_quality(&name){
-    this.state.image_filter_quality = mode;
+    this.state.image_filter.quality = mode;
   }
   Ok(cx.undefined())
 }

src/context/mod.rs

@@ -19,7 +19,7 @@ pub mod page;
 use crate::FONT_LIBRARY;
 use crate::utils::*;
 use crate::typography::*;
-use crate::filter::Filter;
+use crate::filter::{Filter, ImageFilter, FilterQuality};
 use crate::gradient::{CanvasGradient, BoxedCanvasGradient};
 use crate::pattern::{CanvasPattern, BoxedCanvasPattern};
 use crate::texture::{CanvasTexture, BoxedCanvasTexture};
@@ -62,8 +62,7 @@ pub struct State{
 
   global_alpha: f32,
   global_composite_operation: BlendMode,
-  image_filter_quality: FilterQuality,
-  image_smoothing_enabled: bool,
+  image_filter: ImageFilter,
   filter: Filter,
 
   font: String,
@@ -105,8 +104,7 @@ impl Default for State {
 
       global_alpha: 1.0,
       global_composite_operation: BlendMode::SrcOver,
-      image_filter_quality: FilterQuality::Low,
-      image_smoothing_enabled: true,
+      image_filter: ImageFilter{ smoothing:true, quality:FilterQuality::Low },
       filter: Filter::default(),
 
       shadow_blur: 0.0,
@@ -398,15 +396,9 @@ impl Context2D{
 
   pub fn draw_image(&mut self, img:&Option<Image>, src_rect:&Rect, dst_rect:&Rect){
     let paint = self.paint_for_image();
-
-    let quality = match self.state.image_smoothing_enabled {
-      true => self.state.image_filter_quality,
-      false => FilterQuality::None
-    };
-
     if let Some(image) = &img {
       self.render_to_canvas(&paint, |canvas, paint| {
-        let sampling = to_sampling_opts(quality);
+        let sampling = self.state.image_filter.sampling();
         canvas.draw_image_rect_with_sampling_options(&image, Some((src_rect, Strict)), dst_rect, sampling, paint);
       });
     }
@@ -500,7 +492,7 @@ impl Context2D{
   pub fn paint_for_drawing(&self, style:PaintStyle) -> Paint{
     let mut paint = self.state.paint.clone();
     self.state.filter.mix_into(&mut paint, self.state.matrix, false);
-    self.state.dye(style).mix_into(&mut paint, self.state.global_alpha, self.state.image_smoothing_enabled);
+    self.state.dye(style).mix_into(&mut paint, self.state.global_alpha, self.state.image_filter);
     paint.set_style(style);
 
     if style==PaintStyle::Stroke && !self.state.line_dash_list.is_empty(){
@@ -581,7 +573,7 @@ impl Dye{
     }
   }
 
-  pub fn mix_into(&self, paint: &mut Paint, alpha: f32, smoothing: bool){
+  pub fn mix_into(&self, paint: &mut Paint, alpha: f32, image_filter: ImageFilter){
     match self {
       Dye::Color(color) => {
         let mut color:Color4f = (*color).into();
@@ -593,7 +585,7 @@ impl Dye{
              .set_alpha_f(alpha);
       },
       Dye::Pattern(pattern) =>{
-        paint.set_shader(pattern.shader(smoothing))
+        paint.set_shader(pattern.shader(image_filter))
              .set_alpha_f(alpha);
       }
       Dye::Texture(texture) =>{

src/filter.rs

@@ -2,6 +2,7 @@
 #![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
+use skia_safe::{FilterMode, MipmapMode, SamplingOptions, CubicResampler};
 use skia_safe::{Paint, Matrix, Point, Color, TileMode,  MaskFilter, BlurStyle,
                 image_filters, color_filters, table_color_filter};
 
@@ -150,4 +151,36 @@ impl Filter {
 
     paint.set_image_filter(image_filter)
   }
-}
+}
+
+#[derive(Copy, Clone)]
+pub enum FilterQuality{
+  None, Low, Medium, High
+}
+
+#[derive(Copy, Clone)]
+pub struct ImageFilter {
+  pub smoothing: bool,
+  pub quality: FilterQuality
+}
+
+impl ImageFilter {
+  pub fn sampling(&self) -> SamplingOptions {
+    let quality = if self.smoothing { self.quality } else { FilterQuality::None };
+    match quality {
+      FilterQuality::None => SamplingOptions {
+        use_cubic:false, cubic:CubicResampler{b:0.0, c:0.0}, filter:FilterMode::Nearest, mipmap:MipmapMode::None
+      },
+      FilterQuality::Low => SamplingOptions {
+        use_cubic:false, cubic:CubicResampler{b:0.0, c:0.0}, filter:FilterMode::Linear, mipmap:MipmapMode::Nearest
+      },
+      FilterQuality::Medium => SamplingOptions {
+        use_cubic:true, cubic:CubicResampler::mitchell(), filter:FilterMode::Linear, mipmap:MipmapMode::Nearest
+      },
+      FilterQuality::High => SamplingOptions {
+        use_cubic:true, cubic:CubicResampler::catmull_rom(), filter:FilterMode::Linear, mipmap:MipmapMode::Linear
+      }
+    }
+  }
+
+}

src/pattern.rs

@@ -10,8 +10,9 @@ use skia_safe::{Shader, TileMode, TileMode::{Decal, Repeat}, SamplingOptions, Si
                 Image as SkImage, Picture, Matrix, FilterMode};
 
 use crate::utils::*;
-use crate::image::{BoxedImage};
-use crate::context::{BoxedContext2D};
+use crate::image::BoxedImage;
+use crate::context::BoxedContext2D;
+use crate::filter::ImageFilter;
 
 pub type BoxedCanvasPattern = JsBox<RefCell<CanvasPattern>>;
 impl Finalize for CanvasPattern {}
@@ -31,17 +32,12 @@ pub struct CanvasPattern{
 }
 
 impl CanvasPattern{
-  pub fn shader(&self, smoothing: bool) -> Option<Shader>{
+  pub fn shader(&self, image_filter: ImageFilter) -> Option<Shader>{
     let stamp = Arc::clone(&self.stamp);
     let stamp = stamp.lock().unwrap();
 
     if let Some(image) = &stamp.image{
-      let quality = match smoothing{
-        true => FilterQuality::High,
-        false => FilterQuality::None
-      };
-
-      image.to_shader(stamp.repeat, to_sampling_opts(quality), None).map(|shader|
+      image.to_shader(stamp.repeat, image_filter.sampling(), None).map(|shader|
         shader.with_local_matrix(&stamp.matrix)
       )
     }else if let Some(pict) = &stamp.pict{

src/utils.rs

@@ -440,7 +440,7 @@ pub fn opt_path2d_arg(cx: &mut FunctionContext, idx:usize) -> Option<Path> {
 // Filters
 //
 
-use crate::filter::FilterSpec;
+use crate::filter::{FilterSpec, FilterQuality};
 
 pub fn filter_arg(cx: &mut FunctionContext, idx: usize) -> NeonResult<(String, Vec<FilterSpec>)> {
   let arg = cx.argument::<JsObject>(idx as i32)?;
@@ -473,39 +473,6 @@ pub fn filter_arg(cx: &mut FunctionContext, idx: usize) -> NeonResult<(String, V
   Ok( (canonical, filters) )
 }
 
-//
-// Skia Enums
-//
-
-use skia_safe::{TileMode, TileMode::{Decal, Repeat}};
-// pub fn to_tile_mode(mode_name:&str) -> Option<TileMode>{
-//   let mode = match mode_name.to_lowercase().as_str(){
-//     "clamp" => TileMode::Clamp,
-//     "repeat" => TileMode::Repeat,
-//     "mirror" => TileMode::Mirror,
-//     "decal" => TileMode::Decal,
-//     _ => return None
-//   };
-//   Some(mode)
-// }
-
-pub fn to_repeat_mode(repeat:&str) -> Option<(TileMode, TileMode)> {
-  let mode = match repeat.to_lowercase().as_str() {
-    "repeat" | "" => (Repeat, Repeat),
-    "repeat-x" => (Repeat, Decal),
-    "repeat-y" => (Decal, Repeat),
-    "no-repeat" => (Decal, Decal),
-    _ => return None
-  };
-  Some(mode)
-}
-
-
-#[derive(Copy, Clone)]
-pub enum FilterQuality{
-  None, Low, Medium, High
-}
-
 pub fn to_filter_quality(mode_name:&str) -> Option<FilterQuality>{
   let mode = match mode_name.to_lowercase().as_str(){
     "low" => FilterQuality::Low,
@@ -525,23 +492,21 @@ pub fn from_filter_quality(mode:FilterQuality) -> String{
   }.to_string()
 }
 
-use skia_safe::{FilterMode, MipmapMode, SamplingOptions, CubicResampler};
 
-pub fn to_sampling_opts(mode:FilterQuality) -> SamplingOptions {
-  match mode {
-    FilterQuality::None => SamplingOptions {
-      use_cubic:false, cubic:CubicResampler{b:0.0, c:0.0}, filter:FilterMode::Nearest, mipmap:MipmapMode::None
-    },
-    FilterQuality::Low => SamplingOptions {
-      use_cubic:false, cubic:CubicResampler{b:0.0, c:0.0}, filter:FilterMode::Linear, mipmap:MipmapMode::Nearest
-    },
-    FilterQuality::Medium => SamplingOptions {
-      use_cubic:true, cubic:CubicResampler::mitchell(), filter:FilterMode::Linear, mipmap:MipmapMode::Nearest
-    },
-    FilterQuality::High => SamplingOptions {
-      use_cubic:true, cubic:CubicResampler::catmull_rom(), filter:FilterMode::Linear, mipmap:MipmapMode::Linear
-    }
-  }
+//
+// Skia Enums
+//
+
+use skia_safe::{TileMode, TileMode::{Decal, Repeat}};
+pub fn to_repeat_mode(repeat:&str) -> Option<(TileMode, TileMode)> {
+  let mode = match repeat.to_lowercase().as_str() {
+    "repeat" | "" => (Repeat, Repeat),
+    "repeat-x" => (Repeat, Decal),
+    "repeat-y" => (Decal, Repeat),
+    "no-repeat" => (Decal, Decal),
+    _ => return None
+  };
+  Some(mode)
 }
 
 use skia_safe::{PaintCap};