LCOV - code coverage report
Current view: top level - path_parser/model/commands - 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/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 CurveToCommand extends Command {
       8           3 :   @override
       9             :   String get absoluteCommandName => 'C';
      10             : 
      11           2 :   @override
      12             :   String get relativeCommandName => 'c';
      13             : 
      14           3 :   CurveToCommand({
      15             :     String? command,
      16             :     bool? isRelative,
      17             :     required CurveToCoordinateSequence commandArguments,
      18           3 :   }) : super(
      19             :           command: command,
      20             :           isRelative: isRelative,
      21             :           commandArguments: commandArguments,
      22             :         );
      23             : 
      24           2 :   @override
      25             :   List<Command> applyTransformation(
      26             :     Matrix3 transform,
      27             :     CoordinatePair startPoint,
      28             :   ) {
      29           2 :     final Matrix3 transformationMatrix = isAbsolute
      30             :         ? transform
      31           3 :         : (transform.clone()..setColumn(2, Vector3(0.0, 0.0, 1.0)));
      32             :     final CurveToCoordinateSequence transformedCommandArguments =
      33           2 :         CurveToCoordinateSequence(
      34           2 :       coordinatePairTriplets: (commandArguments as CurveToCoordinateSequence)
      35           2 :           .coordinatePairTriplets
      36           4 :           .map((cpt) {
      37           2 :         return CoordinatePairTriplet(
      38           6 :           coordinatePairs: cpt.coordinatePairs.map((cp) {
      39             :             final Vector3 transformedCoordinates =
      40           8 :                 transformationMatrix.transform(Vector3(cp.x, cp.y, 1.0));
      41           2 :             return CoordinatePair(
      42           2 :               x: transformedCoordinates.x,
      43           2 :               y: transformedCoordinates.y,
      44             :             );
      45           2 :           }).toList(),
      46             :         );
      47           2 :       }).toList(),
      48             :     );
      49           2 :     return [
      50           2 :       CurveToCommand(
      51           2 :         command: command,
      52             :         commandArguments: transformedCommandArguments,
      53             :       ),
      54             :     ];
      55             :   }
      56             : 
      57           2 :   @override
      58             :   CoordinatePair getLastPoint(CoordinatePair startPoint) {
      59           2 :     if (isAbsolute) {
      60           2 :       return (commandArguments as CurveToCoordinateSequence)
      61           2 :           .coordinatePairTriplets
      62           2 :           .last
      63           2 :           .coordinatePairs
      64           2 :           .last;
      65             :     }
      66           1 :     double x = startPoint.x;
      67           1 :     double y = startPoint.y;
      68             :     for (final CoordinatePairTriplet cpt
      69           1 :         in (commandArguments as CurveToCoordinateSequence)
      70           2 :             .coordinatePairTriplets) {
      71           4 :       x += cpt.coordinatePairs.last.x;
      72           4 :       y += cpt.coordinatePairs.last.y;
      73             :     }
      74           1 :     return CoordinatePair(
      75             :       x: x,
      76             :       y: y,
      77             :     );
      78             :   }
      79             : 
      80           3 :   @override
      81             :   bool operator ==(Object other) {
      82           3 :     if (other is! CurveToCommand) {
      83             :       return false;
      84             :     }
      85           9 :     return command == other.command &&
      86           6 :         commandArguments as CurveToCoordinateSequence ==
      87           3 :             other.commandArguments as CurveToCoordinateSequence;
      88             :   }
      89             : 
      90           1 :   @override
      91           3 :   int get hashCode => Object.hash(command, commandArguments);
      92             : }

Generated by: LCOV version 1.15