update median and averring

Author: harunlakodla

example/filter/guassian_smoothing_example.dart

@@ -1,7 +1,7 @@
 import 'dart:io';
 
 import 'package:dart_opencv_sdk/src/edge_detector/canny_edge.dart';
-import 'package:dart_opencv_sdk/src/smoothing/guassian.dart';
+import 'package:dart_opencv_sdk/src/blur/guassian.dart';
 import 'package:image/image.dart';
 
 void main(List<String> args) async {

lib/src/blur/averaging.dart

@@ -0,0 +1,65 @@
+import 'package:image/image.dart';
+import '../core/functions.dart';
+import 'blur.dart';
+
+class AveragingFilter implements SmoothFilter {
+  final CoreFunctions coreFunctions;
+  final int radius;
+  final int kernelSize;
+
+  AveragingFilter({this.radius = 2})
+      : kernelSize = radius * 2 + 1,
+        coreFunctions = CoreFunctions();
+
+  @override
+  Image applyFilter(Image image) {
+    final filteredImage = Image(width: image.width, height: image.height);
+
+    final kernel = generateKernel();
+
+    for (var y = 0; y < image.height; y++) {
+      for (var x = 0; x < image.width; x++) {
+        final filteredPixel = applyKernel(image, x, y, kernel);
+        filteredImage.setPixel(x, y,
+            ColorFloat64.rgb(filteredPixel, filteredPixel, filteredPixel));
+      }
+    }
+
+    return filteredImage;
+  }
+
+  List<List<int>> generateKernel() {
+    final kernel = List.generate(kernelSize, (_) => List.filled(kernelSize, 1));
+
+    return kernel;
+  }
+
+  int applyKernel(Image image, int x, int y, List<List<int>> kernel) {
+    num sumR = 0;
+    num sumG = 0;
+    num sumB = 0;
+
+    for (var i = -radius; i <= radius; i++) {
+      for (var j = -radius; j <= radius; j++) {
+        final pixel = coreFunctions.getPixelSafer(image, x + j, y + i);
+        final weight = kernel[i + radius][j + radius];
+        final r = pixel.r;
+        final g = pixel.g;
+        final b = pixel.b;
+
+        sumR += r * weight;
+        sumG += g * weight;
+        sumB += b * weight;
+      }
+    }
+
+    final filteredR = (sumR ~/ (kernelSize * kernelSize)).clamp(0, 255);
+    final filteredG = (sumG ~/ (kernelSize * kernelSize)).clamp(0, 255);
+    final filteredB = (sumB ~/ (kernelSize * kernelSize)).clamp(0, 255);
+
+    return coreFunctions.getColors(filteredR, filteredG, filteredB);
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}

lib/src/smoothing/smooth.dart lib/src/blur/blur.dartlib/src/smoothing/smooth.dart renamed to lib/src/blur/blur.dart

@@ -2,7 +2,7 @@ import 'package:image/image.dart';
 import 'dart:math';
 
 import '../core/functions.dart';
-import 'smooth.dart';
+import 'blur.dart';
 
 // https://docs.opencv.org/4.x/d4/d13/tutorial_py_filtering.html
 class GaussianBlurFilter implements SmoothFilter {

lib/src/smoothing/guassian.dart lib/src/blur/guassian.dartlib/src/smoothing/guassian.dart renamed to lib/src/blur/guassian.dart

@@ -0,0 +1,54 @@
+import 'package:image/image.dart';
+import '../core/functions.dart';
+import 'blur.dart';
+
+class MedianBlurFilter implements SmoothFilter {
+  final CoreFunctions coreFunctions;
+  final int radius;
+  final int kernelSize;
+
+  MedianBlurFilter({this.radius = 2})
+      : kernelSize = radius * 2 + 1,
+        coreFunctions = CoreFunctions();
+
+  @override
+  Image applyFilter(Image image) {
+    final filteredImage = Image(width: image.width, height: image.height);
+
+    for (var y = 0; y < image.height; y++) {
+      for (var x = 0; x < image.width; x++) {
+        final filteredPixel = applyMedianFilter(image, x, y);
+        filteredImage.setPixel(x, y,
+            ColorFloat64.rgb(filteredPixel, filteredPixel, filteredPixel));
+      }
+    }
+
+    return filteredImage;
+  }
+
+  int applyMedianFilter(Image image, int x, int y) {
+    final pixelValues = <int>[];
+
+    for (var i = -radius; i <= radius; i++) {
+      for (var j = -radius; j <= radius; j++) {
+        final pixel = coreFunctions.getPixelSafer(image, x + j, y + i);
+        final r = pixel.r;
+        final g = pixel.g;
+        final b = pixel.b;
+
+        final grayValue = (r + g + b) ~/ 3;
+        pixelValues.add(grayValue);
+      }
+    }
+
+    pixelValues.sort();
+
+    final medianIndex = (pixelValues.length / 2).floor();
+    final filteredValue = pixelValues[medianIndex];
+
+    return filteredValue;
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}

lib/src/blur/median.dart

@@ -2,7 +2,7 @@ import 'package:dart_opencv_sdk/src/filter/grayscale.dart';
 import 'package:image/image.dart';
 
 import '../core/functions.dart';
-import '../smoothing/guassian.dart';
+import '../blur/guassian.dart';
 import '../filter/filter.dart';
 import 'dart:math';
 

lib/src/edge_detector/canny_edge.dart

@@ -0,0 +1,6 @@
+import 'package:dart_opencv_sdk/src/core/functions.dart';
+import 'package:image/image.dart';
+
+abstract class GeometricTransform implements Image {
+  Image applyFilter(Image image);
+}

lib/src/geometric_transform/geometric_transform.dart

@@ -0,0 +1,17 @@
+import 'package:dart_opencv_sdk/src/geometric_transform/geometric_transform.dart';
+import 'package:image/image.dart';
+import 'package:image/src/image/image.dart';
+
+class RotateImage implements GeometricTransform {
+  final angle;
+
+  RotateImage({this.angle});
+
+  @override
+  Image applyFilter(Image image) {
+    return copyRotate(image, angle: angle);
+  }
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}

lib/src/geometric_transform/rotate.dart

@@ -1,16 +1,20 @@
 import 'package:dart_opencv_sdk/dart_opencv_sdk.dart';
 import 'package:test/test.dart';
 
+class ClassName {
+  ClassName name(params) {
+    return this;
+  }
+}
+
 void main() {
-  group('A group of tests', () {
-    final awesome = Awesome();
+  ClassName().name("aaa").name("Hello").name("aa");
 
+  group('A group of tests', () {
     setUp(() {
       // Additional setup goes here.
     });
 
-    test('First Test', () {
-      expect(awesome.isAwesome, isTrue);
-    });
+    test('First Test', () {});
   });
 }