0. Code

{{{id=13| from itertools import chain def flatten(listOfLists): "Flatten one level of nesting" return chain.from_iterable(listOfLists) class Point(Graphics): def __init__(self, coordinates, label='', latexlabels=True, color=(0,0,0), pointsize=14, labelcolor=(0,0,0), labelnudge=.01, labelposition=('center', 'top'), labelsize=14): #First, run the init function from our parent class, then construct our pieces Graphics.__init__(self) self.coordinates = coordinates self._point = point(coordinates, rgbcolor=color, size=pointsize) self._labelcoordinates = self.makelabelcoordinates(coordinates, labelnudge, labelposition) if(latexlabels): self._labeltext = '$' + label + '$' else: self._labeltext = label self._label = text(self._labeltext, self._labelcoordinates, rgbcolor=labelcolor, fontsize=labelsize, vertical_alignment=labelposition[1], horizontal_alignment=labelposition[0]) self.add_primitive(self._point[0]) self.add_primitive(self._label[0]) def makelabelcoordinates(self, coordinates, labelnudge, labelposition): #Calculate a position for the label, based on the point coordinates, and nudge factor coordinatesout = [] for i, pos in enumerate(labelposition): if pos == 'center': coordinatesout.append(coordinates[i]) elif pos in ['top', 'right']: coordinatesout.append(coordinates[i] - labelnudge) elif pos in ['bottom', 'left']: coordinatesout.append(coordinates[i] + labelnudge) return tuple(coordinatesout) class Segment(Graphics): def __init__(self, points, labels=['',''], color=(0,0,0), linethickness=1.25, drawpoints=False, marks=0, markersize=.02): # Init the underlying Graphics object Graphics.__init__(self) if(type(points[0]) == Point): self._points = points else: self._points = [Point(points[i], labels[i]) for i in range(2)] self._color = (0,0,0) self._linethickness = 1 self.coordinates = (self._points[0].coordinates, self._points[1].coordinates) self._x1 = self.coordinates[0][0] self._y1 = self.coordinates[0][1] self._x2 = self.coordinates[1][0] self._y2 = self.coordinates[1][1] self._line = line(self.coordinates, rgbcolor=color, thickness=linethickness)[0] self.add_primitive(self._line) self._markersize = markersize if(marks > 0): self.addmarks() # Graphics objects can be treated as a list of primitives, so if we need to draw the points, # we extract its primitives, and add them to the Segment if drawpoints: for g in self._points[0]: self.add_primitive(g) for g in self._points[1]: self.add_primitive(g) @property def points(self): return (self._points[0], self._points[1]) def midpoint(self): return Point([(self._x1 + self._x2)/2, (self._y1 + self._y2)/2]) def length(self): return sqrt((self._x1 - self._x2)^2 + (self._y1 - self._y2)^2) def rise(self): return self._y1 - self._y2 def run(self): return self._x1 - self._x2 def slope(self): try: return (self.rise()) / (self.run()) except ZeroDivisionError: return infinity def addmarks(self): midcoors = self.midpoint().coordinates size = self._markersize slope = self.slope() if(slope > 0): xnudge = abs(self.rise()) * self._markersize ynudge = -abs(self.run()) * self._markersize elif(slope < 0): xnudge = -abs(self.rise()) * self._markersize ynudge = -abs(self.run()) * self._markersize elif(slope == 0): xnudge = 0 ynudge = self._markersize elif(slope == infinity): xnudge = self._markersize ynudge = 0 self._markercoordinates = [(midcoors[0] + xnudge, midcoors[1] + ynudge), (midcoors[0] - xnudge, midcoors[1] - ynudge)] marker = line(self._markercoordinates, rgbcolor=self._color, thickness=self._linethickness)[0] self.add_primitive(marker) class _TriangleBuilder: def __init__(self, points=None, labels=['','',''], color=(0,0,0), linethickness=1, drawpoints=False): self._args = {} self._args['points'] = points self._args['labels'] = labels self._args['color'] = color self._args['linethickness'] = linethickness self._args['drawpoints'] = drawpoints self._congruence_marks = [] def build(self): tri = Triangle(_being_built=True) self._build_inplace(tri) return tri def with_congruence_mark(self, from_pt, to_pt, num): self._congruence_marks.append((from_pt, to_pt, num)) return self def _get_segment_marker(self, f, t, points): from sage.rings.integer import Integer for (from_pt, to_pt, num) in self._congruence_marks: if isinstance(from_pt, (int, Integer)): from_pt = points[from_pt] if isinstance(to_pt, (int, Integer)): to_pt = points[to_pt] if from_pt == f and to_pt == t or \ from_pt == t and to_pt == f: return num return None def _build_inplace(self, tri): points = self._args['points'] labels = self._args['labels'] color = self._args['color'] linethickness = self._args['linethickness'] drawpoints = self._args['drawpoints'] if(type(points[0]) == Point): tri._points = points else: tri._points = [Point(points[i], labels[i]) for i in range(3)] tri._segments = [] for p1, p2 in zip(tri._points, tri._points[1:] + [tri._points[0]]): tri._segments.append(Segment((p1, p2), color=color, linethickness=linethickness, drawpoints=False, marks=self._get_segment_marker(p1, p2, tri._points))) containers = tri._segments if drawpoints: containers = chain(containers, flatten([seg.points for seg in tri._segments])) for con in containers: for g in con: tri.add_primitive(g) class Triangle(Graphics): def __init__(self, *args, **kwargs): Graphics.__init__(self) if '_being_built' not in kwargs: _TriangleBuilder(*args, **kwargs)._build_inplace(self) @staticmethod def new(*args, **kwargs): return _TriangleBuilder(*args, **kwargs) @property def sides(self): return self._segments def __iter__(self): return iter(self._points) def __getitem__(self, idx): return self._points[idx] /// }}}

1. Motivation and Summary

While taking an axiomatic geometry course in parallel with learning about Sage this quarter, I was drawn to the following question: Can I produce the type of diagrams which I need to draw for my geometry assignments using Sage? As it turns out, Sage includes in its drawing packages all of the basic functionality needed, but provides no convenient ways to construct geometric objects like points with a label, line segments with marked endpoints, or triangles. Throughout the quarter, I wrote some code in Sage which began to implement my desired behavior, and decided to expand that work into a decent proof of concept for a more complete geometry package in Sage.

The intended scope of the project was to allow for the easy (one line of code) construction of labeled points, line segments, and triangles. Furthermore, I wanted my line segment objects to be able to draw tick marks along their length to indicate congruence with another segment, and I wanted to be able to mark angles with arcs to similarly show angle congruence. Relationships among objects are important as well--one should be able to construct a segment from two point objects easily, or a triangle from three points, and after construction, the individual points of a segment, or points and segments of a triangle should be accessible to the user. An auxillary goal of the project was to be able to do mathematics with the drawn objects once they are created, and to be able to get information or new related objects from each item implemented. Thus, line segments should know their length and slope, and should be able to return their midpoint. With just this functionality in place, a number of interesting diagrams could be created, and a solid foundation would be laid for creating more complex geometric constructions.

2. Implementation

We created a class for each object which was to be represented--Point, Segment, Triangle--referring to a point with an optional label, a line segment with two points on the ends, and a collection of three points and the line segments connecting them. In the rest of the paper, we will use the capitalized class names to refer to their coded representations, and terms like 'point' and 'line' to refer to the general geometric objects. These classes inherit from Sage's Graphics object, which makes sense for a few reasons. First, this allows them to be treated like any shape built into Sage, and can thus be added to other Graphics instances to overlay them, or displayed using the show() function. Furthermore, because Graphics acts as a container for Sage's Graphics primitives, it was easy to build up and store our more complicated constructions from Sage's builtin plotting primitives. Some subtle bugs were introduced as a result of inheriting from Graphics, and it did require becoming intimately familiar with some aspects of Sage's drawing code, but the slick infterface it provides is certainly worth it.

Point was the first class which we implemented. Point takes a set of coordinates, an optional label, and some drawing style options, and draws the point and label accordingly. Drawing a round point mark in Sage is trivial, so it was the creation of the labels which provided the major hurdle here. In fact, drawing a piece of text in Sage is not hard either, but getting it to appear in the correct location with respect to the point (and not overlapping) was more difficult. While working on this, I found that Sage's text object did have an alignment argument to set where it is to appear compared to the coordinates provided for its location. However, use of that parameter alone did not always put labels into the correct location. Therefore, I added an extra argument to the constructor of Point which will nudge the label away from its corresponding point. Once the labels were looking nice, it was a simple matter of making sure that the points coordinates were available to the outside world (points don't have much other info to offer).

{{{id=1| p1,p2,p3 = Point((0,0), 'A'), Point((.5,0), 'B'), Point((.25,.75), 'C', labelposition=('center', 'bottom')) show(p1 + p2 + p3, aspect_ratio=1, axes=False) ///

}}}

With Point in place, I started work on Segment. Segment accepts a pair of Points, or a pair of coordinates and pair of optional labels, as well as some style options as input, and constructs the segment connecting those points. Getting Segment to draw properly was fairly straightforward, and so I turned my attention to being able to place a congruence tick mark at the center of the segment. In working out the details, I realized that I would need several pieces of information available to me, which I had been planning on adding methods to compute anyway. Thus, I added methods to compute the slope, length, and midpoint of the segment. Segment congruence marks should be perpendicular to the segment, and should also be a set length, so I produced an algorithm which finds two points on the line which is perpendicular to the segment and passes through its midpoint. These points are are equidistant from the midpoint, and that distance is given by a constructor option. With coordinates in hand, a line segment primitive is added to Segment, assuming the option to draw a congruence mark is enabled.

{{{id=6| s1 = Segment([p1, p2], drawpoints=True) s2 = Segment([p2, p3], drawpoints=True) show(s1 + p3, aspect_ratio=1, axes=False, figsize=[5,5]) ///

}}} {{{id=9| s3 = Segment([(0,0), (1,1)], ['P', 'Q'], drawpoints=True) s4 = Segment([(.25,.75), (.75,.25)], ['R', 'S'], drawpoints=True) show(s3 + s4, aspect_ratio=1, axes=False) ///

}}}

With the building blocks in place, my partner Bill went to work on a Triangle class. Like Segment, Triangle accepts either Points or a list of three coordinates and a list of optional labels. During initialization, Triangle creates its Points if necessary, and also the Segments which connect them, both of which are made available to the user through methods. We wished to have a convenient way to add congruence marks to the sides of our Triangle during construction, and so, Bill implemented a rather fancy interface which uses an internal class to accept a string of function calls from the user indicating which segment to draw the tick marks on. TriangleBuilder adds all of the necessary primitives to the underlying Graphics object, and the user gets a Triangle back, as expected.

{{{id=16| t1 = Triangle([(0,0), (0,1), (1,1)], drawpoints=True) show(t1, aspect_ratio=1, axes=False) ///

}}} {{{id=3| t2 = Triangle.new([p1, p2, p3], drawpoints=True).with_congruence_mark(p2,p3,1).with_congruence_mark(p3,p1,1).build() show(t2, aspect_ratio=1, axes=False) ///

}}}

3. Conclusion

The project, while having to shed some planned functionality for the sake of deadlines, did produce some very useful and useable code. Overall, the design and implementation are cleanly done, and should provide a solid foundation for further such work if I choose to pursue it. Given more time, a few more features would have nicely rounded out the functionality which was finished. Particularly, I would have liked to make the congruence mark drawing routine robust enough to support more than a single tick mark, and to have implemented the planned Angle class with the ability to draw angle arcs for congruence marks. Also, the current interface for choosing where to place labels is ugly, and the constructors for Segment and Triangle should take label placement data when Point objects are not passed in. In reviewing the code, I have realized that the algorithm for placing tick marks on segments is more complicated than it should be, and could use reimlementation. Further features would include routines for doing things like returning the Point where two Segments intersect, checking whether a Point is on a Segment, implementing a more general Line class, adding classes for circles, quadrilaterals, and more complex polygons, and exploration of working with these objects without explicit reference to x/y coordinates. For now, I am pleased with my results, and look forward to further hacking with the possibility of contributing some form of this code to Sage in the future.