hackathon-v-escape-4ff8b5a65aeb460d8771b7f4962482c0/frontend/node_modules/react-native-svg/apple/Utils/RNSVGMarkerPosition.mm

#import "RNSVGMarkerPosition.h"

@implementation RNSVGMarkerPosition
- (instancetype)init
{
  self = [super init];
  if (self) {
    _type = kStartMarker;
    _origin = RNSVGZEROPOINT;
    _angle = 0;
  }
  return self;
}

+ (instancetype)markerPosition:(RNSVGMarkerType)type origin:(CGPoint)origin angle:(float)angle
{
  RNSVGMarkerPosition *newElement = [[self alloc] init];
  newElement.type = type;
  newElement.origin = origin;
  newElement.angle = angle;
  return newElement;
}

+ (NSArray<RNSVGMarkerPosition *> *)fromCGPath:(CGPathRef)path
{
  positions_ = [[NSMutableArray alloc] init];
  element_index_ = 0;
  origin_ = RNSVGZEROPOINT;
  subpath_start_ = RNSVGZEROPOINT;
  CGPathApply(path, (__bridge void *)positions_, UpdateFromPathElement);
  PathIsDone();
  return positions_;
}

void PathIsDone()
{
  float angle = CurrentAngle(kEndMarker);
  [positions_ addObject:[RNSVGMarkerPosition markerPosition:kEndMarker origin:origin_ angle:angle]];
}

static double BisectingAngle(double in_angle, double out_angle)
{
  // WK193015: Prevent bugs due to angles being non-continuous.
  if (fabs(in_angle - out_angle) > 180)
    in_angle += 360;
  return (in_angle + out_angle) / 2;
}

static CGFloat RNSVG_radToDeg = 180 / (CGFloat)M_PI;

double rad2deg(CGFloat rad)
{
  return rad * RNSVG_radToDeg;
}

CGFloat SlopeAngleRadians(CGSize p)
{
  CGFloat angle = atan2(p.height, p.width);
  return angle;
}

double CurrentAngle(RNSVGMarkerType type)
{
  // For details of this calculation, see:
  // http://www.w3.org/TR/SVG/single-page.html#painting-MarkerElement
  double in_angle = rad2deg(SlopeAngleRadians(in_slope_));
  double out_angle = rad2deg(SlopeAngleRadians(out_slope_));
  switch (type) {
    case kStartMarker:
      if (auto_start_reverse_)
        out_angle += 180;
      return out_angle;
    case kMidMarker:
      return BisectingAngle(in_angle, out_angle);
    case kEndMarker:
      return in_angle;
  }
  return 0;
}

typedef struct SegmentData {
  CGSize start_tangent; // Tangent in the start point of the segment.
  CGSize end_tangent; // Tangent in the end point of the segment.
  CGPoint position; // The end point of the segment.
} SegmentData;

CGSize subtract(CGPoint *p1, CGPoint *p2)
{
  return CGSizeMake(p2->x - p1->x, p2->y - p1->y);
}

static void ComputeQuadTangents(SegmentData *data, CGPoint *start, CGPoint *control, CGPoint *end)
{
  data->start_tangent = subtract(control, start);
  data->end_tangent = subtract(end, control);
  if (CGSizeEqualToSize(CGSizeZero, data->start_tangent))
    data->start_tangent = data->end_tangent;
  else if (CGSizeEqualToSize(CGSizeZero, data->end_tangent))
    data->end_tangent = data->start_tangent;
}

SegmentData ExtractPathElementFeatures(const CGPathElement *element)
{
  SegmentData data;
  CGPoint *points = element->points;
  switch (element->type) {
    case kCGPathElementAddCurveToPoint:
      data.position = points[2];
      data.start_tangent = subtract(&points[0], &origin_);
      data.end_tangent = subtract(&points[2], &points[1]);
      if (CGSizeEqualToSize(CGSizeZero, data.start_tangent))
        ComputeQuadTangents(&data, &points[0], &points[1], &points[2]);
      else if (CGSizeEqualToSize(CGSizeZero, data.end_tangent))
        ComputeQuadTangents(&data, &origin_, &points[0], &points[1]);
      break;
    case kCGPathElementAddQuadCurveToPoint:
      data.position = points[1];
      ComputeQuadTangents(&data, &origin_, &points[0], &points[1]);
      break;
    case kCGPathElementMoveToPoint:
    case kCGPathElementAddLineToPoint:
      data.position = points[0];
      data.start_tangent = subtract(&data.position, &origin_);
      data.end_tangent = subtract(&data.position, &origin_);
      break;
    case kCGPathElementCloseSubpath:
      data.position = subpath_start_;
      data.start_tangent = subtract(&data.position, &origin_);
      data.end_tangent = subtract(&data.position, &origin_);
      break;
  }
  return data;
}

void UpdateFromPathElement(void *info, const CGPathElement *element)
{
  SegmentData segment_data = ExtractPathElementFeatures(element);
  // First update the outgoing slope for the previous element.
  out_slope_ = segment_data.start_tangent;
  // Record the marker for the previous element.
  if (element_index_ > 0) {
    RNSVGMarkerType marker_type = element_index_ == 1 ? kStartMarker : kMidMarker;
    float angle = CurrentAngle(marker_type);
    [positions_ addObject:[RNSVGMarkerPosition markerPosition:marker_type origin:origin_ angle:angle]];
  }
  // Update the incoming slope for this marker position.
  in_slope_ = segment_data.end_tangent;
  // Update marker position.
  origin_ = segment_data.position;
  // If this is a 'move to' segment, save the point for use with 'close'.
  if (element->type == kCGPathElementMoveToPoint)
    subpath_start_ = element->points[0];
  else if (element->type == kCGPathElementCloseSubpath)
    subpath_start_ = CGPointZero;
  ++element_index_;
}

NSMutableArray<RNSVGMarkerPosition *> *positions_;
unsigned element_index_;
CGPoint origin_;
CGPoint subpath_start_;
CGSize in_slope_;
CGSize out_slope_;
bool auto_start_reverse_;

@end