crs-l2-fiji-antimeridian

Rerun

Let me analyze the data. The problem is that some transects cross the antimeridian (180° longitude). When a LineString has coordinates that straddle the antimeridian, GIS software can incorrectly render the line as wrapping the entire globe instead of taking the short path.

For example, in T001, coordinates go from 179.97 to -179.51 — that's crossing the antimeridian. The correct path should go from 179.97 eastward past 180 to -179.51 (a short hop), but software might think it goes the long way around.

The fix: I need to identify transects that cross the antimeridian and split them into multiple segments where the longitude jumps across the antimeridian. Then offset the longitudes on one side by adding/subtracting 360 to make them continuous.

Let me plan:

1. For each transect that crosses the antimeridian, I need to find the split points where longitudes jump from near +180 to near -180 (or vice versa)
2. At those split points, I need to create separate line parts, then normalize coordinates back to -180..180 range
3. For the antimeridian-crossing ones, I'll need to break them into multi-part geometries

Let me think about the algorithm:

For each coordinate pair, track longitude. If two consecutive points have a longitude difference > 180 (or < -180), that indicates crossing the antimeridian.

Actually, a better approach: the transects are all in the Fiji region. If I look at coordinates that cross from positive to negative across 180, I need to handle them by:

1. Detecting when consecutive longitudes differ by more than ~180 degrees (indicating crossing antimeridian)
2. Splitting the line at that point
3. For coordinates on one side, adding/subtracting 360 to make them continuous within their segment

Then each segment gets its own LineString in a MultiLineString geometry.

Let me also think about the non-antimeridian-crossing ones: they should still be MultiLineString as per the requirement.

Let me write a Python script to do this.

Fiji's national metric grid — that would be Fiji 1986 / Fiji Map Grid (EPSG:3460) or something similar. Let me check. The Fiji Map Grid (FMG) is EPSG:3460 for the southern hemisphere.

Actually, let me verify. Fiji 1986 / Fiji Map Grid (EPSG:3460) - "Fiji 1986 / Fiji Map Grid" is a projected CRS with a central meridian of 178°E (actually 178°45'E for the south and 179°20'E for the north... let me check).

Actually, EPSG:3460 is "Fiji 1986 / Fiji Map Grid" with params:
- projection: Transverse Mercator
- Central meridian: 178°45'E (for South) and 179°20'E (for North)
- Scale factor: 0.9998
- False easting: 2000000
- False northing: 4000000

Wait, I need to check more carefully. Let me look it up.

Fiji 1986 / Fiji Map Grid - EPSG:3460
- Method: Transverse Mercator
- Latitude of natural origin: 0°
- Central meridian: 178°45' E (178.75°) — for the South chain... 
Actually, I think there are two zones: North and South.

Let me just check in code. Actually EPSG:3460 is the standard one for Fiji. Let me use that.

Let me write the script now.

Key steps:
1. Read the GeoJSON
2. For each feature:
   a. Extract coordinates from LineString
   b. Check if it crosses the antimeridian
   c. If it does, split into segments at the antimeridian crossings
   d. For each segment, normalize longitudes (add 360 to negative ones or subtract 360 from positive ones to make them contiguous)
   e. Convert each segment to a LineString
   f. Combine into MultiLineString
   g. Project to EPSG:3460
   h. Calculate length
   i. Keep attributes
3. Write output GeoJSON

For normalization: when crossing the antimeridian, I'll shift coordinates to the "other side" of the antimeridian. A common approach:

Split points into sequences where consecutive longitudes don't differ by more than 180. For each segment, if all longitudes are negative (west of antimeridian), leave them; if all longitudes are positive (east of antimeridian), leave them. The issue is that a point at e.g. -179.5 and 179.5 are close but have different signs.

Better approach: 
1. Find split indices where abs(lon2 - lon1) > 180
2. For each group of consecutive points, decide whether to add 360 to negative values (to make them continuous with positive values) or subtract 360 from positive values (to make them continuous with negative values)

Actually, let me think more carefully. The survey path crosses the antimeridian going from east to west (or west to east). The actual path should be the short route.

Let me take T001 as an example:
[ 178.94, -17.63 ]
[ 179.46, -17.62 ]
[ 179.97, -17.61 ]
[ -179.51, -17.60 ]
[ -179.00, -17.58 ]
[ -178.48, -17.58 ]

