如何获取任意位置的矩形，并使其在视图中居中，以及仅使用画布变换操作对其进行缩放？ [英] How can I take an rect of arbitrary positioning, and center it in the view, and scale it using only Canvas transform operations?

问题描述

我有一个矩形，可以放置在二维坐标空间的任何位置。该矩形最终将表示由许多点组成的精细路径(地图)的边界。当我绘制路径时，我不希望笔划随着地图坐标缩放，所以我打算使用Path.transform在不影响笔划的情况下进行缩放和平移。正因为如此，我希望能够仅使用画布(或转换矩阵)上的转换操作来完成此操作。

为了简化我在当前示例中仅使用RECT的问题。

我想对RET做两件事。

1. 按某个缩放值进行缩放。
2. 使矩形在视图中居中(基于Paint方法中传递的大小)。

我认为我需要在翻译时补偿比例，但我不确定如何补偿。

以下是我的完整应用程序代码，我有一些评论，希望能澄清我的意图。

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key? key}) : super(key: key);
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        // Here we take the value from the MyHomePage object that was created by
        // the App.build method, and use it to set our appbar title.
        title: Text("Custom Painter Test"),
      ),
      body: Container(
        width: double.infinity,
        height: double.infinity,
        child: CustomPaint(
          painter: MyCustomPainter(),
        ),
      ),
    );
  }
}

class MyCustomPainter extends CustomPainter {
  MyCustomPainter() : super();
  @override
  void paint(Canvas canvas, Size size) {
    var rect = Rect.fromLTRB(-14, -20 , 200.0, 80.0);
    var centerX = size.width / 2;
    var centerY = size.height / 2;
    var centeringXOffset = centerX - rect.center.dx;
    var centeringYOffset = centerY - rect.center.dy;
    var scale = 2.0;

    canvas.save();

    canvas.translate(-rect.center.dx, -rect.center.dy); // translate the rect so it is at 0,0 to scale from center of rect
    canvas.scale(scale);
    canvas.translate(rect.center.dx, rect.center.dy); // translate the rect to original position
    canvas.translate(centeringXOffset, centeringYOffset); // translate to center the rect

    // draw the rect with border
    canvas.drawRect(rect, Paint()..color = Colors.red);
    var innerRect = rect.deflate(3);
    canvas.drawRect(innerRect, Paint()..color = Colors.white.withOpacity(0.8));

    // draw the rect center point
    canvas.drawCircle(Offset(rect.center.dx,rect.center.dy) , 3.0 , Paint()..color = Colors.red);

    // draw the origincal center point of the view
    canvas.restore();
    canvas.drawCircle(Offset(centerX , centerY) , 4.0 , Paint()..color = Colors.black.withOpacity(0.32));
  }

  @override
  bool shouldRepaint(MyCustomPainter oldDelegate) => true;
}

推荐答案

在使用Matrix4接口时，您可以使用两种方法：第一种是通用矩阵乘法，这样您可以组合平移、缩放和旋转矩阵，或者直接缩放和平移矩阵，这可能有些棘手(正如您在缩放和翻译您发布的代码中的Canvas时发现的那样)

下面的代码使用这两种方法：红色使用矩阵乘法，橙色使用直接矩阵缩放和平移(请注意，对于您的特定情况，您也可以使用rectToRect2()简化方法)

// your widget code:
  final dragDetails = ValueNotifier(DragUpdateDetails(globalPosition: Offset.zero, primaryDelta: 0.0));

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onVerticalDragUpdate: (d) => dragDetails.value = d,
      child: CustomPaint(
        painter: FooPainter(dragDetails),
        child: Center(child: Text('move your finger up and down', textScaleFactor: 2)),
      ),
    );
  }

// custom painter code    
class FooPainter extends CustomPainter {
  final ValueNotifier<DragUpdateDetails> dragDetails;
  FooPainter(this.dragDetails) : super(repaint: dragDetails);

