index

type At ¶

type At struct {
	Id
	ProbPos
}

At represents an opinion about an object's position.

type CatalogNum ¶

type CatalogNum uint32

CatalogNum is shared identity of the focal object.

This whole concept is perilous, but we'll attempt to use it as best we can.

Currently these identifiers are assigned by the United States Space Command; however, we plan to be able to extend this namespace at least a little (within the current confines of four bytes, which could of course change in the future).

A publisher of an unassigned object needs to take care to use a number that won't conflict with use of that number by a different publisher! Yes, this approach will become problematic, but we need this notion here in order to avoid reporting the conjuction of two views of the same thing.

The number zero represents an unknown value. In this case, any other position report is a candidate for an emitted conjunction. With that exception, no conjunction report is emitted based on two reports that have the same CatalogNum.

type Cell ¶

type Cell struct {
	// contains filtered or unexported fields
}

Cell represents a set of IdProbPos in an S2 cell.

func NewCell() *Cell

func (c *Cell) Add(ipp IdProbPos)

func (c *Cell) Count() int

func (c *Cell) Rem(ipp IdProbPos)

func (c Cell) String() string

type CellFinder ¶

type CellFinder struct {
	Level *Level
}

CellFinder maps a position to a cell.

func NewCellFinder(level int) *CellFinder

func (i *CellFinder) Find(p Pos) (CellId, error)

func (i *CellFinder) Neighbors(cid CellId) []s2.CellID

type CellId ¶

type CellId s2.CellID

type Conj ¶

type Conj struct {
	Ats  [2]At
	Dist float32
}

Conj represents an opinion about the proximity of two objects (at some unspecified time).

func NewConj(a, b At, d float32) Conj

type Id ¶

type Id uint32

Id represents the distinct report in its totality (as far as this package goes). Two reports that are "equal" should have the same id.

We are using only four bytes to conserve RAM.

Re "Id" vs "ID": I'm in the "Id" is an abbreviation, not an acronym camp, and I've been there (rightly or wrongly) for a long time. https://github.com/golang/lint/issues/89 says I'm wrong -- at least as far as Go sources go. Had I known at the time, I probably would have complied.

type IdProbPos ¶

type IdProbPos struct {
	Id
	CatalogNum
	ProbPos
}

func (i IdProbPos) String() string

type IdProbPoss ¶

type IdProbPoss struct {
	Id
	CatalogNum
	PPS []ProbPos
}

IdProbPoss is a set of IdProbPos for a given object.

type Index ¶

type Index struct {
	Dist       float32
	CellFinder *CellFinder

	IPPS  map[Key]*IdProbPoss
	Cells map[CellId]*Cell
}

Index receives object positions and returns "conjunctions".

This implementation is not safe for concurrent use.

func NewIndex(level int, dist float32) *Index

func NewIndexWithFinder(finder *CellFinder, dist float32) *Index

func (i *Index) Data() *IndexData

func (i *Index) GetCell(p Pos) (*Cell, CellId, error)

func (i *Index) Print()

func (i *Index) Search(cid CellId, spp IdProbPos, d float32) []Conj

func (i *Index) Update(id Id, key Key, pps []ProbPos) ([]Conj, []Conj, Id, error)

type IndexData ¶

type IndexData struct {
	CellCount   int
	KeyCount    int
	KeysPerCell float64
}

IndexData represents some statistics about an Index.

type Key ¶

type Key struct {
	CatalogNum
	Publisher
}

Key is the key for storing positions in the index.

In an Index, a CatalogNum+Publisher has can have a single opinion of that object's position(s). Note that that opinion can include multiple possible positions.

func (k Key) String() string

type Level ¶

type Level struct {
	Level   int
	Coverer s2.RegionCoverer
}

func NewLevel(level int) *Level

func (l *Level) Find(ll s2.LatLng) (*s2.CellID, error)

func (l *Level) Neighbors(c s2.CellID) []s2.CellID

type Pos ¶

type Pos struct {
	X float32
	Y float32
	Z float32
}

Pos is the object's state.

Currently this state only includes position (ECI).

If we add velocity, then the index could sample Conjs with low relative speeds. For objects parked together, every index would emit an Conj. The resulting downstream relative computational load is unknown but possibly significant. However, most of that load is (I think) typically spread across all cores. Adding velocity results in a memory increase of maybe 40%. The guiding principle was to optimize for memory, so we'll stick to that principle for now. ToDo: Reconsider.

func (p Pos) Dist(q Pos) float32

func (p Pos) String() string

type Prob ¶

type Prob float32

Prob represents uncertainty (without any index-imposed meaning).

Can update this definition to support more dimensions, but of course we're mindful of memory consumption.

type ProbPos ¶

type ProbPos struct {
	Pos
}

ProbPos represents one candidate Pos.

Currently we do not include Prob here, but this type exists to make it easy to add that and other data.

type Publisher ¶

type Publisher uint32

Publisher is the id for the publisher of a position.