颤动/Dart以相同格式重写图像

基础概念

颤动（Dithering）是一种用于在有限的颜色空间中表示更丰富颜色范围的视觉效果技术。它通过在图像中添加微小的噪声来模拟更多的颜色层次，从而减少颜色量化带来的视觉伪像。

Dart是一种由Google开发的客户端优化语言，用于构建Web、服务器、移动和物联网应用程序。

类型

颤动主要分为两种类型：

有序颤动（Ordered Dithering）：使用预定义的图案来添加噪声。
无序颤动（Random Dithering）：使用随机噪声来模拟更多的颜色层次。

应用场景

颤动技术广泛应用于图像处理、数字艺术、打印和显示设备等领域。

示例代码

以下是一个使用Dart语言实现有序颤动的示例代码：

import 'dart:ui' as ui;
import 'dart:io';
import 'package:flutter/material.dart';

class DitheredImage extends StatelessWidget {
  final String imagePath;

  DitheredImage({required this.imagePath});

  @override
  Widget build(BuildContext context) {
    return FutureBuilder<ui.Image>(
      future: _loadImage(imagePath),
      builder: (context, snapshot) {
        if (snapshot.connectionState == ConnectionState.done) {
          return CustomPaint(
            size: Size(snapshot.data!.width.toDouble(), snapshot.data!.height.toDouble()),
            painter: DitherPainter(image: snapshot.data!),
          );
        } else {
          return Center(child: CircularProgressIndicator());
        }
      },
    );
  }

  Future<ui.Image> _loadImage(String imagePath) async {
    final image = await ImageLoader.load(imagePath);
    return image;
  }
}

class DitherPainter extends CustomPainter {
  final ui.Image image;

  DitherPainter({required this.image});

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint();
    final ditherPattern = [
      0, 48, 12, 60, 3, 51, 15, 63,
      32, 16, 44, 28, 35, 19, 47, 31,
      8, 56, 4, 52, 11, 59, 7, 55,
      40, 24, 36, 20, 43, 27, 39, 23,
      2, 50, 14, 62, 1, 49, 13, 61,
      34, 18, 46, 30, 33, 17, 45, 29,
      10, 58, 6, 54, 9, 57, 5, 53,
      42, 26, 38, 22, 41, 25, 37, 21,
    ];

    final codec = await ui.instantiateImageCodec(image.toByteData(format: ui.ImageByteFormat.rawRgba)!);
    final frame = await codec.getNextFrame();
    final pixels = frame.buffer.asUint8List();

    final width = image.width;
    final height = image.height;
    final bytesPerPixel = 4;

    for (int y = 0; y < height; y += 2) {
      for (int x = 0; x < width; x += 2) {
        int index = (y * width + x) * bytesPerPixel;
        int r = pixels[index];
        int g = pixels[index + 1];
        int b = pixels[index + 2];

        int ditherIndex = ditherPattern[(y / 2) * (width / 2) + (x / 2)];
        int rDither = (r + (ditherIndex % 16) * 17) % 256;
        int gDither = (g + (ditherIndex / 16) * 17) % 256;
        int bDither = (b + (ditherIndex % 16) * 17) % 256;

        pixels[index] = rDither;
        pixels[index + 1] = gDither;
        pixels[index + 2] = bDither;
      }
    }

    final newImage = await ui.instantiateImageCodec(pixels.buffer.asUint8List());
    final newFrame = await newImage.getNextFrame();
    final newPixels = newFrame.buffer.asUint8List();

    canvas.drawImage(ui.Image.fromBytes(width, height, newPixels), Offset.zero);
  }

  @override
  bool shouldRepaint(covariant CustomPainter oldDelegate) {
    return false;
  }
}

class ImageLoader {
  static Future<ui.Image> load(String imagePath) async {
    final data = await rootBundle.load(imagePath);
    final codec = await ui.instantiateImageCodec(data.buffer.asUint8List());
    final frame = await codec.getNextFrame();
    return frame.image;
  }
}