  double scale = 4.0;
  @override
  void paint(Canvas canvas, Size size) {
    final painterRect = Offset.zero & size;
    canvas.drawRect(painterRect, Paint()..color = Colors.black26);
    final center1 = Offset(size.width / 2, size.height / 3);
    final center2 = Offset(size.width / 2, size.height * 2 / 3);
    canvas.drawPoints(PointMode.lines, [
      Offset(0, center1.dy), Offset(size.width, center1.dy),
      Offset(0, center2.dy), Offset(size.width, center2.dy),
      painterRect.topCenter, painterRect.bottomCenter
    ], Paint()..color = Colors.black38);

    final scaleFactor = pow(2, -dragDetails.value.primaryDelta / 128);
    scale *= scaleFactor;
    final rect = Rect.fromLTWH(14, 20, 20, 28);
    final path = Path()
      ..fillType = PathFillType.evenOdd
      ..addOval(Rect.fromCircle(center: rect.bottomLeft, radius: 8))
      ..addRRect(RRect.fromRectAndRadius(rect, Radius.circular(3)))
      ..addOval(Rect.fromCircle(center: rect.center, radius: 3));
    Matrix4 matrix;
    Path transformedPath;

    // first solution
    final tranlationMatrix = _translate(center1 - rect.center);
    final scaleMatrix = _scale(scale, center1);
    matrix = scaleMatrix * tranlationMatrix;
    transformedPath = path.transform(matrix.storage);
    canvas.drawPath(transformedPath, Paint()..color = Colors.red);
    canvas.drawPath(transformedPath, Paint()..style = PaintingStyle.stroke ..strokeWidth = 4 ..color = Colors.white);

    // second solution
    // you can also use simplified rectToRect2() that "fills" src rect into dst one
    matrix = rectToRect(rect, Rect.fromCenter(center: center2, width: scale * rect.width, height: scale * rect.height));
    transformedPath = path.transform(matrix.storage);
    canvas.drawPath(transformedPath, Paint()..color = Colors.orange);
    canvas.drawPath(transformedPath, Paint()..style = PaintingStyle.stroke ..strokeWidth = 4 ..color = Colors.white);

    canvas.drawPath(path, Paint()..color = Colors.deepPurple);
  }

  @override
  bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}

Matrix4 _translate(Offset translation) {
  var dx = translation.dx;
  var dy = translation.dy;
  return Matrix4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, dx, dy, 0, 1);
}

Matrix4 _scale(double scale, Offset focalPoint) {
  var dx = (1 - scale) * focalPoint.dx;
  var dy = (1 - scale) * focalPoint.dy;
  return Matrix4(scale, 0, 0, 0, 0, scale, 0, 0, 0, 0, 1, 0, dx, dy, 0, 1);
}

/// Return a scaled and translated [Matrix4] that maps [src] to [dst] for given [fit]
/// aligned by [alignment] within [dst]
///
/// For example, if you have a [CustomPainter] with size 300 x 200 logical pixels and
/// you want to draw an expanded, centered image with size 80 x 100 you can do the following:
/// 
/// ```dart
///  canvas.save();
///  var matrix = sizeToRect(imageSize, Offset.zero & customPainterSize);
///  canvas.transform(matrix.storage);
///  canvas.drawImage(image, Offset.zero, Paint());
///  canvas.restore();
/// ```
/// 
///  and your image will be drawn inside a rect Rect.fromLTRB(70, 0, 230, 200)
Matrix4 sizeToRect(Size src, Rect dst, {BoxFit fit = BoxFit.contain, Alignment alignment = Alignment.center}) {
  FittedSizes fs = applyBoxFit(fit, src, dst.size);
  double scaleX = fs.destination.width / fs.source.width;
  double scaleY = fs.destination.height / fs.source.height;
  Size fittedSrc = Size(src.width * scaleX, src.height * scaleY);
  Rect out = alignment.inscribe(fittedSrc, dst);

  return Matrix4.identity()
    ..translate(out.left, out.top)
    ..scale(scaleX, scaleY);
}

/// Like [sizeToRect] but accepting a [Rect] as [src]
Matrix4 rectToRect(Rect src, Rect dst, {BoxFit fit = BoxFit.contain, Alignment alignment = Alignment.center}) {
  return sizeToRect(src.size, dst, fit: fit, alignment: alignment)
    ..translate(-src.left, -src.top);
}

Matrix4 rectToRect2(Rect src, Rect dst) {
  final scaleX = dst.width / src.width;
  final scaleY = dst.height / src.height;
  return Matrix4.identity()
    ..translate(dst.left, dst.top)
    ..scale(scaleX, scaleY)
    ..translate(-src.left, -src.top);
}

编辑

您可以进一步将rectToRect2方法简化为：

Matrix4 pointToPoint(double scale, Offset srcFocalPoint, Offset dstFocalPoint) {
  return Matrix4.identity()
    ..translate(dstFocalPoint.dx, dstFocalPoint.dy)
    ..scale(scale)
    ..translate(-srcFocalPoint.dx, -srcFocalPoint.dy);
}

并按如下方式使用：

matrix = pointToPoint(scale, rect.center, center2);

这篇关于如何获取任意位置的矩形，并使其在视图中居中，以及仅使用画布变换操作对其进行缩放？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！