Splitting line by angle

For now, I've calculated the angle to a north vector using python, after which I round it to an int so I can group by it when combining lines. See https://knowledge.safe.com/questions/31810/azimuth-to-compass-directionbearing.html

It's not what I wanted and doesn't work for some cases where the difference in bearing is small but the rounding creates a difference.

Python code:

import fme
import fmeobjects
import math

def processFeature(feature):
    coords = feature.getAllCoordinates()
    if len(coords) < 2:
        return
    x1, y1 = coords[0]
    x2, y2 = coords[1]
    degBearing = math.degrees(math.atan2((x2 - x1),(y2 - y1)))
    feature.setAttribute("degBearing", degBearing)

I've not done that, but I have generalized lines based on the deflection angle.

If it's greater than your maximum, then output that point.

The deflection angle for any vertex i except the start and end vertices can be calculated by taking the the minimum of the absolute value of the difference of the segment angles and their complement

DeflectionAngle = min(abs(a2-a1),360-abs(a2-a1))

a2 = degrees(atan2(Yi+1-Yi, Xi+1-Xi))

a1 = degrees(atan2(Yi-Yi-1, Xi-Xi-1))

Consider the following:

import fme
import fmeobjects
import math


class FeatureProcessor(object):
    def __init__(self):
        pass
    def input(self,feature):
        maxAngle = 10
        pts= feature.getAllCoordinates()
        
        #skip the first and last point
        for i in range(1,len(pts)-1):
            #get previous, current and next point
            p0 = pts[i-1] 
            p1 = pts[i]
            p2 = pts[i+1]
            
            # get segment angles 
            a1 = self.GetAngle(p0,p1)
            a2 = self.GetAngle(p1,p2)
            # calculate deflection between segments
            angle = min(abs(a2-a1),360-abs(a2-a1))
            #points that exceed tolerance
            if angle < maxAngle:
                feat = fmeobjects.FMEFeature(feature)
                p = fmeobjects.FMEPoint(p1[0],p1[1])
                feat.setGeometry(p)
                feat.setAttribute('DEFLECTION',angle)
                self.pyoutput(feat)
    
    def GetAngle(self,pt1, pt2):
        xDiff = pt2[0] - pt1[0]
        yDiff = pt2[1] - pt1[1]
        d = math.degrees(math.atan2(yDiff, xDiff))
        return d

    def close(self):
        pass

import fme
import fmeobjects
import math


class FeatureProcessor(object):
    def __init__(self):
        pass
    def input(self,feature):
        maxAngle = 10
        pts= feature.getAllCoordinates()
        
        #skip the first and last point
        for i in range(1,len(pts)-1):
            #get previous, current and next point
            p0 = pts[i-1] 
            p1 = pts[i]
            p2 = pts[i+1]
            
            # get segment angles 
            a1 = self.GetAngle(p0,p1)
            a2 = self.GetAngle(p1,p2)
            # calculate deflection between segments
            angle = min(abs(a2-a1),360-abs(a2-a1))
            #points that exceed tolerance
            if angle < maxAngle:
                feat = fmeobjects.FMEFeature(feature)
                p = fmeobjects.FMEPoint(p1[0],p1[1])
                feat.setGeometry(p)
                feat.setAttribute('DEFLECTION',angle)
                self.pyoutput(feat)
    
    def GetAngle(self,pt1, pt2):
        xDiff = pt2[0] - pt1[0]
        yDiff = pt2[1] - pt1[1]
        d = math.degrees(math.atan2(yDiff, xDiff))
        return d

    def close(self):
        pass

deflection = @min(@Value(_angle_between_segments), 360 - @Value(_angle_between_segments))

I altered the solution from @jdh to create the desired effect of splitting the line at those points.

import fme
import fmeobjects
import math

class FeatureProcessor(object):
    def __init__(self):
        pass
    def input(self,feature):
        maxAngle = 10
        pts= feature.getAllCoordinates()
        prev_i = 0
        
        #skip the first and last point
        for i in range(1,len(pts)-1):
            #get previous, current and next point
            p0 = pts[i-1] 
            p1 = pts[i]
            p2 = pts[i+1]
            # get segment angles 
            a1 = self.get_angle(p0,p1)
            a2 = self.get_angle(p1,p2)
            # calculate deflection between segments
            angle = min(abs(a2-a1),360-abs(a2-a1))
            #If angle exceeds maximum, output line so far
            if angle > maxAngle:
                self.output_line(feature, pts[prev_i:i+1])  # Make line from 1st coordinate up to and including i
                prev_i = i
        # Output remainder of line if a cut wasn't required
        if prev_i < len(pts)-1:
            self.output_line(feature, pts[prev_i:len(pts)])

    def output_line(self, feature, points):
        feat = fmeobjects.FMEFeature(feature)
        line = fmeobjects.FMELine(points)
        feat.setGeometry(line)
        self.pyoutput(feat)

    def get_angle(self,pt1, pt2):
        xDiff = pt2[0] - pt1[0]
        yDiff = pt2[1] - pt1[1]
        d = math.degrees(math.atan2(yDiff, xDiff))
        return d
        
    def close(self):
        pass