Referencia

Adattípusok

A portokon utazó közös adattípusok (Kofa.Abstractions.DataTypes). Két port akkor köthető, ha a típusazonosító és a főverzió egyezik. A mezők leírása a kód XML-dokumentációjából származik (angolul).

Megjegyzés

A konvenciók: SI mértékegységek, a szögek radiánban, a normalizált vezérlőjelek [-1, 1] vagy [0, 1] tartományban. Lásd: Portok és adattípusok.

Áttekintés

Azonosító	Típus	Leírás
`kofa.actuator.channels/1`	`ActuatorChannels`	Per-channel actuator outputs, each in [-1, 1].
`kofa.attitude/1`	`Attitude`	Tait–Bryan angles (yaw → pitch → roll). Yaw follows the compass convention of `Motion.HeadingRad`.
`kofa.battery/1`	`BatteryState`
`kofa.bool/1`	`BoolValue`
`kofa.camera.frame/1`	`CameraFrame`	Camera image. `CameraFrame.Data` is shared between receivers and must not be modified.
`kofa.camera.labels/1`	`CameraLabels`	Ground truth of a camera image (only a simulator has it): what each part of the image really is, rendered from the very pose of the frame `CameraFrameId`. It tells a real obstacle from a false one when a vision model is recorded or trained.
`kofa.depth-map/1`	`DepthMap`	The known water depth on a grid around the boat and its route: what a nautical chart tells before the boat gets there. Produced by the map (imported charts, a modelled lake bed, the boat's own soundings); consumed by route planning and the sailing pilot, which add the depth sounder's corrections. Cell (col, row) covers east [`DepthMap.OriginEastM` + col·`DepthMap.CellM`, +`DepthMap.CellM`) and north likewise from `DepthMap.OriginNorthM`, in flat-earth metres around `DepthMap.Origin`; row 0 is the southern edge.
	`kofa.drive.command/1`	`DriveCommand`
	`kofa.geo.position/1`	`GeoPosition`	WGS84 position. Exception to the radian rule: latitude / longitude are in degrees.
	`kofa.guide/1`	`Guide`	What the reference driver (the lane guide) wants at this moment: the path along the sidewalk, or else along the left edge of the road, and the ground truth the AI planner is trained on.
	`kofa.imu/1`	`ImuSample`	Inertial sample in the body frame X forward, Y left, Z up (ROS REP 103).
	`kofa.json/1`	`JsonValue`	Escape hatch for untyped data. Only links to other `kofa.json` ports.
	`kofa.link/1`	`LinkStatus`
	`kofa.log/1`	`LogEntry`
	`kofa.motion/1`	`Motion`
	`kofa.occupancy/1`	`Occupancy`	What stands around the vehicle (simulator ground truth): a bird's-eye height map in the vehicle frame, laid out like `SceneGrid` (row 0 is the nearest ahead, column 0 the leftmost). A real vehicle has no such sensor: it labels the training of the obstacle perception.
	`kofa.pose3/1`	`Pose3`	Pose in a local frame (meters), e.g. simulator world coordinates.
	`kofa.ranges/1`	`RangeReadings`	Readings of the distance sensors of a vehicle, sampled together.
	`kofa.roadmap/1`	`RoadMap`	Navigable map: a graph of streets, sidewalks, crosswalks and paths with addresses and named areas. Produced by the simulator (its generated city) or from OpenStreetMap; consumed by navigators and map views. Local meters are relative to `RoadMap.Origin` (flat-earth, east-north-up).
	`kofa.route/1`	`Route`
	`kofa.sail.advice/1`	`SailAdvice`	One instruction for a crew sailing the boat by hand (the sail advisor): what to do now, and the sail / rudder position it aims for (the 3D view draws that). A new instruction has a new `Sequence`; `Speak` says it is worth saying aloud.
	`kofa.sail.command/1`	`SailCommand`
	`kofa.sailboat.specs/1`	`SailboatSpecs`	Dimensions and current sail configuration of a sailboat, metric (m, m², kg). Published by the boat specs Komod for the 3D view (model scaling) and the sailing AI (forces, limits). Unknown values are null.
	`kofa.scalar/1`	`Scalar`	Generic measurement, e.g. for plots.
	`kofa.scene/1`	`Scene`	The world as the planner sees it (for viewers): the planned path, the semantic bird's-eye grid and obstacles.
	`kofa.text/1`	`TextValue`
	`kofa.trigger/1`	`Trigger`	Event without payload: e-stop, reset.
	`kofa.vision.detections/1`	`Detections`
	`kofa.waterway/1`	`Waterway`	The water around a sailboat: water areas and islands (outlines), piers and breakwaters, and the marks of the course, the start, the harbours with their berths and mooring buoys. Produced by the simulator (generated lake or the real map's water) or from OpenStreetMap; consumed by map views, sailing pilots and the training rewards. Local metres are relative to `Waterway.Origin` (flat earth).
	`kofa.wind/1`	`Wind`
	`kofa.world.plan/1`	`WorldPlan`	What a navigator plans in the seen world (world frame), for viewers.
	`kofa.world.trace/1`	`WorldTrace`	The build data of one frame of the seen world (only while asked, e.g. while a recorder records): what each camera saw and every obstacle the frame put into the world with its source pixel. With the ground truth of the same images it tells which pixel made a false obstacle (and how: segmentation, stereo, foot), and which real obstacle did not get into the world.
	`kofa.world.view/1`	`WorldView`	The seen world for a 3D viewer: a coarser grid with colors, the 3D points the cameras measured, the vehicle and the plan. `WorldView.Points`: `WorldView.PointSize` bytes per point: east, north, up as little-endian int16 centimeters relative to the grid origin (up: above the ground), then R, G, B.
	`kofa.world/1`	`WorldMap`	The seen world around the vehicle and where the vehicle is in it: what a navigator plans on.

Típusok

ActuatorChannels

Azonosító: kofa.actuator.channels/1 · C# típus: Kofa.Abstractions.DataTypes.ActuatorChannels

Per-channel actuator outputs, each in [-1, 1].

Mező	Típus	Leírás
`Values`	`IReadOnlyList<double>`

Attitude

Azonosító: kofa.attitude/1 · C# típus: Kofa.Abstractions.DataTypes.Attitude

Tait–Bryan angles (yaw → pitch → roll). Yaw follows the compass convention of Motion.HeadingRad.

Mező	Típus	Leírás
`RollRad`	`double`
`PitchRad`	`double`
`YawRad`	`double`

BatteryState

Azonosító: kofa.battery/1 · C# típus: Kofa.Abstractions.DataTypes.BatteryState

Mező	Típus	Leírás
`VoltageV`	`double`
`CurrentA`	`double?`
`StateOfCharge`	`double?`	[0, 1].

BoolValue

Azonosító: kofa.bool/1 · C# típus: Kofa.Abstractions.DataTypes.BoolValue

Mező	Típus	Leírás
`Value`	`bool`

CameraFrame

Azonosító: kofa.camera.frame/1 · C# típus: Kofa.Abstractions.DataTypes.CameraFrame

Camera image. CameraFrame.Data is shared between receivers and must not be modified.

Mező	Típus	Leírás
`FrameId`	`long`
`Width`	`int`
`Height`	`int`
`Format`	`CameraFrameFormat`
`Data`	`ReadOnlyMemory<byte>`

CameraLabels

Azonosító: kofa.camera.labels/1 · C# típus: Kofa.Abstractions.DataTypes.CameraLabels

Ground truth of a camera image (only a simulator has it): what each part of the image really is, rendered from the very pose of the frame CameraFrameId. It tells a real obstacle from a false one when a vision model is recorded or trained.

Mező	Típus	Leírás
`Camera`	`int`	Which camera of the producer: 0 = its `camera` output, 1 = `camera2`, 2 = `camera3`, 3 = `camera4`.
`CameraFrameId`	`long`	The `CameraFrame.FrameId` of the image the mask belongs to.
`CapturedAtMs`	`long`	When the mask was rendered (the producer's clock, ms).
`Width`	`int`	Mask width in cells; the mask covers the whole image (usually smaller than the image).
`Height`	`int`	Mask height in cells.
`MaskPng`	`ReadOnlyMemory<byte>`	PNG, RGBA: red = class id (see `ClassesJson`; Simulator_V2: 0 sky, 1 water, 2 land, 3 structure, 4 buoy, 5 own vehicle, 6 obstacle, 7 vehicle, 10+ water agents such as swimmers and boats), green = object index (1-based into `ObjectsJson`, 0 = none).
`ObjectsJson`	`string?`	Optional JSON array of the objects in the image (id, type, classId, box, distance).
`ClassesJson`	`string?`	Optional JSON array of the class legend (id, name).

DepthMap

Azonosító: kofa.depth-map/1 · C# típus: Kofa.Abstractions.DataTypes.DepthMap

The known water depth on a grid around the boat and its route: what a nautical chart tells before the boat gets there. Produced by the map (imported charts, a modelled lake bed, the boat's own soundings); consumed by route planning and the sailing pilot, which add the depth sounder's corrections. Cell (col, row) covers east [DepthMap.OriginEastM + col·DepthMap.CellM, +DepthMap.CellM) and north likewise from DepthMap.OriginNorthM, in flat-earth metres around DepthMap.Origin; row 0 is the southern edge.

Mező	Típus	Leírás
`Origin`	`GeoPosition`
`OriginEastM`	`double`
`OriginNorthM`	`double`
`Cols`	`int`
`Rows`	`int`
`CellM`	`double`
`Depths`	`ReadOnlyMemory<byte>`	Cols × Rows little-endian 16 bit depths in centimetres, row by row; `DepthMap.NoDepth` = not known (land or no data).
`Quality`	`ReadOnlyMemory<byte>`	Cols × Rows `DepthQuality` bytes.
`WaterLevelOffsetM`	`double`	The water level now above the level the depths refer to (m): the depth at a place is the stored one plus this.
`Version`	`long`	Changes when the depths, the window or the water level change.
`Source`	`string`	Short list of the layers in it, e.g. "survey, balaton.tif, GLOBathy".

DriveCommand

Azonosító: kofa.drive.command/1 · C# típus: Kofa.Abstractions.DataTypes.DriveCommand

Mező	Típus	Leírás
`Steering`	`double`	[-1, 1], negative = left.
`Throttle`	`double`	[-1, 1], negative = reverse.
`Brake`	`double`	[0, 1].
`Gear`	`int?`

GeoPosition

Azonosító: kofa.geo.position/1 · C# típus: Kofa.Abstractions.DataTypes.GeoPosition

WGS84 position. Exception to the radian rule: latitude / longitude are in degrees.

Mező	Típus	Leírás
`LatDeg`	`double`
`LonDeg`	`double`
`AltM`	`double?`
`AccuracyM`	`double?`

Guide

Azonosító: kofa.guide/1 · C# típus: Kofa.Abstractions.DataTypes.Guide

What the reference driver (the lane guide) wants at this moment: the path along the sidewalk, or else along the left edge of the road, and the ground truth the AI planner is trained on.

Mező	Típus	Leírás
`Sequence`	`long`
`Intent`	`DriveIntent`
`DistanceToJunctionM`	`double?`	Distance to the next route junction, null when none is near.
`Path`	`IReadOnlyList<PathPoint>`	Reference path ahead (about 0.25 m apart, up to ~8 m), in the vehicle frame.
`LateralOffsetM`	`double`	Where the vehicle is relative to the reference path (left positive).
`HeadingErrorRad`	`double`	Vehicle heading minus path direction (left positive).
`ProgressM`	`double`
`RouteLengthM`	`double`
`Grid`	`SceneGrid?`	Ground truth from the map (road / sidewalk / ground around the vehicle), when requested.
`Surface`	`string?`	"road", "sidewalk" or "ground": what the vehicle stands on according to the map.
`OnSidewalkPolicy`	`bool`
`RightEdge`	`bool`	The lane policy keeps to the right edge of the road (false: the left edge).
`Arrived`	`bool`	An open route (no loop) has reached its end: the vehicle should stop.

ImuSample

Azonosító: kofa.imu/1 · C# típus: Kofa.Abstractions.DataTypes.ImuSample

Inertial sample in the body frame X forward, Y left, Z up (ROS REP 103).

Mező	Típus	Leírás
`Orientation`	`Quaternion`	Body → world rotation, world East-North-Up.
`AngularVelocity`	`Vector3`	rad/s in the body frame (+Z = turning left).
`LinearAccel`	`Vector3`	Specific force in m/s² in the body frame (+9.81 Z at rest).

JsonValue

Azonosító: kofa.json/1 · C# típus: Kofa.Abstractions.DataTypes.JsonValue

Escape hatch for untyped data. Only links to other kofa.json ports.

Mező	Típus	Leírás
`Value`	`JsonElement`

LinkStatus

Azonosító: kofa.link/1 · C# típus: Kofa.Abstractions.DataTypes.LinkStatus

Mező	Típus	Leírás
`Connected`	`bool`
`RttMs`	`double?`
`Rssi`	`double?`

LogEntry

Azonosító: kofa.log/1 · C# típus: Kofa.Abstractions.DataTypes.LogEntry

Mező	Típus	Leírás
`Level`	`KofaLogLevel`
`Message`	`string`
`Source`	`string`

Motion

Azonosító: kofa.motion/1 · C# típus: Kofa.Abstractions.DataTypes.Motion

Mező	Típus	Leírás
`SpeedMps`	`double`
`HeadingRad`	`double`	Where the vehicle points: compass bearing, 0 = north, clockwise positive, [0, 2π).
	`CourseOverGroundRad`	`double?`	Direction of travel (GPS bearing), same convention.

Occupancy

Azonosító: kofa.occupancy/1 · C# típus: Kofa.Abstractions.DataTypes.Occupancy

What stands around the vehicle (simulator ground truth): a bird's-eye height map in the vehicle frame, laid out like SceneGrid (row 0 is the nearest ahead, column 0 the leftmost). A real vehicle has no such sensor: it labels the training of the obstacle perception.

Mező	Típus	Leírás
`CapturedAtMs`	`long`
`Rows`	`int`
`Cols`	`int`
`CellM`	`double`
`ForwardStartM`	`double`
`HeightStepM`	`double`	Height of one unit of `Heights` (0 = nothing there).
`Heights`	`ReadOnlyMemory<byte>`

Pose3

Azonosító: kofa.pose3/1 · C# típus: Kofa.Abstractions.DataTypes.Pose3

Pose in a local frame (meters), e.g. simulator world coordinates.

Mező	Típus	Leírás
`Position`	`Vector3`
`Orientation`	`Quaternion`
`Frame`	`string?`

RangeReadings

Azonosító: kofa.ranges/1 · C# típus: Kofa.Abstractions.DataTypes.RangeReadings

Readings of the distance sensors of a vehicle, sampled together.

Mező	Típus	Leírás
`Readings`	`IReadOnlyList<RangeReading>`

RoadMap

Azonosító: kofa.roadmap/1 · C# típus: Kofa.Abstractions.DataTypes.RoadMap

Navigable map: a graph of streets, sidewalks, crosswalks and paths with addresses and named areas. Produced by the simulator (its generated city) or from OpenStreetMap; consumed by navigators and map views. Local meters are relative to RoadMap.Origin (flat-earth, east-north-up).

Mező	Típus	Leírás
`Source`	`string`	"sim-generated", "osm", …
`Origin`	`GeoPosition`
`Nodes`	`IReadOnlyList<RoadMapNode>`
`Edges`	`IReadOnlyList<RoadMapEdge>`
`Addresses`	`IReadOnlyList<RoadMapAddress>`
`Areas`	`IReadOnlyList<RoadMapArea>`
`Version`	`long`	Changes when the map changes (simulator: the world seed).

Route

Azonosító: kofa.route/1 · C# típus: Kofa.Abstractions.DataTypes.Route

Mező	Típus	Leírás
`Waypoints`	`IReadOnlyList<Waypoint>`

SailAdvice

Azonosító: kofa.sail.advice/1 · C# típus: Kofa.Abstractions.DataTypes.SailAdvice

One instruction for a crew sailing the boat by hand (the sail advisor): what to do now, and the sail / rudder position it aims for (the 3D view draws that). A new instruction has a new Sequence; Speak says it is worth saying aloud.

Mező	Típus	Leírás
`Sequence`	`long`
`Primary`	`string`	The instruction, short (e.g. "Engedj a főn").
`Secondary`	`string?`	Detail / reason (e.g. "bum ~35° · dőlés 24° / 32°").
`Category`	`SailAdviceCategory`
`Urgency`	`SailAdviceUrgency`
`Speak`	`bool`
`HeadingDeg`	`double?`	The boat's compass heading now.
`TargetHeadingDeg`	`double?`	The course to steer.
`TrueWindAngleDeg`	`double?`	True wind angle on the target course, + = from starboard.
`TrueWindSpeedMps`	`double?`
`Rudder`	`double`	The rudder the course needs now, [-1, 1], + = turn to starboard.
`MainSheet`	`double`	The advised main sheet, [0, 1], 0 = sheeted in.
`JibSheet`	`double`	The advised headsail sheet, [0, 1].
`MainBoomDeg`	`double`	The advised boom angle off the centreline (from the sheet).
`CountdownS`	`double?`	Seconds to the next tack / gybe, when one is coming.
`HeelDeg`	`double`
`HeelWarnDeg`	`double`
`HeelLimitDeg`	`double`
`Heel`	`string`	The heel level of the pilot (Small, Medium, Large, Custom, Ludicrous).
`Mode`	`string`	The pilot's course mode (Beat, Tack, ...).
`Alarms`	`IReadOnlyList<string>`
`Engaged`	`bool`	The pilot is on (advising); off it only waits to be started.
`Plain`	`string?`	The same instruction in everyday words, no sailing terms (`SailAdvice.Primary` and `SailAdvice.Secondary` use the terms of the sailing manual): the panel shows / says it where the crew switched the plain names on.
`Key`	`string?`	What the advice is about ("idle", "tack", "heel:reef", ...): a stable code, the texts change by language.
`PrimaryText`	`LocalizedText?`	`SailAdvice.Primary` as a translatable text (the string one is always the Hungarian form).
`SecondaryText`	`LocalizedText?`	`SailAdvice.Secondary` as a translatable text.
`PlainText`	`LocalizedText?`	`SailAdvice.Plain` as a translatable text.
`Station`	`string?`	The pilot holds station ("here", "base", "end", "idle") instead of sailing the route; null: on the route.

SailCommand

Azonosító: kofa.sail.command/1 · C# típus: Kofa.Abstractions.DataTypes.SailCommand

Mező	Típus	Leírás
`Rudder`	`double`	[-1, 1].
`MainSheet`	`double`	[0, 1], 0 = sheeted in.
`JibSheet`	`double?`	[0, 1].
`Motor`	`double?`	[-1, 1].

SailboatSpecs

Azonosító: kofa.sailboat.specs/1 · C# típus: Kofa.Abstractions.DataTypes.SailboatSpecs

Dimensions and current sail configuration of a sailboat, metric (m, m², kg). Published by the boat specs Komod for the 3D view (model scaling) and the sailing AI (forces, limits). Unknown values are null.

Mező	Típus	Leírás
`Name`	`string`	Boat type / name, e.g. "Sudár Regatta".
`PresetId`	`string?`	The built-in preset the values come from, null when entered by hand.
`LengthOverallM`	`double`	Length over all (LOA).
`WaterlineLengthM`	`double?`	Length on the waterline (LWL).
`BeamM`	`double`	Largest width.
`DraftM`	`double?`	Max draft (keel down).
`MastHeightM`	`double?`	Mast length (above the deck).
`DisplacementKg`	`double?`	Mass of the boat ready to sail, with the keel ballast.
`BallastKg`	`double?`	Mass of the keel ballast (part of `DisplacementKg`).
`MaxCrew`	`int?`	Max number of people aboard.
`MainSailAreaM2`	`double`	Full mainsail area (no reef).
`JibAreaM2`	`double`	Full headsail (genoa / jib) area (not furled).
`SpinnakerAreaM2`	`double`	Spinnaker area, 0 when the boat has none.
`ReefCount`	`int`	Reef points of the mainsail.
`ReefLevel`	`int`	Reefs taken in now, [0, `ReefCount`].
`GenoaFurl`	`double`	How much of the genoa area is furled, [0, 1] (0 = fully out, 1 = rolled in).
`SpinnakerAvailable`	`bool`	A spinnaker is rigged and can be set.
`KeelBallastFitted`	`bool`	The keel ballast is on (off e.g. for transport or a lifted swing keel: no righting moment from it).
`MainSailAreaEffectiveM2`	`double`	Mainsail area with the reefs.
`JibAreaEffectiveM2`	`double`	Genoa area with the furling.
`MassKg`	`double?`	Current mass: `DisplacementKg` minus the ballast when it is not fitted.
`HullSpeedMps`	`double?`	Theoretical hull speed from the waterline length (1.34·√LWL[ft] knots).
`SailAreaEffectiveM2`	`double`	Upwind sail area now: reefed main + furled genoa.
`Rig`	`SailboatRig?`	The deck layout and rig (where the ropes are handled); null: unknown (a typical layout is assumed).
`MaxHeelDeg`	`double?`	The most heel the boat still takes under control (°), past it rounds up, the rudder lets go: the sailing pilot's heel levels are worked out from it. Null: unknown (the pilot's own limits).
`Hulls`	`int`	1 = monohull, 2 = catamaran (`SailboatSpecs.BeamM` is then the overall beam).
`FoilRideHeightM`	`double?`	Hydrofoils: the ride height of the hull bottom over the water when flying (m); null = no foils. The pilot sends a foil trim (−1 stay down … 1 fly highest) to the boat when it is set.

Scalar

Azonosító: kofa.scalar/1 · C# típus: Kofa.Abstractions.DataTypes.Scalar

Generic measurement, e.g. for plots.

Mező	Típus	Leírás
`Value`	`double`
`Unit`	`string?`

Scene

Azonosító: kofa.scene/1 · C# típus: Kofa.Abstractions.DataTypes.Scene

The world as the planner sees it (for viewers): the planned path, the semantic bird's-eye grid and obstacles.

Mező	Típus	Leírás
`FrameId`	`long`	The camera frame this scene was made from.
`Intent`	`DriveIntent`
`SpeedMps`	`double`
`Steering`	`double`
`Throttle`	`double`
`Engaged`	`bool`
`Path`	`IReadOnlyList<PathPoint>`	Planned path in the vehicle frame (what the vehicle will drive).
`Grid`	`SceneGrid?`	Null when no viewer asked for it.
`Obstacles`	`IReadOnlyList<SceneObstacle>`
`Note`	`string?`

TextValue

Azonosító: kofa.text/1 · C# típus: Kofa.Abstractions.DataTypes.TextValue

Mező	Típus	Leírás
`Text`	`string`

Trigger

Azonosító: kofa.trigger/1 · C# típus: Kofa.Abstractions.DataTypes.Trigger

Event without payload: e-stop, reset.

Nincs mezője.

Detections

Azonosító: kofa.vision.detections/1 · C# típus: Kofa.Abstractions.DataTypes.Detections

Mező	Típus	Leírás
`FrameId`	`long`
`Boxes`	`IReadOnlyList<DetectionBox>`

Waterway

Azonosító: kofa.waterway/1 · C# típus: Kofa.Abstractions.DataTypes.Waterway

The water around a sailboat: water areas and islands (outlines), piers and breakwaters, and the marks of the course, the start, the harbours with their berths and mooring buoys. Produced by the simulator (generated lake or the real map's water) or from OpenStreetMap; consumed by map views, sailing pilots and the training rewards. Local metres are relative to Waterway.Origin (flat earth).

Mező	Típus	Leírás
`Source`	`string`	"generated" (lake), "osm" (real map), "open" (open water, marks only).
`Origin`	`GeoPosition`
`Areas`	`IReadOnlyList<WaterwayArea>`
`Marks`	`IReadOnlyList<WaterwayMark>`
`Course`	`string`	"windward-leeward", "triangle", "none".
`CourseWindFromDeg`	`double`	The wind the course was laid to (compass degrees it blows from).
`Version`	`long`	Changes when the water or the course changes.
`Coverage`	`IReadOnlyList<GeoPosition>?`	The outline the areas are complete inside (a window of a bigger map, e.g. the water a few hundred metres around the boat): outside it the water is not known, so it is neither water nor land. Null: the areas are the whole water (outside them is land).
`CourseMarks`	`IEnumerable<WaterwayMark>`	The course marks in order (finish last).
`Berths`	`IEnumerable<WaterwayMark>`	The berths of the harbours (a dock task names one by its id).

Wind

Azonosító: kofa.wind/1 · C# típus: Kofa.Abstractions.DataTypes.Wind

Mező	Típus	Leírás
`SpeedMps`	`double`	Wind speed (apparent: relative to the vehicle).
`DirectionRad`	`double`	Where the wind comes from. `WindKind.True`: compass bearing (0 = from north, clockwise, [0, 2π)). `WindKind.Apparent`: angle relative to the bow (0 = head-on, positive = from starboard, (-π, π]). `WindMath` converts between the two.
`Kind`	`WindKind`

WorldPlan

Azonosító: kofa.world.plan/1 · C# típus: Kofa.Abstractions.DataTypes.WorldPlan

What a navigator plans in the seen world (world frame), for viewers.

Mező	Típus	Leírás
`Sequence`	`long`
`Route`	`IReadOnlyList<WorldPoint2>`	The route ahead (and a little behind), about 1 m apart: a car's map route, a sailboat's planned legs.
`Path`	`IReadOnlyList<WorldPoint2>`	The path it drives now, planned in the seen world.
`Waypoints`	`IReadOnlyList<WorldWaypoint>`
`Blocked`	`IReadOnlyList<WorldPoint2>`	Places where the route was found impassable (the route was replanned around them).
`Engaged`	`bool`
`Note`	`string?`
`Maneuvers`	`IReadOnlyList<WorldManeuver>?`	Optional: the turns planned on `WorldPlan.Route` (a sailboat's tacks and gybes), in order. A property, not a constructor parameter: Komods built before it keep their constructor.

WorldTrace

Azonosító: kofa.world.trace/1 · C# típus: Kofa.Abstractions.DataTypes.WorldTrace

The build data of one frame of the seen world (only while asked, e.g. while a recorder records): what each camera saw and every obstacle the frame put into the world with its source pixel. With the ground truth of the same images it tells which pixel made a false obstacle (and how: segmentation, stereo, foot), and which real obstacle did not get into the world.

Mező	Típus	Leírás
`Sequence`	`long`	The `WorldMap.Sequence` published after this frame.
`PoseEastM`	`double`	Where the builder placed the vehicle for the frame (seen world frame); the obstacles are relative to it.
`PoseNorthM`	`double`
`PoseHeadingRad`	`double`	Compass heading of that pose.
`MaxObstacleRangeM`	`double`	The builder maps obstacles up to this far.
`WaterMode`	`bool`
`Cameras`	`IReadOnlyList<WorldTraceCamera>`
`Obstacles`	`IReadOnlyList<WorldTraceObstacle>`
`ObstaclesDropped`	`int`	Obstacles of the frame left out of `Obstacles` (a size limit).

WorldView

Azonosító: kofa.world.view/1 · C# típus: Kofa.Abstractions.DataTypes.WorldView

The seen world for a 3D viewer: a coarser grid with colors, the 3D points the cameras measured, the vehicle and the plan. WorldView.Points: WorldView.PointSize bytes per point: east, north, up as little-endian int16 centimeters relative to the grid origin (up: above the ground), then R, G, B.

Mező	Típus	Leírás
`Sequence`	`long`
`Origin`	`GeoPosition`
`Pose`	`WorldPose`
`Grid`	`WorldGrid`
`Points`	`ReadOnlyMemory<byte>`
`PointCount`	`int`
`Plan`	`WorldPlan?`
`Note`	`string?`

WorldMap

Azonosító: kofa.world/1 · C# típus: Kofa.Abstractions.DataTypes.WorldMap

The seen world around the vehicle and where the vehicle is in it: what a navigator plans on.

Mező	Típus	Leírás
`Sequence`	`long`
`Origin`	`GeoPosition`	Earth position of the world's (0, 0).
`Pose`	`WorldPose`
`Grid`	`WorldGrid`

Összetevő típusok

Más adattípusok mezőiként szerepelnek.

DetectionBox

Bounding box with coordinates normalized to 0..1.

Mező	Típus	Leírás
`Label`	`string`
`Score`	`double`
`X`	`double`
`Y`	`double`
`W`	`double`
`H`	`double`

PathPoint

A point of a planned path in the vehicle frame (meters).

Mező	Típus	Leírás
`X`	`double`
`Y`	`double`

RangeReading

One distance sensor (time-of-flight, ultrasonic) reading.

Mező	Típus	Leírás
`SensorId`	`string`
`DistanceM`	`double`	Nearest target; only meaningful when `Valid`.
`Valid`	`bool`	False: nothing within `MaxRangeM` (or a sensor error).
`MinRangeM`	`double`
`MaxRangeM`	`double`
`FieldOfViewRad`	`double`	Full cone angle of the sensor.

RigPoint

A point of the rig map on deck: a winch, a clutch, the mast, the traveller. The ids are the rig controls of the rig procedures ("jib-winch-port", "main-sheet", "reef-hook", ...).

Mező	Típus	Leírás
`Id`	`string`	Rig control id.
`X`	`double`	Along the boat: 0 bow, 1 stern (part of the length).
`Y`	`double`	Across: -1 port edge, 0 centreline, 1 starboard edge (part of the half beam).
`Z`	`double`	Height above the deck (m).

RoadMapAddress

A house number with its entrance and where it attaches to the network.

Mező	Típus	Leírás
`Street`	`string`
`Number`	`string`	Text: "12", "12/A".
`Position`	`GeoPosition`
`EastM`	`double`
`NorthM`	`double`
`EdgeId`	`string?`	Sidewalk edge in front of the entrance; `AlongM` from its From node.
`AlongM`	`double`
`RoadEdgeId`	`string?`	Street (road edge) beside it; `RoadAlongM` from its From node.
`RoadAlongM`	`double`

RoadMapArea

Mező	Típus	Leírás
`Id`	`string`
`Kind`	`string`	"park", …
`Name`	`string?`
`Outline`	`IReadOnlyList<GeoPosition>`

RoadMapEdge

Undirected unless OneWay (then From → To).

Mező	Típus	Leírás
`Id`	`string`
`From`	`string`
`To`	`string`
`Kind`	`RoadMapEdgeKind`
`LengthM`	`double`
`WidthM`	`double`
`Street`	`string?`	Road: the street; sidewalk: the street beside it; crossing: the street crossed.
`Lanes`	`int`	Lanes of a road (both directions), 0 for footways.
`OneWay`	`bool`

RoadMapNode

Mező	Típus	Leírás
`Id`	`string`
`LatDeg`	`double`
`LonDeg`	`double`
`EastM`	`double`	Local position relative to `RoadMap.Origin` (east, north, up; meters).
`NorthM`	`double`
`UpM`	`double`
`Kind`	`string?`	"intersection", "sidewalk", "park", … (informational).

SailboatRig

The rig and deck layout of a sailboat, for the drawings and the step-by-step rig guide: the mast, the cabin and the cockpit (parts of the length from the bow) and where each rope is handled.

Mező	Típus	Leírás
`Mast`	`MastRig`	Masthead or fractional rig.
`MastX`	`double`	The mast along the boat (0 bow, 1 stern).
`CabinFromX`	`double`	The cabin top starts here…
`CabinToX`	`double`	…and ends here (the companionway).
`CockpitToX`	`double`	The cockpit runs from the cabin to here (the transom is 1).
`Wheel`	`bool`	A wheel instead of a tiller.
`Furler`	`bool`	The genoa is on a roller furler.
`Traveller`	`bool`	The main sheet runs on a traveller.
`LinesAft`	`bool`	Halyards and reef lines led aft to the cabin top (else handled at the mast).
`Points`	`IReadOnlyList<RigPoint>`	Where the ropes are handled.

SceneGrid

Bird's-eye grid in the vehicle frame. Row 0 is the nearest: cell (row, col) is centered at x = ForwardStartM + (row + 0.5) · CellM, y = (Cols / 2 − col − 0.5) · CellM (column 0 is the leftmost). SceneGrid.Cells holds one SceneClass byte per cell, row-major (it travels as base64 in JSON).

Mező	Típus	Leírás
`Rows`	`int`
`Cols`	`int`
`CellM`	`double`
`ForwardStartM`	`double`
`Cells`	`ReadOnlyMemory<byte>`
`Heights`	`ReadOnlyMemory<byte>?`	Only in the ground truth of the lane guide: the height of the tallest solid thing in every cell, in `Occupancy.HeightStepM` units (0 = nothing), same layout as `SceneGrid.Cells`. It labels what the camera sees, not just the floor.

SceneObstacle

An obstacle in the vehicle frame: a box of Length (along X) × Width centered at (X, Y).

Mező	Típus	Leírás
`X`	`double`
`Y`	`double`
`Length`	`double`
`Width`	`double`
`Source`	`SceneObstacleSource`

WaterwayArea

Mező	Típus	Leírás
`Id`	`string`
`Kind`	`string`	"water" (a lake or river: inside its outline), "island" (land inside a water area), "pier", "breakwater".
`Name`	`string?`
`Outline`	`IReadOnlyList<GeoPosition>`

WaterwayMark

A buoy or a point on the water.

Mező	Típus	Leírás
`Id`	`string`
`Kind`	`string`	"mark" (course buoy), "finish", "start", "harbor" (a harbour), "berth" (a boat's place in it), "buoy" (fixed buoy), "mooring" (mooring buoy).
`Name`	`string?`
`Position`	`GeoPosition`
`EastM`	`double`
`NorthM`	`double`
`Rounding`	`MarkRounding`
`Order`	`int`	Place in the course (0-based), -1 when not part of it.
`RadiusM`	`double`	Rounding zone / reached radius.
`HeadingDeg`	`double`	A berth: the heading of a boat lying in it, bow first (compass degrees).
`LengthM`	`double`	A berth: its length along the heading.
`WidthM`	`double`	A berth: its width.
`Berth`	`string?`	A berth: "piles" (between two piles, the quay at the bow end; bow or stern first), "bow-in", "alongside" (the quay to starboard).
`HarborId`	`string?`	A berth or mooring buoy: the harbour it belongs to.

Waypoint

Mező	Típus	Leírás
`Position`	`GeoPosition`
`Order`	`int`
`ToleranceM`	`double`

WorldGrid

A square window of the seen world (2.5D). Cell (col, row) is centered at east = OriginEastM + (col + 0.5) · CellM, north = OriginNorthM + (row + 0.5) · CellM; row-major, row 0 is the southernmost.

Mező	Típus	Leírás
`OriginEastM`	`double`
`OriginNorthM`	`double`
`Cols`	`int`
`Rows`	`int`
`CellM`	`double`
`Classes`	`ReadOnlyMemory<byte>`	One `SceneClass` byte per cell (or `WorldGrid.FreeClass`).
`Heights`	`ReadOnlyMemory<byte>`	Top of what stands in the cell, in `WorldGrid.HeightStepM` units (0 = flat ground or not seen).
`Colors`	`ReadOnlyMemory<byte>?`	Optional RGB per cell (3 bytes), the color the cameras saw.

WorldManeuver

A planned turn on the route (world frame).

Mező	Típus	Leírás
`EastM`	`double`
`NorthM`	`double`
`Kind`	`WorldManeuverKind`

WorldPoint2

A point in the world frame (meters east / north of the world origin).

Mező	Típus	Leírás
`EastM`	`double`
`NorthM`	`double`

WorldPose

Where the vehicle is in its seen world, and the same place on the earth.

Mező	Típus	Leírás
`EastM`	`double`
`NorthM`	`double`
`HeadingRad`	`double`	Compass heading: 0 = north, clockwise positive.
`SpeedMps`	`double`
`Geo`	`GeoPosition`	The same position on the earth: the world position plus the GPS correction.
`GpsOffsetEastM`	`double`	World → earth correction (what the GPS says minus where the vehicle placed itself), filtered.
`GpsOffsetNorthM`	`double`
`GpsResidualM`	`double?`	Distance of the last GPS fix from the corrected position (null: no GPS yet).
`MatchScore`	`double?`	0..1: how well the last camera frames fitted the world built before (null: not matched).

WorldTraceCamera

What one camera gave to a frame of the seen world: the image it used, the camera as used (the horizon fitted on the water) and its segmentation.

Mező	Típus	Leírás
`Camera`	`byte`	0 = front left, 2 = left side, 3 = right side.
`FrameId`	`long`	The `CameraFrame.FrameId` of the image.
`StereoFrameId`	`long?`	With a stereo pair: the right image's frame id.
`ImageWidth`	`int`
`ImageHeight`	`int`
`HorizontalFovDeg`	`double`
`ForwardM`	`double`
`LeftM`	`double`
`HeightM`	`double`
`YawLeftDeg`	`double`
`PitchDownDeg`	`double`
`RollDeg`	`double`	Body roll the camera was used with (+ = right side down; on the water fitted to the horizon).
`PitchDeg`	`double`	Body pitch the camera was used with (+ = nose up).
`SegWidth`	`int`
`SegHeight`	`int`
`SegCropTop`	`int`
`SegCropHeight`	`int`
`SegClasses`	`ReadOnlyMemory<byte>`	`SceneClass` per cell of the `SegWidth` × `SegHeight` segmentation raster covering image rows `SegCropTop` .. + `SegCropHeight`; empty without segmentation.
`SegConfidence`	`ReadOnlyMemory<byte>`	Confidence per cell, 0..255.
`GroundRanges`	`ReadOnlyMemory<byte>`	Per cell: the ground (water) distance of the cell's bottom edge in 0.1 m (255 = beyond 25.4 m or above the horizon).

WorldTraceObstacle

One obstacle update a frame put into the seen world: from which camera pixel, how, and where.

Mező	Típus	Leírás
`Source`	`WorldTraceSource`
`Camera`	`byte`	0 = front left, 1 = front right, 2 = left side, 3 = right side (the vision-world's camera inputs).
`U`	`float`	The source pixel in the camera's image (x right from the left edge).
`V`	`float`	The source pixel (y down from the top).
`X`	`float`	Where it went in the vehicle frame of the trace (m, forward).
`Y`	`float`	Left (m).
`Z`	`float`	Height (m).
`Weight`	`float`	Its vote in the world (closer and surer counts more).

WorldWaypoint

Mező	Típus	Leírás
`EastM`	`double`
`NorthM`	`double`
`Reached`	`bool`
`Current`	`bool`	The waypoint the vehicle is heading to now.