def _transform_from_image(self):
from matplotlib.transforms import Bbox, BboxTransform
ref_im = np.array([(15.152, 57.079), (15.152, 65.091),
(12.949, 65.091), (12.949, 62.575), (5.613, 62.575),
(5.613, 60.587), (12.949, 60.587),
(12.949, 57.079)])
ref = Vessel().digitizer.xy[2]
bbox_im, bbox = Bbox.unit(), Bbox.unit()
bbox_im.update_from_data_xy(ref_im)
bbox.update_from_data_xy(ref)
trans = BboxTransform(bbox_im, bbox)
return trans
def connect_bbox(bbox1, bbox2, loc1, loc2=None):
"""
Construct a `.Path` connecting corner *loc1* of *bbox1* to corner
*loc2* of *bbox2*, where parameters behave as documented as for the
`.BboxConnector` constructor.
"""
if isinstance(bbox1, Rectangle):
bbox1 = TransformedBbox(Bbox.unit(), bbox1.get_transform())
if isinstance(bbox2, Rectangle):
bbox2 = TransformedBbox(Bbox.unit(), bbox2.get_transform())
if loc2 is None:
loc2 = loc1
x1, y1 = BboxConnector.get_bbox_edge_pos(bbox1, loc1)
x2, y2 = BboxConnector.get_bbox_edge_pos(bbox2, loc2)
return Path([[x1, y1], [x2, y2]])
def _set_lim_and_transforms(self):
self.transAxes = BboxTransformTo(self.bbox)
self.transScale = TransformWrapper(IdentityTransform())
self.transProjection = self.PolarTransform()
self.transProjectionAffine = self.PolarAffine(self.transScale, self.viewLim)
self.transData = self.transScale + self.transProjection + \
(self.transProjectionAffine + self.transAxes)
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes)
self._theta_label1_position = Affine2D().translate(0.0, 1.1)
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform)
self._theta_label2_position = Affine2D().translate(0.0, 1.0 / 1.1)
self._xaxis_text2_transform = (
self._theta_label2_position +
self._xaxis_transform)
self._yaxis_transform = (
Affine2D().scale(npy.pi * 2.0, 1.0) +
self.transData)
self._r_label1_position = Affine2D().translate(22.5, self._rpad)
self._yaxis_text1_transform = (
self._r_label1_position +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform
)
self._r_label2_position = Affine2D().translate(22.5, self._rpad)
self._yaxis_text2_transform = (
self._r_label2_position +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform
)
def _set_lim_and_transforms(self):
PolarAxes._set_lim_and_transforms(self)
try:
theta_position = self._theta_label1_position
except AttributeError:
theta_position = self.get_theta_offset()
self.transProjection = self.GlobeCrossSectionTransform()
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes)
self._xaxis_text1_transform = (
theta_position +
self._xaxis_transform)
self._yaxis_transform = (
Affine2D().scale(num.pi * 2.0, 1.0) +
self.transData)
try:
rlp = getattr(self, '_r_label1_position')
except AttributeError:
rlp = getattr(self, '_r_label_position')
self._yaxis_text1_transform = (
rlp +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform)
def _set_lim_and_transforms(self):
"""
Overrides the method with the same name in the PolarAxes-class.
This method replaces the same method in the PolarAxes-class. It ensures
that the limits and label placement fit the north-polar projection.
"""
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.NorthPolarTransform()
# pylint: attribute-defined-outside-init,invalid-name
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
# pylint: attribute-defined-outside-init,invalid-name
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes) # pylint: attribute-defined-outside-init
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform) # pylint: attribute-defined-outside-init
self._yaxis_transform = (
Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData) # pylint: attribute-defined-outside-init
self._yaxis_text1_transform = (
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform) # pylint: attribute-defined-outside-init
def _set_lim_and_transforms(self):
"""
Overrides the method with the same name in the PolarAxes-class.
This method replaces the same method in the PolarAxes-class. It ensures
that the limits and label placement fit the north-polar projection.
"""
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.NorthPolarTransform()
# pylint: attribute-defined-outside-init,invalid-name
self.transData = (self.transScale + self.transProjection +
(self.transProjectionAffine + self.transAxes))
# pylint: attribute-defined-outside-init,invalid-name
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) + self.transAxes
) # pylint: attribute-defined-outside-init
self._xaxis_text1_transform = (
self._theta_label1_position + self._xaxis_transform
) # pylint: attribute-defined-outside-init
self._yaxis_transform = (Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData
) # pylint: attribute-defined-outside-init
self._yaxis_text1_transform = (
Affine2D().scale(1.0 / 360.0, 1.0) + self._yaxis_transform
) # pylint: attribute-defined-outside-init
def _set_lim_and_transforms(self): PolarAxes._set_lim_and_transforms(self) self.transProjection = self.NorthPolarTransform() self.axisProjection = self.NorthPolarAxisTransform() self.transData = ( Affine2D().scale(numpy.pi/180.0, 1.0/90.0) + self.transScale + self.transProjection + (self.transProjectionAffine + self.transAxes)) self._xaxis_pretransform = ( Affine2D().scale(1.0, 1.0) ) self._xaxis_transform = ( self._xaxis_pretransform + self.axisProjection + self.PolarAffine(IdentityTransform(), Bbox.unit()) + self.transAxes) self._xaxis_text1_transform = ( self._theta_label1_position + self._xaxis_transform) self._yaxis_transform = ( Affine2D().scale(numpy.pi*2.0, 1.0) + self.transScale + self.axisProjection + (self.transProjectionAffine + self.transAxes)) self._yaxis_text1_transform = ( self._r_label1_position + Affine2D().translate(0.0, -0.051) + self._yaxis_transform)
def draw_plot(self):
if self._doRePlot:
self._resizeCreateContent()
if self.background is None:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
self.foo += 1
#self.y = numpy.cos(numpy.arange(0.0,1.0,0.1)+self.foo*0.1)
# Optimization on the blitting: we compute the box where the changes happen
changes_box = None
for i in range(len(self.lines)):
data = self.channels[i].getNext()
if len(data[1]) > 0:
if self.autolim:
print self.autolim[0], data[1], self.autolim[1]
self.autolim = [ min(self.autolim[0], min(data[1])), \
max(self.autolim[1], max(data[1])) ]
else:
self.autolim = [min(data[1]), min(data[1])]
if changes_box is None:
changes_box = Bbox.unit()
print '>>>>>>>>'
print data[0], data[1]
changes_box.update_from_data(numpy.array(data[0]), \
numpy.array(data[1]), ignore=changes_box.is_unit())
if not self._doRePlot and len(data[0]) > 0:
end = data[0][-1]
if end > self.begin + self.span:
self.begin += self.span
self._doRePlot = True
print 'do replot'
self.lines[i].set_data(data[0], data[1])
else:
self.lines[i].set_data([], [])
if not changes_box:
return
#self.canvas.restore_region(self.background)
for line in self.lines:
self.ax.draw_artist(line)
#print line.get_transform()
tr = line.get_transform()
changes_box_inframe = changes_box.transformed(tr)
box_padding = 5
(x, y, l, w) = changes_box_inframe.bounds
changes_box_inframe = Bbox.from_bounds(x-box_padding, \
y-box_padding, l+2*box_padding, w+2*box_padding)
#print
t0 = time.time()
self.canvas.blit(None)
#self.canvas.blit(changes_box_inframe)
self.blit_time += time.time() - t0
def _set_lim_and_transforms(self):
self.transAxes = BboxTransformTo(self.bbox)
# Transforms the x and y axis separately by a scale factor
# It is assumed that this part will have non-linear components
self.transScale = TransformWrapper(IdentityTransform())
# A (possibly non-linear) projection on the (already scaled)
# data. This one is aware of rmin
self.transProjection = self.PolarTransform(self)
# This one is not aware of rmin
self.transPureProjection = self.PolarTransform()
# An affine transformation on the data, generally to limit the
# range of the axes
self.transProjectionAffine = self.PolarAffine(self.transScale, self.viewLim)
# The complete data transformation stack -- from data all the
# way to display coordinates
self.transData = self.transScale + self.transProjection + \
(self.transProjectionAffine + self.transAxes)
# This is the transform for theta-axis ticks. It is
# equivalent to transData, except it always puts r == 1.0 at
# the edge of the axis circle.
self._xaxis_transform = (
self.transPureProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes)
# The theta labels are moved from radius == 0.0 to radius == 1.1
self._theta_label1_position = Affine2D().translate(0.0, 1.1)
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform)
self._theta_label2_position = Affine2D().translate(0.0, 1.0 / 1.1)
self._xaxis_text2_transform = (
self._theta_label2_position +
self._xaxis_transform)
# This is the transform for r-axis ticks. It scales the theta
# axis so the gridlines from 0.0 to 1.0, now go from 0.0 to
# 2pi.
self._yaxis_transform = (
Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData)
# The r-axis labels are put at an angle and padded in the r-direction
self._r_label1_position = Affine2D().translate(22.5, self._rpad)
self._yaxis_text1_transform = (
self._r_label1_position +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform
)
self._r_label2_position = Affine2D().translate(22.5, self._rpad)
self._yaxis_text2_transform = (
self._r_label2_position +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform
)
def draw_plot(self):
if self._doRePlot:
self._resizeCreateContent()
if self.background is None:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
self.foo += 1
#self.y = numpy.cos(numpy.arange(0.0,1.0,0.1)+self.foo*0.1)
# Optimization on the blitting: we compute the box where the changes happen
changes_box = None
for i in range(len(self.lines)):
data=self.channels[i].getNext()
if len(data[1])>0:
if self.autolim:
print self.autolim[0], data[1], self.autolim[1]
self.autolim = [ min(self.autolim[0], min(data[1])), \
max(self.autolim[1], max(data[1])) ]
else:
self.autolim = [ min(data[1]), min(data[1]) ]
if changes_box is None:
changes_box = Bbox.unit()
print '>>>>>>>>'
print data[0], data[1]
changes_box.update_from_data(numpy.array(data[0]), \
numpy.array(data[1]), ignore=changes_box.is_unit())
if not self._doRePlot and len(data[0]) > 0 :
end = data[0][-1]
if end > self.begin+self.span:
self.begin += self.span
self._doRePlot = True
print 'do replot'
self.lines[i].set_data(data[0], data[1])
else:
self.lines[i].set_data([], [])
if not changes_box:
return
#self.canvas.restore_region(self.background)
for line in self.lines:
self.ax.draw_artist(line)
#print line.get_transform()
tr = line.get_transform()
changes_box_inframe = changes_box.transformed(tr)
box_padding = 5
(x,y,l,w) = changes_box_inframe.bounds
changes_box_inframe = Bbox.from_bounds(x-box_padding, \
y-box_padding, l+2*box_padding, w+2*box_padding)
#print
t0 = time.time()
self.canvas.blit(None)
#self.canvas.blit(changes_box_inframe)
self.blit_time += time.time() - t0
def _set_lim_and_transforms(self):
self.transAxes = BboxTransformTo(self.bbox)
# Transforms the x and y axis separately by a scale factor
# It is assumed that this part will have non-linear components
self.transScale = TransformWrapper(IdentityTransform())
# A (possibly non-linear) projection on the (already scaled) data
self.transProjection = self.PolarTransform()
# An affine transformation on the data, generally to limit the
# range of the axes
self.transProjectionAffine = self.PolarAffine(self.transScale, self.viewLim)
# The complete data transformation stack -- from data all the
# way to display coordinates
self.transData = self.transScale + IdentityTransform() + \
(self.transProjectionAffine + self.transAxes)
# old version of the previous line
self.transGrid = self.transScale + self.transProjection + \
(self.transProjectionAffine + self.transAxes)
# This is the transform for theta-axis ticks. It is
# equivalent to transData, except it always puts r == 1.0 at
# the edge of the axis circle.
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes)
# The theta labels are moved from radius == 0.0 to radius == 1.1
self._theta_label1_position = Affine2D().translate(0.0, 1.1)
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform)
self._theta_label2_position = Affine2D().translate(0.0, 1.0 / 1.1)
self._xaxis_text2_transform = (
self._theta_label2_position +
self._xaxis_transform)
# This is the transform for r-axis ticks. It scales the theta
# axis so the gridlines from 0.0 to 1.0, now go from 0.0 to
# 2pi.
self._yaxis_transform = (
Affine2D().scale(npy.pi * 2.0, 1.0) +
self.transGrid)
# The r-axis labels are put at an angle and padded in the r-direction
self._r_label1_position = Affine2D().translate(22.5, self._rpad)
self._yaxis_text1_transform = (
self._r_label1_position +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform
)
self._r_label2_position = Affine2D().translate(22.5, self._rpad)
self._yaxis_text2_transform = (
self._r_label2_position +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform
)
def connect_bbox(bbox1, bbox2, loc1, loc2=None):
"""
Helper function to obtain a Path from one bbox to another.
Parameters
----------
bbox1, bbox2 : `matplotlib.transforms.Bbox`
Bounding boxes to connect.
loc1 : {1, 2, 3, 4}
Corner of *bbox1* to use. Valid values are::
'upper right' : 1,
'upper left' : 2,
'lower left' : 3,
'lower right' : 4
loc2 : {1, 2, 3, 4}, optional
Corner of *bbox2* to use. If None, defaults to *loc1*.
Valid values are::
'upper right' : 1,
'upper left' : 2,
'lower left' : 3,
'lower right' : 4
Returns
-------
path : `matplotlib.path.Path`
A line segment from the *loc1* corner of *bbox1* to the *loc2*
corner of *bbox2*.
"""
if isinstance(bbox1, Rectangle):
bbox1 = TransformedBbox(Bbox.unit(), bbox1.get_transform())
if isinstance(bbox2, Rectangle):
bbox2 = TransformedBbox(Bbox.unit(), bbox2.get_transform())
if loc2 is None:
loc2 = loc1
x1, y1 = BboxConnector.get_bbox_edge_pos(bbox1, loc1)
x2, y2 = BboxConnector.get_bbox_edge_pos(bbox2, loc2)
return Path([[x1, y1], [x2, y2]])
def _set_lim_and_transforms(self):
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.GlobeCrossSectionTransform(GlobeCrossSectionAxes.RESOLUTION)
self.transData = self.transScale + self.transProjection + (self.transProjectionAffine + self.transAxes)
self._xaxis_transform = (
self.transProjection + self.PolarAffine(IdentityTransform(), Bbox.unit()) + self.transAxes
)
self._xaxis_text1_transform = self._theta_label1_position + self._xaxis_transform
self._yaxis_transform = Affine2D().scale(num.pi * 2.0, 1.0) + self.transData
self._yaxis_text1_transform = (
self._r_label1_position + Affine2D().scale(1.0 / 360.0, 1.0) + self._yaxis_transform
)
def _set_lim_and_transforms(self):
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.GalPolarTransform()
self.transData = (self.transScale + self.transProjection +
(self.transProjectionAffine + self.transAxes))
self._xaxis_transform = (self.transProjection + self.PolarAffine(
IdentityTransform(), Bbox.unit()) + self.transAxes)
self._xaxis_text1_transform = (self._theta_label1_position +
self._xaxis_transform)
self._yaxis_transform = (Affine2D().scale(sc.pi * 2.0, 1.0) +
self.transData)
self._yaxis_text1_transform = (self._r_label1_position +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform)
def get_size(self):
factor = 1.
if self.unit == "points":
factor = self.ax.figure.dpi / 72.
elif self.unit[:4] == "axes":
b = TransformedBbox(Bbox.unit(), self.ax.transAxes)
dic = {
"max": max(b.width, b.height),
"min": min(b.width, b.height),
"width": b.width,
"height": b.height
}
factor = dic[self.unit[5:]]
return self.size * factor
def _set_lim_and_transforms(self):
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.NorthPolarTransform()
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes)
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform)
self._yaxis_transform = (
Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData)
def _set_lim_and_transforms(self):
"""
"""
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.DipPolarTransform()
# pylint: attribute-defined-outside-init,invalid-name
self.transData = (self.transScale + self.transProjection +
(self.transProjectionAffine + self.transAxes))
# pylint: attribute-defined-outside-init,invalid-name
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) + self.transAxes
) # pylint: attribute-defined-outside-init
self._xaxis_text1_transform = (
self._theta_label1_position + self._xaxis_transform
) # pylint: attribute-defined-outside-init
self._yaxis_transform = (Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData
) # pylint: attribute-defined-outside-init
self._yaxis_text1_transform = (
Affine2D().scale(1.0 / 360.0, 1.0) + self._yaxis_transform
) # pylint: attribute-defined-outside-init
def _set_lim_and_transforms(self):
"""
"""
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.DipPolarTransform()
# pylint: attribute-defined-outside-init,invalid-name
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
# pylint: attribute-defined-outside-init,invalid-name
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes) # pylint: attribute-defined-outside-init
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform) # pylint: attribute-defined-outside-init
self._yaxis_transform = (
Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData) # pylint: attribute-defined-outside-init
self._yaxis_text1_transform = (
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform) # pylint: attribute-defined-outside-init
def draw_plot(self):
if self._doRePlot:
self._resizeCreateContent()
if self.background is None:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
changes_box = None
#try:
for i in range(len(self.lines)):
data=self.channels[i].getNext()
if len(data[0]) > 0:
if len(data[0]) != len(data[1]):
print 'incoherent data', len(data[0]), len(data[1])
return
# Add new points
#print type(self.cached_datax[i]), type(data[0])
if isinstance(data[0], numpy.ndarray):
self.cached_datax[i] += list(data[0])
self.cached_datay[i] += data[1].tolist()
else:
self.cached_datax[i] += data[0]
self.cached_datay[i] += data[1]
if len(data[1])>0:
if self.autolim:
self.autolim = [ min(self.autolim[0], min(data[1])), \
max(self.autolim[1], max(data[1])) ]
else:
self.autolim = [ min(data[1]), min(data[1]) ]
if changes_box is None:
changes_box = Bbox.unit()
changes_box.update_from_data(numpy.array(data[0]), \
numpy.array(data[1]), ignore=changes_box.is_unit())
if not self._doRePlot and len(data[0]) > 0 :
end = data[0][-1]
if end > self.begin+self.span:
self.begin = end
self._doRePlot = True
#print 'C'
#self.cached_datax[i] += (data[0])
#self.cached_datay[i] += (data[1])
#print self.cached_datay[i], self.cached_datax[i]
self.lines[i].set_data(self.cached_datax[i], \
self.cached_datay[i])
#self.lines[i].set_data(data[0], data[1])
else:
self.lines[i].set_data([], [])
if not changes_box:
return
for line in self.lines:
self.ax.draw_artist(line)
tr = line.get_transform()
changes_box_inframe = changes_box.transformed(tr)
box_xpadding = 20
box_ypadding = 100
(x,y,l,w) = changes_box_inframe.bounds
changes_box_inframe = Bbox.from_bounds(x-box_xpadding, \
y-box_ypadding, l+2*box_xpadding, w+2*box_ypadding)
#self.canvas.blit(None)
self.canvas.blit(changes_box_inframe)
def draw_plot(self):
if self._doRePlot:
self._resizeCreateContent()
if self.background is None:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
changes_box = None
#try:
for i in range(len(self.lines)):
data = self.channels[i].getNext()
if len(data[0]) > 0:
if len(data[0]) != len(data[1]):
print 'incoherent data', len(data[0]), len(data[1])
return
# Add new points
#print type(self.cached_datax[i]), type(data[0])
if isinstance(data[0], numpy.ndarray):
self.cached_datax[i] += list(data[0])
self.cached_datay[i] += data[1].tolist()
else:
self.cached_datax[i] += data[0]
self.cached_datay[i] += data[1]
if len(data[1]) > 0:
if self.autolim:
self.autolim = [ min(self.autolim[0], min(data[1])), \
max(self.autolim[1], max(data[1])) ]
else:
self.autolim = [min(data[1]), min(data[1])]
if changes_box is None:
changes_box = Bbox.unit()
changes_box.update_from_data(numpy.array(data[0]), \
numpy.array(data[1]), ignore=changes_box.is_unit())
if not self._doRePlot and len(data[0]) > 0:
end = data[0][-1]
if end > self.begin + self.span:
self.begin = end
self._doRePlot = True
#print 'C'
#self.cached_datax[i] += (data[0])
#self.cached_datay[i] += (data[1])
#print self.cached_datay[i], self.cached_datax[i]
self.lines[i].set_data(self.cached_datax[i], \
self.cached_datay[i])
#self.lines[i].set_data(data[0], data[1])
else:
self.lines[i].set_data([], [])
if not changes_box:
return
for line in self.lines:
self.ax.draw_artist(line)
tr = line.get_transform()
changes_box_inframe = changes_box.transformed(tr)
box_xpadding = 20
box_ypadding = 100
(x, y, l, w) = changes_box_inframe.bounds
changes_box_inframe = Bbox.from_bounds(x-box_xpadding, \
y-box_ypadding, l+2*box_xpadding, w+2*box_ypadding)
#self.canvas.blit(None)
self.canvas.blit(changes_box_inframe)
def draw_grid(*,
max_row: int,
max_column: int,
clued_locations: Set[Location],
location_to_entry: Dict[Location, str],
location_to_clue_numbers: Dict[Location, Sequence[str]],
top_bars: Set[Location],
left_bars: Set[Location],
shading: Dict[Location, str] = {},
rotation: Dict[Location, str] = {},
circles: Set[Location] = set(),
**args: Any) -> None:
_axes = args.get('axes')
if _axes:
axes = cast(Axes, _axes)
else:
_, axes = plt.subplots(1, 1, figsize=(8, 11), dpi=100)
# Set (1,1) as the top-left corner, and (max_column, max_row) as the bottom right.
axes.axis([1, max_column, max_row, 1])
axes.axis('equal')
axes.axis('off')
# Fill in the shaded squares
for row, column in itertools.product(range(1, max_row),
range(1, max_column)):
if (row, column) in shading:
color = shading[row, column]
axes.add_patch(
patches.Rectangle((column, row),
1,
1,
facecolor=color,
linewidth=0))
# elif (row, column) not in clued_locations:
# axes.add_patch(patches.Rectangle((column, row), 1, 1, facecolor='black', linewidth=0))
for row, column in itertools.product(range(1, max_row + 1),
range(1, max_column + 1)):
this_exists = (row, column) in clued_locations
left_exists = (row, column - 1) in clued_locations
above_exists = (row - 1, column) in clued_locations
if this_exists or left_exists:
width = 5 if this_exists != left_exists or (
row, column) in left_bars else None
axes.plot([column, column], [row, row + 1],
'black',
linewidth=width)
if this_exists or above_exists:
width = 5 if this_exists != above_exists or (
row, column) in top_bars else None
axes.plot([column, column + 1], [row, row],
'black',
linewidth=width)
if (row, column) in shading:
color = shading[row, column]
axes.add_patch(
patches.Rectangle((column, row),
1,
1,
facecolor=color,
linewidth=0))
for row, column in circles:
circle = plt.Circle((column + .5, row + .5),
radius=.4,
linewidth=2,
fill=False,
facecolor='black')
axes.add_patch(circle)
scaled_box = Bbox.unit().transformed(axes.transData -
axes.figure.dpi_scale_trans)
inches_per_data = min(abs(scaled_box.width), abs(scaled_box.height))
points_per_data = 72 * inches_per_data
# Fill in the values
for (row, column), entry in location_to_entry.items():
axes.text(column + 1 / 2,
row + 1 / 2,
entry,
fontsize=points_per_data / 2,
fontweight='bold',
fontfamily="sans-serif",
verticalalignment='center',
horizontalalignment='center',
rotation=rotation.get((row, column), 0))
# Fill in the clue numbers
for (row, column), clue_numbers in location_to_clue_numbers.items():
font_info = dict(fontsize=points_per_data / 4, fontfamily="sans-serif")
for index, text in enumerate(clue_numbers):
if index == 0:
axes.text(column + .05,
row + .05,
text,
verticalalignment='top',
horizontalalignment='left',
**font_info)
elif index == 1:
axes.text(column + .95,
row + .05,
text,
verticalalignment='top',
horizontalalignment='right',
**font_info)
elif index == 2:
axes.text(column + .05,
row + .95,
text,
verticalalignment='bottom',
horizontalalignment='left',
**font_info)
elif index == 3:
axes.text(column + .95,
row + .95,
text,
verticalalignment='bottom',
horizontalalignment='right',
**font_info)
if not _axes:
plt.show()
