def getModelFromPoints(sourcePoints, targetPoints): rigidModel = RigidModel2D() pointMatches = HashSet() for a in zip(sourcePoints, targetPoints): pm = PointMatch(Point([a[0][0], a[0][1]]), Point([a[1][0], a[1][1]])) pointMatches.add(pm) rigidModel.fit(pointMatches) return rigidModel
def __init__(self, center, p1, d1, p2, d2): """ center, p1, p2 are 3 RealLocalizable, with center being the center point and p1, p2 being the wings (the other two points). p1 is always closer to center than p2 (d1 < d2) d1, d2 are the square distances from center to p1, p2 (which we could compute here, but RadiusNeighborSearchOnKDTree did it already). """ self.position = Point(self.array(center)) v1 = Vector3f(*self.subtract(p1, center)) v2 = Vector3f(*self.subtract(p2, center)) self.angle = v1.angle(v2) # in radians self.len1 = d1 # same as v1.lengthSquared() self.len2 = d2 # same as v2.lengthSquared()
class Constellation: """ Expects 3 scalars and an iterable of scalars. """ def __init__(self, angle, len1, len2, coords): self.angle = angle self.len1 = len1 self.len2 = len2 self.position = Point(array(coords, 'd')) def matches(self, other, angle_epsilon, len_epsilon_sq): """ Compare the angles, if less than epsilon, compare the vector lengths. Return True when deemed similar within measurement error brackets. """ return abs(self.angle - other.angle) < angle_epsilon \ and abs(self.len1 - other.len1) + abs(self.len2 - other.len2) < len_epsilon_sq @staticmethod def subtract(loc1, loc2): return (loc1.getFloatPosition(d) - loc2.getFloatPosition(d) for d in xrange(loc1.numDimensions())) @staticmethod def fromSearch(center, p1, d1, p2, d2): """ center, p1, p2 are 3 RealLocalizable, with center being the peak and p1, p2 being the wings (the other two points). p1 is always closer to center than p2 (d1 < d2). d1, d2 are the square distances from center to p1, p2 (could be computed here, but RadiusNeighborSearchOnKDTree did it). """ pos = tuple(center.getFloatPosition(d) for d in xrange(center.numDimensions())) v1 = Vector3f(Constellation.subtract(p1, center)) v2 = Vector3f(Constellation.subtract(p2, center)) return Constellation(v1.angle(v2), d1, d2, pos) @staticmethod def fromRow(row): """ Expects: row = [angle, len1, len2, x, y, z] """ return Constellation(row[0], row[1], row[2], row[3:]) def asRow(self): "Returns: [angle, len1, len2, position.x, position,y, position.z" return (self.angle, self.len1, self.len2) + tuple(self.position.getW()) @staticmethod def csvHeader(): return ["angle", "len1", "len2", "x", "y", "z"]
def __init__(self, angle, len1, len2, coords): self.angle = angle self.len1 = len1 self.len2 = len2 self.position = Point(array(coords, 'd'))
def fromRows(rows): """ rows: from a CSV file, as lists of strings. """ return PointMatches([PointMatch(Point(array(imap(float, row[0:3]), 'd')), Point(array(imap(float, row[3:6]), 'd'))) for row in rows])
''' import sys, os import cPickle as pickle curDir = os.path.abspath(os.path.dirname(__file__)) sys.path.append("/plugin/mpicbg-master/mpicbg/target/mpicLatest.jar") from mpicbg.models import Point, PointMatch, AffineModel3D, MovingLeastSquaresTransform with open(os.path.join(curDir, "MLS", "pointsToMatchDec2017EntryPointsB.pkl")) as fI: landmarkList = pickle.load(fI) matches = [] for thisLand in landmarkList: for thisSide in ["right", "left", "centre"]: if "FROM_" + thisSide in thisLand and "TO_" + thisSide in thisLand: p1 = Point(map(float, thisLand["FROM_" + thisSide])) p2 = Point(map(float, thisLand["TO_" + thisSide])) matches.append(PointMatch(p1, p2, 1.0)) print len(matches), "landmark points used" mls = MovingLeastSquaresTransform() model = AffineModel3D() mls.setModel(model) mls.setMatches(matches) with open(os.path.join(curDir, "MLS", "Points_input.pkl")) as fI: pointList = pickle.load(fI) output = [] for i in range(len(pointList)): output.append(map(float, mls.apply(pointList[i])))