LCOV - code coverage report
Current view: top level - path_parser/model/commands - smooth_curve_to_command.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 43 43 100.0 %
Date: 2022-02-22 16:00:34 Functions: 0 0 -

          Line data    Source code
       1             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/coordinate_pair.dart';
       2             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/coordinate_pair_sequence.dart';
       3             : import 'package:mrx_icon_font_gen/parser/path/model/arguments/smooth_curve_to_coordinate_sequence.dart';
       4             : import 'package:mrx_icon_font_gen/parser/path/model/command.dart';
       5             : import 'package:vector_math/vector_math_64.dart';
       6             : 
       7             : class SmoothCurveToCommand extends Command {
       8           2 :   @override
       9             :   String get absoluteCommandName => 'S';
      10             : 
      11           2 :   @override
      12             :   String get relativeCommandName => 's';
      13             : 
      14           2 :   SmoothCurveToCommand({
      15             :     String? command,
      16             :     bool? isRelative,
      17             :     required SmoothCurveToCoordinateSequence commandArguments,
      18           2 :   }) : super(
      19             :           command: command,
      20             :           isRelative: isRelative,
      21             :           commandArguments: commandArguments,
      22             :         );
      23             : 
      24           1 :   @override
      25             :   List<Command> applyTransformation(
      26             :     Matrix3 transform,
      27             :     CoordinatePair startPoint,
      28             :   ) {
      29           1 :     final Matrix3 transformationMatrix = isAbsolute
      30             :         ? transform
      31           3 :         : (transform.clone()..setColumn(2, Vector3(0.0, 0.0, 1.0)));
      32             :     final SmoothCurveToCoordinateSequence transformedCommandArguments =
      33           1 :         SmoothCurveToCoordinateSequence(
      34             :       coordinatePairDoubles:
      35           1 :           (commandArguments as SmoothCurveToCoordinateSequence)
      36           1 :               .coordinatePairDoubles
      37           2 :               .map((cpd) {
      38           1 :         return CoordinatePairDouble(
      39           3 :           coordinatePairs: cpd.coordinatePairs.map((cp) {
      40             :             final Vector3 transformedCoordinates =
      41           4 :                 transformationMatrix.transform(Vector3(cp.x, cp.y, 1.0));
      42           1 :             return CoordinatePair(
      43           1 :               x: transformedCoordinates.x,
      44           1 :               y: transformedCoordinates.y,
      45             :             );
      46           1 :           }).toList(),
      47             :         );
      48           1 :       }).toList(),
      49             :     );
      50           1 :     return [
      51           1 :       SmoothCurveToCommand(
      52           1 :         command: command,
      53             :         commandArguments: transformedCommandArguments,
      54             :       ),
      55             :     ];
      56             :   }
      57             : 
      58           1 :   @override
      59             :   CoordinatePair getLastPoint(CoordinatePair startPoint) {
      60           1 :     if (isAbsolute) {
      61           1 :       return (commandArguments as SmoothCurveToCoordinateSequence)
      62           1 :           .coordinatePairDoubles
      63           1 :           .last
      64           1 :           .coordinatePairs
      65           1 :           .last;
      66             :     }
      67           1 :     double x = startPoint.x;
      68           1 :     double y = startPoint.y;
      69             :     for (final CoordinatePairDouble cpd
      70           1 :         in (commandArguments as SmoothCurveToCoordinateSequence)
      71           2 :             .coordinatePairDoubles) {
      72           4 :       x += cpd.coordinatePairs.last.x;
      73           4 :       y += cpd.coordinatePairs.last.y;
      74             :     }
      75           1 :     return CoordinatePair(
      76             :       x: x,
      77             :       y: y,
      78             :     );
      79             :   }
      80             : 
      81           2 :   @override
      82             :   bool operator ==(Object other) {
      83           2 :     if (other is! SmoothCurveToCommand) {
      84             :       return false;
      85             :     }
      86           6 :     return command == other.command &&
      87           4 :         commandArguments as SmoothCurveToCoordinateSequence ==
      88           2 :             other.commandArguments as SmoothCurveToCoordinateSequence;
      89             :   }
      90             : 
      91           1 :   @override
      92           3 :   int get hashCode => Object.hash(command, commandArguments);
      93             : }

Generated by: LCOV version 1.15