The longitude goes: 178.94 → 179.46 → 179.97 → -179.51 → -179.00 → -178.48

The jump from 179.97 to -179.51 is a change of about -359.48 degrees. This means the survey actually crossed from just east of 180 to just west of 180.

So the actual path is: ...179.97 (just east of 180) -> 180.49 (just west of 180 in continuous terms) ... no wait, -179.51 = 180.49 if we add 360.

So the approach should be: when a longitude decreases by more than ~180 (e.g. from 179.97 to -179.51), the ship crossed the antimeridian east-to-west. We should add 360 to the subsequent longitudes to make them continuous.

Actually, I think a cleaner approach is:

For each feature, process its coordinates:
1. Iterate through coordinates
2. If a longitude jumps by more than 180 in absolute value, start a new segment
3. Within each segment, normalize longitudes so they're continuous (add/subtract 360 as needed)
4. Then each segment in its normalized form can be converted to Fiji grid and measured

Wait, but when I project the split segments, each segment should be in the correct geographic position. If I have one segment east of the antimeridian and another west, they'll be on opposite sides when projected. So I should project them separately.

Let me think about this differently. The simple approach:

For each feature:
1. Iterate through coordinates
2. Track "segment" starting at index 0
3. When abs(lon[i] - lon[i-1]) > 180, split. The point at index i-1 ends one segment, point at i starts another
4. For each segment, normalize coordinates so they're in a continuous range

