saveMask method

Future<XFile?> saveMask()

Implementation

Future<XFile?> saveMask() async {
  try {
    if (_imageWidth == null || _imageHeight == null) return null;

    final recorder = ui.PictureRecorder();
    final canvas = Canvas(
      recorder,
      Rect.fromLTWH(0, 0, _imageWidth!, _imageHeight!),
    );

    final backgroundPaint = Paint()..color = _backgroundColor;
    canvas.drawRect(
      Rect.fromLTWH(0, 0, _imageWidth!, _imageHeight!),
      backgroundPaint,
    );

    final scaleX = _imageWidth! / (_canvasWidth ?? _imageWidth!);
    final scaleY = _imageHeight! / (_canvasHeight ?? _imageHeight!);

    final maskPaint = Paint()
      ..color = _maskColor
      ..strokeCap = StrokeCap.round
      ..strokeJoin = StrokeJoin.round
      ..style = PaintingStyle.stroke;

    for (final stroke in _strokes) {
      maskPaint.strokeWidth = stroke.size * scaleX;

      if (stroke.points.length == 1) {
        final scaledPoint = Offset(
          stroke.points.first.dx * scaleX,
          stroke.points.first.dy * scaleY,
        );
        final scaledRadius = (stroke.size / 2) * scaleX;

        canvas.drawCircle(
          scaledPoint,
          scaledRadius,
          Paint()
            ..color = _maskColor
            ..style = PaintingStyle.fill,
        );
      } else {
        final scaledPath = Path();
        final pathMetrics = stroke.path.computeMetrics();

        for (final pathMetric in pathMetrics) {
          bool isFirst = true;

          for (double distance = 0;
              distance <= pathMetric.length;
              distance += 1.0) {
            final tangent = pathMetric.getTangentForOffset(distance);
            if (tangent != null) {
              final scaledPoint = Offset(
                tangent.position.dx * scaleX,
                tangent.position.dy * scaleY,
              );

              if (isFirst) {
                scaledPath.moveTo(scaledPoint.dx, scaledPoint.dy);
                isFirst = false;
              } else {
                scaledPath.lineTo(scaledPoint.dx, scaledPoint.dy);
              }
            }
          }
        }

        canvas.drawPath(scaledPath, maskPaint);
      }
    }

    final picture = recorder.endRecording();
    final image =
        await picture.toImage(_imageWidth!.toInt(), _imageHeight!.toInt());
    final byteData = await image.toByteData(format: ui.ImageByteFormat.png);

    if (byteData != null) {
      final directory = await getTemporaryDirectory();
      final file = File(
          '${directory.path}/mask_${DateTime.now().millisecondsSinceEpoch}.png');
      await file.writeAsBytes(byteData.buffer.asUint8List());

      final maskFile = XFile(file.path);
      _onMaskSaved?.call(maskFile);
      print('Mask saved to: ${maskFile.path}');
      return maskFile;
    }
  } catch (e) {
    debugPrint('Error saving mask: $e');
  }
  return null;
}