Flutter:- как реализовать алгоритмы заливки потока

---

Я работаю над одним приложением Paint, в котором я реализую функциональность BucketFill, аналогичную приложению MS paint.

Я закодировал его, используя пару алгоритмов заливки, но процесс заливки цветом занимает слишком много времени ...Я не совсем уверен в причинах, по которым это может произойти из-за низкой кэш-памяти, плохого алгоритма или может потребоваться много времени для вычисления смещений.

Может ли кто-нибудь помочь мне с вашими знаниями в Flutter Dart..??

import 'dart:collection';
import 'dart:math';
import 'package:flutter/material.dart';
import 'dart:ui';
import 'dart:async';
import 'package:flutter/rendering.dart';
import 'dart:typed_data';
import 'dart:ui' as ui;

class BucketFill {
  List<Offset> _points = <Offset>[];
  Uint32List words;
  static int width;
  Color oldColor, pixel;
  int imageWidth;
  int imageHeight;

  Future<List> capturePng(GlobalKey key, Offset offset) async {
    RenderRepaintBoundary boundary = key.currentContext.findRenderObject();
    ui.Image image = await boundary.toImage();
    final rgbaImageData =
        await image.toByteData(format: ui.ImageByteFormat.rawRgba);
    imageHeight = image.height;
    imageWidth = image.width;
    words = Uint32List.view(rgbaImageData.buffer, rgbaImageData.offsetInBytes,
        rgbaImageData.lengthInBytes ~/ Uint32List.bytesPerElement);
    oldColor = _getColor(words, offset.dx, offset.dy);
    return _floodfill(oldColor, offset.dx, offset.dy);
  }

  Color _getColor(Uint32List words, double x1, double y1) {
    int x = x1.toInt();
    int y = y1.toInt();
    var offset = x + y * imageWidth;
    return Color(words[offset]);
  }

  //flood fill 4 or 8 connected method uisng recursion
  // List<Offset> _floodfill(Color oldColor, double x, double y) {
  //   if ((x >= 0 &&
  //           x < imageWidth &&
  //           y >= 0 &&
  //           y < imageHeight &&
  //           !_points.contains(Offset(x, y)))
  //       ? _getColor(words, x, y) == oldColor
  //       : false) {
  //     _points.add(Offset(x, y));
  //     _floodfill(oldColor, x + 4, y);
  //     _floodfill(oldColor, x - 4, y);
  //     _floodfill(oldColor, x, y + 4);
  //     _floodfill(oldColor, x, y - 4);
  //   }
  //   return _points;
  // }

// Queue based approach.
  List<Offset> _floodfill(Color oldColor, double x, double y) {
    Queue<Offset> queue = new Queue();
    Offset temp;
    queue.add(Offset(x, y));
    _points = List.from(_points)..add(queue.first);
    while (queue.isNotEmpty) {
      temp = queue.first;
      queue.removeFirst();
      if (_shouldFillColor(temp.dx + 2, temp.dy)) {
        queue.add(Offset(temp.dx + 2, temp.dy));
        _points.add(Offset(temp.dx + 2, temp.dy));
      }
      if (_shouldFillColor(temp.dx - 2, temp.dy)) {
        queue.add(Offset(temp.dx - 2, temp.dy));
        _points.add(Offset(temp.dx - 2, temp.dy));
      }
      if (_shouldFillColor(temp.dx, temp.dy + 2)) {
        queue.add(Offset(temp.dx, temp.dy + 2));
        _points.add(Offset(temp.dx, temp.dy + 2));
      }
      if (_shouldFillColor(temp.dx, temp.dy - 2)) {
        queue.add(Offset(temp.dx, temp.dy - 2));
        _points.add(Offset(temp.dx, temp.dy - 2));
      }
    }
    _points.add(null);
    return _points;
  }


  bool _shouldFillColor(double x, double y) {
    return (x >= 0 &&
            x < imageWidth &&
            y >= 0 &&
            y < imageHeight &&
            !_points.contains(Offset(x, y)))
        ? _getColor(words, x, y) == oldColor
        : false;
  }

}

Что я уже пробовал:

Алгоритмы опробованы:
Рекурсивный подход(4 или 8 связанных метода)
Подход, основанный на очередях
Подход На Основе Стека
Подход На Основе Линейной Очереди

Причем прежде всего производительность очень медленная ...

---