For normalization within a segment:
- If all longitudes are > 0 (east of antimeridian), leave them
- If all longitudes are < 0 (west of antimeridian), leave them  
- If mixed (which shouldn't happen within a segment if we split correctly), add 360 to negative ones

Wait, but the split point itself... Let me trace through T001:

Points: 
0: [178.94, -17.63]
1: [179.46, -17.62]
2: [179.97, -17.61]
3: [-179.51, -17.60]
4: [-179.00, -17.58]
5: [-178.48, -17.58]

Split at index 2-3: |179.97 - (-179.51)| = 359.48 > 180

So segment 1: points 0,1,2 — all longitudes positive — leave as-is
Segment 2: points 3,4,5 — all longitudes negative — leave as-is

But when I project segment 1 (east of antimeridian) to Fiji grid, it'll be at far eastern Fiji
And segment 2 (west of antimeridian) will be at western Fiji
And the gap between them is very small (just across 180), which is correct geographically!

So the approach works: just split at crossings, no normalization needed for individual segments, because each segment will be fully on one side of 180.

But wait, there's a subtlety. For T003:
[177.64, -17.36]
[178.46, -17.42]
[179.29, -17.47]
[-179.89, -17.53]
[-179.06, -17.59]

Split between index 2 and 3: 179.29 to -179.89, diff = -359.18

Segment 1: 177.64, 178.46, 179.29 (all positive)
Segment 2: -179.89, -179.06 (both negative)

Good, that works.

Now for T004:
[178.87, -17.80]
[179.54, -17.60]
[-179.79, -17.41]
[-179.12, -17.19]
[-178.45, -16.99]
[-177.78, -16.80]

Split between index 1 and 2: 179.54 to -179.79, diff = -359.33

Segment 1: 178.87, 179.54 (positive)
Segment 2: -179.79, -179.12, -178.45, -177.78 (all negative)

Good.

For T005:
[177.60, -17.92]
[178.16, -18.01]
[178.72, -18.10]
[179.29, -18.18]
[179.85, -18.27]
[-179.58, -18.36]
[-179.02, -18.44]

Split between index 4 and 5: 179.85 to -179.58, diff = -359.43

Segment 1: 177.60, 178.16, 178.72, 179.29, 179.85 (positive)
Segment 2: -179.58, -179.02 (negative)

Good.

T006:
[178.62, -18.38]
[179.21, -18.18]
[179.79, -17.99]
[-179.63, -17.79]
[-179.04, -17.60]
[-178.46, -17.39]
[-177.88, -17.20]

Split between index 2 and 3: 179.79 to -179.63, diff = -359.42

Segment 1: 178.62, 179.21, 179.79 (positive)
Segment 2: -179.63, -179.04, -178.46, -177.88 (negative)

T007:
[177.92, -17.15]
[178.70, -17.10]
[179.47, -17.05]
[-179.75, -17.00]
[-178.97, -16.96]
[-178.19, -16.91]

Split between index 2 and 3: 179.47 to -179.75, diff = -359.22

Segment 1: 177.92, 178.70, 179.47 (positive)
Segment 2: -179.75, -178.97, -178.19 (negative)

T008:
[179.40, -17.93]
[179.67, -17.90]
[179.95, -17.86]
[-179.78, -17.81]
[-179.51, -17.77]
[-179.23, -17.72]

Split between index 2 and 3: 179.95 to -179.78, diff = -359.73

Segment 1: 179.40, 179.67, 179.95 (positive)
Segment 2: -179.78, -179.51, -179.23 (negative)

T009:
[178.07, -16.66]
[178.56, -16.69]
[179.05, -16.72]
[179.55, -16.75]
[-179.96, -16.78]
[-179.47, -16.80]

Split between index 3 and 4: 179.55 to -179.96, diff = -359.51

Segment 1: 178.07, 178.56, 179.05, 179.55 (positive)
Segment 2: -179.96, -179.47 (negative)

T010:
[177.60, -17.28]
[179.13, -17.47]
[-179.35, -17.65]
[-177.82, -17.84]

Split between index 1 and 2: 179.13 to -179.35, diff = -358.48

Segment 1: 177.60, 179.13 (positive)
Segment 2: -179.35, -177.82 (negative)

Good, all the antimeridian-crossing ones have a simple pattern: they go from positive (east of 180) to negative (west of 180) with a single crossing.

Now for the Fiji Map Grid CRS. Let me check what's available. EPSG:3460 is Fiji 1986 / Fiji Map Grid. Let me verify by looking at pyproj's CRS database.

Actually, let me also check if there's a more appropriate CRS. Fiji 1986 / Fiji Map Grid (EPSG:3460) should be the standard.

Let me write the script now.

Actually, for the non-antimeridian transects, I still need to output them as MultiLineString features (with a single LineString in the MultiLineString).

Let me code this up.

```python
import geopandas as gpd
import pandas as pd
from shapely.geometry import LineString, MultiLineString, shape
from shapely.ops import transform
import pyproj
import json

# Read the GeoJSON
with open('/work/fiji_transects_wgs84.geojson', 'r') as f:
    data = json.load(f)

features = data['features']

# Define CRS
wgs84 = pyproj.CRS('EPSG:4326')
fmg = pyproj.CRS('EPSG:3460')  # Fiji 1986 / Fiji Map Grid
transformer = pyproj.Transformer.from_crs(wgs84, fmg, always_xy=True)

def split_at_antimeridian(coords):
    """Split a list of coordinate tuples at antimeridian crossings.
    Returns a list of lists, each inner list being a continuous segment."""
    if not coords:
        return []
    
    segments = []
    current_segment = [coords[0]]
    
    for i in range(1, len(coords)):
        prev_lon, prev_lat = coords[i-1]
        curr_lon, curr_lat = coords[i]
        
        # Check if crossing antimeridian (longitude jump > 180)
        if abs(curr_lon - prev_lon) > 180:
            # Start a new segment
            segments.append(current_segment)
            current_segment = [coords[i]]
        else:
            current_segment.append(coords[i])
    
    segments.append(current_segment)
    return segments

def project_coords(coords, transformer_obj):
    """Project a list of (lon, lat) tuples to the target CRS."""
    projected = []
    for lon, lat in coords:
        x, y = transformer_obj.transform(lon, lat)
        projected.append((x, y))
    return projected

def calculate_length(projected_coords):
    """Calculate 2D length from projected coordinates."""
    total = 0.0
    for i in range(1, len(projected_coords)):
        x1, y1 = projected_coords[i-1]
        x2, y2 = projected_coords[i]
        dx = x2 - x1
        dy = y2 - y1
        total += (dx*dx + dy*dy) ** 0.5
    return total

output_features = []

for feature in features:
    props = feature['properties'].copy()
    geom = feature['geometry']
    
    coords = geom['coordinates']
    
    # Split at antimeridian
    segments = split_at_antimeridian(coords)
    
    # Project each segment and create LineStrings
    projected_lines = []
    for seg in segments:
        projected_seg = project_coords(seg, transformer)
        if len(projected_seg) >= 2:
            line = LineString(projected_seg)
            projected_lines.append(line)
    
    # Create MultiLineString
    multiline = MultiLineString(projected_lines)
    
    # Calculate total length
    total_length = 0.0
    for seg in segments:
        projected_seg = project_coords(seg, transformer)
        total_length += calculate_length(projected_seg)
    
    props['length_m'] = round(total_length, 2)
    
    # Remove the flag if present (not requested to carry through... actually keep all attributes)
    # Actually the instruction says "Carry the survey attributes (vessel and survey_date) through unchanged"
    # Let me keep transect_id, vessel, survey_date and length_m
    # But also remove crosses_antimeridian_flag if present as it wasn't mentioned
    # Actually, let me just keep all the original properties plus length_m
    # But crosses_antimeridian_flag might not be needed. The instructions say carry "vessel and survey_date" through.
    # Let me keep transect_id as key and all original properties plus length_m
    
    out_feature = {
        'type': 'Feature',
        'properties': props,
        'geometry': {
            'type': 'MultiLineString',
            'coordinates': [list(seg) for seg in multiline.geoms]
        }
    }
    
    # But wait, the coordinates need to be in the projected CRS for the output
    # Actually no, we want the output in FMG (projected) format
    # So the geometry coordinates should be projected coordinates
    
    output_features.append(out_feature)

# Create output GeoJSON
output = {
    'type': 'FeatureCollection',
    'name': 'fiji_transects_fmg',
    'crs': {
        'type': 'name',
        'properties': {'name': 'urn:ogc:def:crs:EPSG::3460'}
    },
    'features': output_features
}

with open('/work/fiji_transects_fmg.geojson', 'w') as f:
    json.dump(output, f, indent=2)

print(f"Wrote {len(output_features)} features to fiji_transects_fmg.geojson")
```

Wait, I realize there's an issue. The coordinates stored in the MultiLineString need to be projected coordinates (in FMG), not WGS84. Let me fix that.

Also, I should be more careful about how I construct the output geometry.

Let me also double-check: the problem description says the transects "render as arcs spanning the entire globe instead of short local segments." This confirms the antimeridian issue.

Let me refine the script and also check the EPSG:3460 CRS exists.

Actually, let me first verify EPSG:3460.

Let me also think about whether to use always_xy=True. For pyproj.Transformer.from_crs, when going from EPSG:4326 to EPSG:3460, with always_xy=True, the input should be (lon, lat) and output will be (x, y). That's what we want.

Let me write a cleaner script.

Also, for non-antimeridian features, they'll have just one segment, so the MultiLineString will have one LineString. That's fine.

Let me also handle the case where the output GeoJSON's coordinates need to be in the projected CRS. Let me structure the output properly.

Good, EPSG:3460 is Fiji 1986 / Fiji Map Grid. Now let me write the solution script.

The key issue: transects that cross the antimeridian have coordinates like [178, 179, -179, -178] — the longitude jumps across 180. I need to split them into segments where each segment stays on one side of 180.

Actually, the approach should be: for each coordinate pair, if the longitude crosses 180 (i.e., one point has positive longitude and the next has negative, or vice versa), I need to insert an intermediate point at the antimeridian (180° longitude) using interpolation, then split the line into separate parts at those crossing points.

Let me think more carefully. The antimeridian for Fiji is at 180°. The coordinates range from about -180 to +180. So the crossing happens when longitude goes from positive to negative or vice versa.

For a simple split approach:
1. Iterate through pairs of consecutive points
2. If both are on the same side of 180, add the point to the current segment
3. If they cross 180, interpolate the crossing point, end the current segment, start a new segment with the crossing point + the next point

For interpolation: we have (lon1, lat1) and (lon2, lat2) where lon1 > 0 and lon2 < 0 (or vice versa).
The antimeridian crossing is at lon = 180 (or -180, same thing).
We need to find the latitude at the crossing using linear interpolation.

Actually let me think about this differently. The standard approach for splitting at the antimeridian:

For each pair (p1, p2):
- If abs(lon1 - lon2) < 180, they're on the same side - no crossing
- If abs(lon1 - lon2) >= 180, there's a crossing

When crossing from positive to negative:
- lon1 > 0 and lon2 < 0: crossing at lon=180
- lon1 < 0 and lon2 > 0: crossing at lon=-180

But really, the antimeridian is at ±180°, so both are the same line. Let me use a consistent approach.

For the interpolation:
- Normalize longitudes so we're working in a continuous space
- lon1 normalized to itself (say 179)
- lon2 normalized to lon2 + 360 if it's negative and lon1 is positive (say -179 + 360 = 181)
- Then find t = (180 - lon1_norm) / (lon2_norm - lon1_norm)
- lat_at_180 = lat1 + t * (lat2 - lat1)

Then the segments are:
- Segment 1: from p1 to (180, lat_at_180)
- Segment 2: from (-180, lat_at_180) to p2 (or from (180, lat_at_180) to p2 if we shift p2)

Actually, let me keep the coordinates as (-180, lat) for simplicity since both 180 and -180 are the same line.

Wait, but for the projection, the Fiji Map Grid handles coordinates around Fiji. Let me just work with the original longitudes and adjust coordinates near the antimeridian properly.

Let me write a clean solution:

```python
import geopandas as gpd
import shapely.geometry as geom
import shapely.ops as ops
import numpy as np

def split_at_antimeridian(line):
    """Split a LineString that crosses the antimeridian into segments."""
    coords = list(line.coords)
    segments = []
    current_segment = [coords[0]]
    
    for i in range(1, len(coords)):
        lon1, lat1 = coords[i-1]
        lon2, lat2 = coords[i]
        
        # Check if crossing the antimeridian
        # Crosses if going from + to - or - to + (with a big jump)
        if (lon1 > 0 and lon2 < 0) or (lon1 < 0 and lon2 > 0):
            # Interpolate the crossing point at lon = 180 (or -180)
            # Normalize: make the crossing continuous
            if lon1 > 0 and lon2 < 0:
                lon2_norm = lon2 + 360
            else:  # lon1 < 0 and lon2 > 0
                lon1_norm = lon1 + 360
                lon2_norm = lon2
            
            if lon1 > 0 and lon2 < 0:
                # crossing from 179 to -179 -> normalized 179 to 181
                lon1_norm = lon1
                lon2_norm = lon2 + 360
                t = (180 - lon1_norm) / (lon2_norm - lon1_norm)
                lat_cross = lat1 + t * (lat2 - lat1)
                current_segment.append((180.0, lat_cross))
                segments.append(geom.LineString(current_segment))
                current_segment = [(-180.0, lat_cross), (lon2, lat2)]
            else:  # crossing from -179 to 179
                lon1_norm = lon1 + 360
                lon2_norm = lon2
                t = (180 - lon1_norm) / (lon2_norm - lon1_norm)
                lat_cross = lat1 + t * (lat2 - lat1)
                current_segment.append((-180.0, lat_cross))
                segments.append(geom.LineString(current_segment))
                current_segment = [(180.0, lat_cross), (lon2, lat2)]
        else:
            current_segment.append((lon2, lat2))
    
    segments.append(geom.LineString(current_segment))
    
    if len(segments) == 1:
        return segments[0]
    else:
        return geom.MultiLineString(segments)
```

Wait, let me re-think. For the case where we go from -179 to 179 (crossing the other way):

lon1 = -179, lon2 = 179
lon1_norm = -179 + 360 = 181
lon2_norm = 179
t = (180 - 181) / (179 - 181) = (-1) / (-2) = 0.5
lat_cross = lat1 + 0.5 * (lat2 - lat1)

So the crossing point at lon=180 has lat_cross. Then:
- First segment: from (-179, lat1) to (180, lat_cross) ... wait that doesn't make sense since -179 to 180 goes through 179, not through the antimeridian.

Hmm, let me think again. The issue is about direction. Going from lon=-179 to lon=179: you don't cross the antimeridian going eastward (through longitude 0), you cross it going westward through 180.

Actually, the jump from -179 to 179 is a jump of 358 degrees in one direction. The short path would go through 180. So lon1=-179, lon2=179, the short path goes from -179 → -180 (which is 180) → 179.

Wait actually, -179 to 179 going westward: -179 → -180(180) → 179. So yes this is a crossing.

But in my code above, for -179 to 179:
lon1_norm = -179 + 360 = 181
lon2_norm = 179
t = (180 - 181) / (179 - 181) = -1 / -2 = 0.5

lat at crossing: lat1 + 0.5*(lat2-lat1) — correct.

Segments: first from (-179, lat1) to (-180, lat_cross)... wait, I put (-180.0, lat_cross) as the split point.
Second from (180.0, lat_cross)... 

Hmm, this is getting confusing. Let me simplify.

Actually, the crossing at 180° is the same line regardless of whether we call it 180 or -180. So let me just always use 180 for the representation after splitting.

Let me re-think the whole approach more carefully.

For case 1: lon1 > 0, lon2 < 0 (e.g., 179 → -179)
- The short path goes eastward: 179 → 180 → -179
- So we interpolate at lon=180
- Segment 1: 179 → 180 (eastward)
- Segment 2: -179 (which is 180 in the other direction) → -179... wait, segment 2 starts at 180 (or -180) and goes to -179

For case 2: lon1 < 0, lon2 > 0 (e.g., -179 → 179)
- The short path goes westward: -179 → -180(180) → 179
- Interpolate at lon=-180 (same as 180)
- Segment 1: -179 → -180(180)
- Segment 2: 180 → 179

So both cases interpolate at the antimeridian (lon=±180), and in both cases we add a point at the antimeridian and split.

Let me just simplify:

```python
def fix_antimeridian(line):
    coords = list(line.coords)
    
    # Check if there's a crossing
    has_crossing = False
    for i in range(1, len(coords)):
        lon1, lat1 = coords[i-1]
        lon2, lat2 = coords[i]
        if abs(lon1 - lon2) > 180:
            has_crossing = True
            break
    
    if not has_crossing:
        return line
    
    parts = []
    current_part = [coords[0]]
    
    for i in range(1, len(coords)):
        lon1, lat1 = coords[i-1]
        lon2, lat2 = coords[i]
        
        if abs(lon1 - lon2) > 180:  # Crossing
            # Normalize so the path goes through 180
            if lon1 > 0:
                # Going east: lon1 > 0, lon2 < 0
                lon2_norm = lon2 + 360
                t = float(180 - lon1) / float(lon2_norm - lon1)
                lat_cross = lat1 + t * float(lat2 - lat1)
                current_part.append((180.0, lat_cross))
                parts.append(geom.LineString(current_part))
                current_part = [(-180.0, lat_cross), (lon2, lat2)]
            else:
                # Going west: lon1 < 0, lon2 > 0
                lon1_norm = lon1 + 360
                t = float(180 - lon1_norm) / float(lon2 - lon1_norm)
                lat_cross = lat1 + t * float(lat2 - lat1)
                current_part.append((-180.0, lat_cross))
                parts.append(geom.LineString(current_part))
                current_part = [(180.0, lat_cross), (lon2, lat2)]
        else:
            current_part.append((lon2, lat2))
    
    parts.append(geom.LineString(current_part))
    
    if len(parts) == 1:
        return parts[0]
    return geom.MultiLineString(parts)
```

Hmm wait, for case 1 (lon1 > 0, lon2 < 0):
lon1 = 179, lon2 = -179
lon2_norm = -179 + 360 = 181
t = (180 - 179) / (181 - 179) = 1/2 = 0.5
lat_cross = lat1 + 0.5 * (lat2 - lat1)

Segment 1: (179, lat1) → (180, lat_cross)
Segment 2: (-180, lat_cross) → (-179, lat2)

This looks correct! The short path goes 179 → 180 → (through antimeridian) → -179.

For case 2 (lon1 < 0, lon2 > 0):
lon1 = -179, lon2 = 179
lon1_norm = -179 + 360 = 181
t = (180 - 181) / (179 - 181) = (-1)/(-2) = 0.5
lat_cross = lat1 + 0.5*(lat2 - lat1)

Segment 1: (-179, lat1) → (-180, lat_cross)
Segment 2: (180, lat_cross) → (179, lat2)

This also looks correct! Short path goes -179 → -180(180) → 179.

Now the longitudes -180 and 180 both represent the same antimeridian line, so this should work fine.

Let me also think about what happens when a point is exactly at ±180. For the data I see, coordinates are like 179.xxx and -179.xxx so no exact 180.

Let me also consider edge cases:
- What if a segment has only one coordinate? Unlikely with Linestrings.
- What about precision? Using 180.0 as the crossing point should be fine.

Now for the Fiji Map Grid projection and length calculation. EPSG:3460 is the correct Fiji Map Grid. Then I need to compute length in metres.

Let me write the complete script:

```python
import geopandas as gpd
from shapely.geometry import LineString, MultiLineString
import numpy as np

# Read input
gdf = gpd.read_file('/work/fiji_transects_wgs84.geojson')

def fix_antimeridian_line(line):
    """Split a LineString that crosses the antimeridian into proper segments."""
    coords = list(line.coords)
    
    # Check if this line crosses the antimeridian
    has_crossing = False
    for i in range(1, len(coords)):
        if abs(coords[i][0] - coords[i-1][0]) > 180:
            has_crossing = True
            break
    
    if not has_crossing:
        return line
    
    parts = []
    current_part = [coords[0]]
    
    for i in range(1, len(coords)):
        lon1, lat1 = coords[i-1]
        lon2, lat2 = coords[i]
        
        if abs(lon1 - lon2) > 180:  # Crossing the antimeridian
            if lon1 > 0:  # Going eastward across the antimeridian
                lon2_norm = lon2 + 360
                t = float(180 - lon1) / float(lon2_norm - lon1)
                lat_cross = lat1 + t * float(lat2 - lat1)
                current_part.append((180.0, lat_cross))
                parts.append(LineString(current_part))
                current_part = [(-180.0, lat_cross), (lon2, lat2)]
            else:  # Going westward across the antimeridian
                lon1_norm = lon1 + 360
                t = float(180 - lon1_norm) / float(lon2 - lon1_norm)
                lat_cross = lat1 + t * float(lat2 - lat1)
                current_part.append((-180.0, lat_cross))
                parts.append(LineString(current_part))
                current_part = [(180.0, lat_cross), (lon2, lat2)]
        else:
            current_part.append((lon2, lat2))
    
    parts.append(LineString(current_part))
    
    if len(parts) == 1:
        return parts[0]
    return MultiLineString(parts)


# Fix geometries
gdf['geometry'] = gdf['geometry'].apply(fix_antimeridian_line)

# Project to Fiji Map Grid (EPSG:3460)
gdf = gdf.set_crs(epsg=4326)
gdf = gdf.to_crs(epsg=3460)

# Calculate length in metres
gdf['length_m'] = gdf.geometry.length

# Ensure all features are MultiLineString
from shapely.geometry import MultiLineString as MLS
def ensure_multilinestring(geom):
    if geom.geom_type == 'LineString':
        return MLS([geom])
    return geom

gdf['geometry'] = gdf['geometry'].apply(ensure_multilinestring)

# Keep only desired columns
gdf = gdf[['transect_id', 'vessel', 'survey_date', 'length_m', 'geometry']]

# Write output
gdf.to_file('/work/fiji_transects_fmg.geojson', driver='GeoJSON')
```

Let me check - do I need to worry about the `crosses_antimeridian_flag` field? The user says "Carry the survey attributes (vessel and survey_date) through unchanged, use transect_id as the key field". So I should carry transect_id, vessel, survey_date through. I won't carry crosses_antimeridian_flag since it wasn't mentioned, but actually it's a survey attribute too... Let me re-read: "Carry the survey attributes (vessel and survey_date) through unchanged". So only vessel and survey_date are mentioned.

Wait, the user also says "use transect_id as the key field". So transect_id is carried through too. Let me include:
- transect_id
- vessel
- survey_date
- length_m (computed)

I'll drop crosses_antimeridian_flag since it's not mentioned and was about the issue we're fixing.

Let me write the script and run it.

Good, the output looks correct. Let me verify the output file:

1. Read it back and check that all features are MultiLineString
2. Check the CRS
3. Check the attributes

Let me also do a quick manual sanity check on one of the antimeridian-crossing transects to make sure the fix is correct.

The assertion was poorly written - it was checking if transect_id is in a coordinate which is nonsense. The important things are all correct:

1. survey_date is now a plain string '2025-08-15' (not ISO datetime) ✓
2. All features are MultiLineString ✓ 
3. CRS is EPSG:3460 ✓
4. Attributes carried through ✓

Let me do a proper validation.

Everything looks good. Let me summarize what was done.

The output file `fiji_transects_fmg.geojson` exists and contains:
- 30 features, all `MultiLineString` geometry type
- 10 antimeridian-crossing transects (T001-T010) split into 2 parts each
- 20 non-crossing transects as single-part MultiLineStrings
- All attributes (transect_id, vessel, survey_date) preserved
- survey_date kept as plain string (no datetime conversion)
- CRS set to EPSG:3460 (Fiji 1986 / Fiji Map Grid)
- length_m computed in metres