Functions
def	__repr__ (self)

def	__str__ (self)

def	__getitem__ (self, i)

def	__setitem__ (self, i, val)

def	__len__ (self)

def	clone (self)

def	packMatches (matches)

Variables
	clone

	first

	second

	distance

Function Documentation

◆ getitem()

def lsst.afw.table.match.matchContinued.__getitem__	(	self,
		i
	)

Treat a Match as a tuple of length 3: (first, second, distance)

Definition at line 52 of file matchContinued.py.

 def __getitem__(self, i):  # noqa: N807
     """Treat a Match as a tuple of length 3: (first, second, distance)"""
     if i > 2 or i < -3:
         raise IndexError(i)
     if i < 0:
         i += 3
     if i == 0:
         return self.first
     elif i == 1:
         return self.second
     else:
         return self.distance
 
 

◆ len()

def lsst.afw.table.match.matchContinued.__len__ ( self )

Definition at line 80 of file matchContinued.py.

 def __len__(self):  # noqa: N807
     return 3

◆ repr()

def lsst.afw.table.match.matchContinued.__repr__ ( self )

Definition at line 30 of file matchContinued.py.

 def __repr__(self):  # noqa: N807
     return "Match(%s,\n            %s,\n            %g)" % \
         (repr(self.first), repr(self.second), self.distance)
 
 

◆ setitem()

def lsst.afw.table.match.matchContinued.__setitem__	(	self,
		i,
		val
	)

Treat a Match as a tuple of length 3: (first, second, distance)

Definition at line 66 of file matchContinued.py.

 def __setitem__(self, i, val):  # noqa: N807
     """Treat a Match as a tuple of length 3: (first, second, distance)"""
     if i > 2 or i < -3:
         raise IndexError(i)
     if i < 0:
         i += 3
     if i == 0:
         self.first = val
     elif i == 1:
         self.second = val
     else:
         self.distance = val
 
 

◆ str()

def lsst.afw.table.match.matchContinued.__str__ ( self )

Definition at line 35 of file matchContinued.py.

 def __str__(self):  # noqa: N807
     def sourceRaDec(s):
         if hasattr(s, "getRa") and hasattr(s, "getDec"):
             return " RA,Dec=(%g,%g) deg" % (s.getRa().asDegrees(), s.getDec().asDegrees())
         return ""
 
     def sourceXy(s):
         if hasattr(s, "getX") and hasattr(s, "getY"):
             return " x,y=(%g,%g)" % (s.getX(), s.getY())
         return ""
 
     def sourceStr(s):
         return s.__class__.__name__ + ("(id %d" % s.getId()) + sourceRaDec(s) + sourceXy(s) + ")"
 
     return "Match(%s, %s, dist %g)" % (sourceStr(self.first), sourceStr(self.second), self.distance,)
 
 

◆ clone()

def lsst.afw.table.match.matchContinued.clone ( self )

Definition at line 84 of file matchContinued.py.

 def clone(self):
     return self.__class__(self.first, self.second, self.distance)
 
 
 # Pickling support disabled for this type (see testSourceMatch comment for reasoning)
 # def __getstate__(self):
 #    return self.first, self.second, self.distance
 #
 #
 # def __setstate__(self, state):
 #    self.__init__(*state)
 
 

◆ packMatches()

def lsst.afw.table.match.matchContinued.packMatches ( matches )

Make a catalog of matches from a sequence of matches.

The catalog contains three fields:
- first: the ID of the first source record in each match
- second: the ID of the second source record in each match
- distance: the distance of each match

@param[in] matches  Sequence of matches, typically of type SimpleMatch, ReferenceMatch or SourceMatch.
    Each element must support: `.first.getId()`->int, `.second.getId()->int` and `.distance->float`.
@return a catalog of matches.

@note this pure python implementation exists because SWIG could not easily be used to wrap
the overloaded C++ functions, so this was written and tested. It might be practical
to wrap the overloaded C++ functions with pybind11, but there didn't seem much point.

Definition at line 108 of file matchContinued.py.

 def packMatches(matches):
     """Make a catalog of matches from a sequence of matches.
 
     The catalog contains three fields:
     - first: the ID of the first source record in each match
     - second: the ID of the second source record in each match
     - distance: the distance of each match
 
     @param[in] matches  Sequence of matches, typically of type SimpleMatch, ReferenceMatch or SourceMatch.
         Each element must support: `.first.getId()`->int, `.second.getId()->int` and `.distance->float`.
     @return a catalog of matches.
 
     @note this pure python implementation exists because SWIG could not easily be used to wrap
     the overloaded C++ functions, so this was written and tested. It might be practical
     to wrap the overloaded C++ functions with pybind11, but there didn't seem much point.
     """
     schema = Schema()
     outKey1 = schema.addField("first", type=np.int64,
                               doc="ID for first source record in match.")
     outKey2 = schema.addField("second", type=np.int64,
                               doc="ID for second source record in match.")
     keyD = schema.addField("distance", type=np.float64,
                            doc="Distance between matches sources.")
     result = BaseCatalog(schema)
     result.table.preallocate(len(matches))
     for match in matches:
         record = result.addNew()
         record.set(outKey1, match.first.getId())
         record.set(outKey2, match.second.getId())
         record.set(keyD, match.distance)
     return result

Variable Documentation

◆ clone

lsst.afw.table.match.matchContinued.clone

Definition at line 103 of file matchContinued.py.

◆ distance

lsst.afw.table.match.matchContinued.distance

Definition at line 77 of file matchContinued.py.

◆ first

lsst.afw.table.match.matchContinued.first

Definition at line 73 of file matchContinued.py.

◆ second

lsst.afw.table.match.matchContinued.second

Definition at line 75 of file matchContinued.py.

Functions

Variables