def solid_shapes():
drawing = Drawing(width=400, height=200)
rectangle = Rect(10, 10, 100, 100)
rectangle.fillColor = colors.blue
drawing.add(rectangle)
ellipse = Ellipse(100, 50, 50, 25)
ellipse.fillColor = colors.red
drawing.add(ellipse)
circle = Circle(50, 170, 25)
circle.fillColor = colors.green
drawing.add(circle)
wedge = Wedge(150, 150, 65,
startangledegrees=0,
endangledegrees=45)
wedge.fillColor = colors.yellow
drawing.add(wedge)
poly = Polygon(points=[250, 150,
280, 150,
280, 100,
250, 100
])
poly.fillColor = colors.purple
drawing.add(poly)
drawing.save(formats=['pdf'], outDir='.', fnRoot='solid_shapes')
def _draw_segment(self, cur_drawing):
"""Draw a half circle representing the end of a linear chromosome.
"""
# set the coordinates of the segment -- it'll take up the MIDDLE part
# of the space we have.
width = (self.end_x_position - self.start_x_position) \
* self.chr_percent
height = self.start_y_position - self.end_y_position
center_x = 0.5 * (self.end_x_position + self.start_x_position)
start_x = center_x - 0.5 * width
if self._inverted:
center_y = self.start_y_position
start_angle = 180
end_angle = 360
else:
center_y = self.end_y_position
start_angle = 0
end_angle = 180
cap_wedge = Wedge(center_x, center_y, width / 2,
start_angle, end_angle, height)
cap_wedge.strokeColor = None
cap_wedge.fillColor = self.fill_color
cur_drawing.add(cap_wedge)
# Now draw an arc for the curved edge of the wedge,
# omitting the flat end.
cap_arc = ArcPath()
cap_arc.addArc(center_x, center_y, width / 2,
start_angle, end_angle, height)
cur_drawing.add(cap_arc)
def _draw_segment(self, cur_drawing):
"""Draw a half circle representing the end of a linear chromosome."""
# set the coordinates of the segment -- it'll take up the MIDDLE part
# of the space we have.
width = (self.end_x_position - self.start_x_position) \
* self.chr_percent
height = self.start_y_position - self.end_y_position
center_x = 0.5 * (self.end_x_position + self.start_x_position)
start_x = center_x - 0.5 * width
if self._inverted:
center_y = self.start_y_position
start_angle = 180
end_angle = 360
else:
center_y = self.end_y_position
start_angle = 0
end_angle = 180
cap_wedge = Wedge(center_x, center_y, width / 2,
start_angle, end_angle, height)
cap_wedge.strokeColor = None
cap_wedge.fillColor = self.fill_color
cur_drawing.add(cap_wedge)
# Now draw an arc for the curved edge of the wedge,
# omitting the flat end.
cap_arc = ArcPath()
cap_arc.addArc(center_x, center_y, width / 2,
start_angle, end_angle, height)
cur_drawing.add(cap_arc)
def sample1():
"Make up something from the individual Sectors"
d = Drawing(400, 400)
g = Group()
s1 = Wedge(centerx=200,
centery=200,
radius=150,
startangledegrees=0,
endangledegrees=120,
radius1=100)
s1.fillColor = colors.red
s1.strokeColor = None
d.add(s1)
s2 = Wedge(centerx=200,
centery=200,
radius=150,
startangledegrees=120,
endangledegrees=240,
radius1=100)
s2.fillColor = colors.green
s2.strokeColor = None
d.add(s2)
s3 = Wedge(centerx=200,
centery=200,
radius=150,
startangledegrees=240,
endangledegrees=260,
radius1=100)
s3.fillColor = colors.blue
s3.strokeColor = None
d.add(s3)
s4 = Wedge(centerx=200,
centery=200,
radius=150,
startangledegrees=260,
endangledegrees=360,
radius1=100)
s4.fillColor = colors.gray
s4.strokeColor = None
d.add(s4)
return d
def sample1():
"Make up something from the individual Sectors"
d = Drawing(400, 400)
g = Group()
s1 = Wedge(centerx=200, centery=200, radius=150, startangledegrees=0, endangledegrees=120, radius1=100)
s1.fillColor = colors.red
s1.strokeColor = None
d.add(s1)
s2 = Wedge(centerx=200, centery=200, radius=150, startangledegrees=120, endangledegrees=240, radius1=100)
s2.fillColor = colors.green
s2.strokeColor = None
d.add(s2)
s3 = Wedge(centerx=200, centery=200, radius=150, startangledegrees=240, endangledegrees=260, radius1=100)
s3.fillColor = colors.blue
s3.strokeColor = None
d.add(s3)
s4 = Wedge(centerx=200, centery=200, radius=150, startangledegrees=260, endangledegrees=360, radius1=100)
s4.fillColor = colors.gray
s4.strokeColor = None
d.add(s4)
return d
def _draw_segment(self, cur_drawing):
"""Draw a half circle representing the end of a linear chromosome.
"""
# set the coordinates of the segment -- it'll take up the left part
# of the space we have.
width = (self.end_x_position - self.start_x_position) \
* self.chr_percent
height = self.start_y_position - self.end_y_position
center_x = self.start_x_position + width / 2
if self._inverted:
center_y = self.start_y_position
start_angle = 180
end_angle = 360
else:
center_y = self.end_y_position
start_angle = 0
end_angle = 180
cap_wedge = Wedge(center_x, center_y, width / 2,
start_angle, end_angle, height / 2)
cap_wedge.fillColor = self.fill_color
cur_drawing.add(cap_wedge)
# draw a line to cover up the the bottom part of the wedge
if self._inverted:
cover_line = Line(self.start_x_position, self.start_y_position,
self.start_x_position + width,
self.start_y_position)
else:
cover_line = Line(self.start_x_position, self.end_y_position,
self.start_x_position + width,
self.end_y_position)
if self.fill_color is not None:
cover_color = self.fill_color
else:
cover_color = colors.white
cover_line.strokeColor = cover_color
cur_drawing.add(cover_line)
def _draw_segment(self, cur_drawing):
"""Draw a half circle representing the end of a linear chromosome.
"""
# set the coordinates of the segment -- it'll take up the left part
# of the space we have.
width = (self.end_x_position - self.start_x_position) \
* self.chr_percent
height = self.start_y_position - self.end_y_position
center_x = self.start_x_position + width / 2
if self._inverted:
center_y = self.start_y_position
start_angle = 180
end_angle = 360
else:
center_y = self.end_y_position
start_angle = 0
end_angle = 180
cap_wedge = Wedge(center_x, center_y, width / 2, start_angle,
end_angle, height / 2)
cap_wedge.fillColor = self.fill_color
cur_drawing.add(cap_wedge)
# draw a line to cover up the the bottom part of the wedge
if self._inverted:
cover_line = Line(self.start_x_position, self.start_y_position,
self.start_x_position + width,
self.start_y_position)
else:
cover_line = Line(self.start_x_position, self.end_y_position,
self.start_x_position + width,
self.end_y_position)
if self.fill_color is not None:
cover_color = self.fill_color
else:
cover_color = colors.white
cover_line.strokeColor = cover_color
cur_drawing.add(cover_line)
def makeWedges(self):
angles = self.makeAngles()
n = len(angles)
labels = _fixLabels(self.labels,n)
self._seriesCount = n
styleCount = len(self.slices)
plMode = self.pointerLabelMode
if plMode:
checkLabelOverlap = False
PL=self.makePointerLabels(angles,plMode)
xradius = PL.xradius
yradius = PL.yradius
centerx = PL.centerx
centery = PL.centery
PL_data = PL.data
gSN = lambda i: ''
else:
xradius = self.width*0.5
yradius = self.height*0.5
centerx = self.x + xradius
centery = self.y + yradius
if self.xradius: xradius = self.xradius
if self.yradius: yradius = self.yradius
if self.sameRadii: xradius=yradius=min(xradius,yradius)
checkLabelOverlap = self.checkLabelOverlap
gSN = lambda i: self.getSeriesName(i,'')
g = Group()
g_add = g.add
if checkLabelOverlap:
L = []
L_add = L.append
else:
L_add = g_add
for i,(a1,a2) in angles:
if a2 is None: continue
#if we didn't use %stylecount here we'd end up with the later wedges
#all having the default style
wedgeStyle = self.slices[i%styleCount]
if not wedgeStyle.visible: continue
# is it a popout?
cx, cy = centerx, centery
text = gSN(i)
popout = wedgeStyle.popout
if text or popout:
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle/_180_pi
cosAA = cos(aveAngleRadians)
sinAA = sin(aveAngleRadians)
if popout:
# pop out the wedge
cx = centerx + popout*cosAA
cy = centery + popout*sinAA
if n > 1:
theWedge = Wedge(cx, cy, xradius, a1, a2, yradius=yradius)
elif n==1:
theWedge = Ellipse(cx, cy, xradius, yradius)
theWedge.fillColor = wedgeStyle.fillColor
theWedge.strokeColor = wedgeStyle.strokeColor
theWedge.strokeWidth = wedgeStyle.strokeWidth
theWedge.strokeDashArray = wedgeStyle.strokeDashArray
g_add(theWedge)
if wedgeStyle.label_visible:
if text:
labelRadius = wedgeStyle.labelRadius
rx = xradius*labelRadius
ry = yradius*labelRadius
labelX = cx + rx*cosAA
labelY = cy + ry*sinAA
_addWedgeLabel(self,text,L_add,averageAngle,labelX,labelY,wedgeStyle)
if checkLabelOverlap:
l = L[-1]
l._origdata = { 'x': labelX, 'y':labelY, 'angle': averageAngle,
'rx': rx, 'ry':ry, 'cx':cx, 'cy':cy,
'bounds': l.getBounds(),
}
elif plMode and PL_data:
l = PL_data[i]
if l:
data = l._origdata
sinM = data['smid']
cosM = data['cmid']
lX = cx + xradius*cosM
lY = cy + yradius*sinM
lpel = wedgeStyle.label_pointer_elbowLength
lXi = lX + lpel*cosM
lYi = lY + lpel*sinM
L_add(PolyLine((lX,lY,lXi,lYi,l.x,l.y),
strokeWidth=wedgeStyle.label_pointer_strokeWidth,
strokeColor=wedgeStyle.label_pointer_strokeColor))
L_add(l)
if checkLabelOverlap and L:
fixLabelOverlaps(L)
map(g_add,L)
return g
def makeSectors(self):
# normalize slice data
if type(self.data) in (ListType, TupleType) and type(
self.data[0]) in (ListType, TupleType):
#it's a nested list, more than one sequence
normData = []
n = []
for l in self.data:
t = self.normalizeData(l)
normData.append(t)
n.append(len(t))
self._seriesCount = max(n)
else:
normData = self.normalizeData(self.data)
n = len(normData)
self._seriesCount = n
#labels
checkLabelOverlap = self.checkLabelOverlap
L = []
L_add = L.append
if self.labels is None:
labels = []
if type(n) not in (ListType, TupleType):
labels = [''] * n
else:
for m in n:
labels = list(labels) + [''] * m
else:
labels = self.labels
#there's no point in raising errors for less than enough labels if
#we silently create all for the extreme case of no labels.
if type(n) not in (ListType, TupleType):
i = n - len(labels)
if i > 0:
labels = list(labels) + [''] * i
else:
tlab = 0
for m in n:
tlab += m
i = tlab - len(labels)
if i > 0:
labels = list(labels) + [''] * i
xradius = self.width / 2.0
yradius = self.height / 2.0
centerx = self.x + xradius
centery = self.y + yradius
if self.direction == "anticlockwise":
whichWay = 1
else:
whichWay = -1
g = Group()
startAngle = self.startAngle #% 360
styleCount = len(self.slices)
if type(self.data[0]) in (ListType, TupleType):
#multi-series doughnut
iradius = (self.height / 5.0) / len(self.data)
for sn, series in enumerate(normData):
for i, angle in enumerate(series):
endAngle = (startAngle + (angle * whichWay)) #% 360
if abs(startAngle - endAngle) < 1e-5:
startAngle = endAngle
continue
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
startAngle = endAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if type(n) in (ListType, TupleType):
theSector = Wedge(
cx,
cy,
xradius + (sn * iradius) - iradius,
a1,
a2,
yradius=yradius + (sn * iradius) - iradius,
radius1=yradius + (sn * iradius) - (2 * iradius))
else:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
radius1=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
if sn == 0:
text = self.getSeriesName(i, '')
if text:
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
rx = xradius * labelRadius
ry = yradius * labelRadius
labelX = centerx + (0.5 * self.width *
cos(aveAngleRadians) *
labelRadius)
labelY = centery + (0.5 * self.height *
sin(aveAngleRadians) *
labelRadius)
l = _addWedgeLabel(self, text, averageAngle,
labelX, labelY, sectorStyle)
if checkLabelOverlap:
l._origdata = {
'x': labelX,
'y': labelY,
'angle': averageAngle,
'rx': rx,
'ry': ry,
'cx': cx,
'cy': cy,
'bounds': l.getBounds(),
}
L_add(l)
else:
#single series doughnut
iradius = self.height / 5.0
for i, angle in enumerate(normData):
endAngle = (startAngle + (angle * whichWay)) #% 360
if abs(startAngle - endAngle) < 1e-5:
startAngle = endAngle
continue
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
startAngle = endAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if n > 1:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
radius1=iradius)
elif n == 1:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
iradius=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
# now draw a label
if labels[i] != "":
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
labelX = centerx + (0.5 * self.width *
cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height *
sin(aveAngleRadians) * labelRadius)
rx = xradius * labelRadius
ry = yradius * labelRadius
l = _addWedgeLabel(self, labels[i], averageAngle, labelX,
labelY, sectorStyle)
if checkLabelOverlap:
l._origdata = {
'x': labelX,
'y': labelY,
'angle': averageAngle,
'rx': rx,
'ry': ry,
'cx': cx,
'cy': cy,
'bounds': l.getBounds(),
}
L_add(l)
if checkLabelOverlap and L:
fixLabelOverlaps(L)
for l in L:
g.add(l)
return g
def makeWedges(self):
# normalize slice data
normData = self.normalizeData()
n = len(normData)
labels = _fixLabels(self.labels,n)
xradius = self.width/2.0
yradius = self.height/2.0
centerx = self.x + xradius
centery = self.y + yradius
if self.direction == "anticlockwise":
whichWay = 1
else:
whichWay = -1
g = Group()
i = 0
styleCount = len(self.slices)
startAngle = self.startAngle #% 360
for angle in normData:
endAngle = (startAngle + (angle * whichWay)) #% 360
if abs(startAngle-endAngle)>=1e-5:
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
#if we didn't use %stylecount here we'd end up with the later wedges
#all having the default style
wedgeStyle = self.slices[i%styleCount]
# is it a popout?
cx, cy = centerx, centery
if wedgeStyle.popout <> 0:
# pop out the wedge
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle * pi/180.0
popdistance = wedgeStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if n > 1:
theWedge = Wedge(cx, cy, xradius, a1, a2, yradius=yradius)
elif n==1:
theWedge = Ellipse(cx, cy, xradius, yradius)
theWedge.fillColor = wedgeStyle.fillColor
theWedge.strokeColor = wedgeStyle.strokeColor
theWedge.strokeWidth = wedgeStyle.strokeWidth
theWedge.strokeDashArray = wedgeStyle.strokeDashArray
g.add(theWedge)
text = labels[i]
if text:
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle*pi/180.0
labelRadius = wedgeStyle.labelRadius
labelX = cx + (0.5 * self.width * cos(aveAngleRadians) * labelRadius)
labelY = cy + (0.5 * self.height * sin(aveAngleRadians) * labelRadius)
_addWedgeLabel(self,text,g.add,averageAngle,labelX,labelY,wedgeStyle)
startAngle = endAngle
i = i + 1
return g
def makeSectors(self):
# normalize slice data
if type(self.data) in (ListType, TupleType) and type(self.data[0]) in (ListType, TupleType):
# it's a nested list, more than one sequence
normData = []
n = []
for l in self.data:
t = self.normalizeData(l)
normData.append(t)
n.append(len(t))
else:
normData = self.normalizeData(self.data)
n = len(normData)
# labels
if self.labels is None:
labels = []
if type(n) not in (ListType, TupleType):
labels = [""] * n
else:
for m in n:
labels = list(labels) + [""] * m
else:
labels = self.labels
# there's no point in raising errors for less than enough errors if
# we silently create all for the extreme case of no labels.
if type(n) not in (ListType, TupleType):
i = n - len(labels)
if i > 0:
labels = list(labels) + [""] * i
else:
tlab = 0
for m in n:
tlab = tlab + m
i = tlab - len(labels)
if i > 0:
labels = list(labels) + [""] * i
xradius = self.width / 2.0
yradius = self.height / 2.0
centerx = self.x + xradius
centery = self.y + yradius
if self.direction == "anticlockwise":
whichWay = 1
else:
whichWay = -1
g = Group()
i = 0
sn = 0
startAngle = self.startAngle #% 360
if type(self.data[0]) in (ListType, TupleType):
# multi-series doughnut
styleCount = len(self.slices)
iradius = (self.height / 5.0) / len(self.data)
for series in normData:
for angle in series:
endAngle = startAngle + (angle * whichWay) #% 360
if abs(startAngle - endAngle) >= 1e-5:
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
# if we didn't use %stylecount here we'd end up with the later sectors
# all having the default style
sectorStyle = self.slices[i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if type(n) in (ListType, TupleType):
theSector = Wedge(
cx,
cy,
xradius + (sn * iradius) - iradius,
a1,
a2,
yradius=yradius + (sn * iradius) - iradius,
radius1=yradius + (sn * iradius) - (2 * iradius),
)
else:
theSector = Wedge(cx, cy, xradius, a1, a2, yradius=yradius, radius1=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
startAngle = endAngle
if labels[i] != "":
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
labelX = centerx + (0.5 * self.width * cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height * sin(aveAngleRadians) * labelRadius)
theLabel = String(labelX, labelY, labels[i])
theLabel.textAnchor = "middle"
theLabel.fontSize = sectorStyle.fontSize
theLabel.fontName = sectorStyle.fontName
theLabel.fillColor = sectorStyle.fontColor
g.add(theLabel)
i = i + 1
sn = sn + 1
else:
# single series doughnut
styleCount = len(self.slices)
iradius = self.height / 5.0
for angle in normData:
endAngle = startAngle + (angle * whichWay) #% 360
if abs(startAngle - endAngle) >= 1e-5:
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
# if we didn't use %stylecount here we'd end up with the later sectors
# all having the default style
sectorStyle = self.slices[i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if n > 1:
theSector = Wedge(cx, cy, xradius, a1, a2, yradius=yradius, radius1=iradius)
elif n == 1:
theSector = Wedge(cx, cy, xradius, a1, a2, yradius=yradius, iradius=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
# now draw a label
if labels[i] != "":
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
labelX = centerx + (0.5 * self.width * cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height * sin(aveAngleRadians) * labelRadius)
theLabel = String(labelX, labelY, labels[i])
theLabel.textAnchor = "middle"
theLabel.fontSize = sectorStyle.fontSize
theLabel.fontName = sectorStyle.fontName
theLabel.fillColor = sectorStyle.fontColor
g.add(theLabel)
startAngle = endAngle
i = i + 1
return g
def makeSectors(self):
# normalize slice data
data = self.data
multi = isListOfListOfNoneOrNumber(data)
if multi:
#it's a nested list, more than one sequence
normData = []
n = []
for l in data:
t = self.normalizeData(l)
normData.append(t)
n.append(len(t))
self._seriesCount = max(n)
else:
normData = self.normalizeData(data)
n = len(normData)
self._seriesCount = n
#labels
checkLabelOverlap = self.checkLabelOverlap
L = []
L_add = L.append
labels = self.labels
if labels is None:
labels = []
if not multi:
labels = [''] * n
else:
for m in n:
labels = list(labels) + [''] * m
else:
#there's no point in raising errors for less than enough labels if
#we silently create all for the extreme case of no labels.
if not multi:
i = n - len(labels)
if i > 0:
labels = list(labels) + [''] * i
else:
tlab = 0
for m in n:
tlab += m
i = tlab - len(labels)
if i > 0:
labels = list(labels) + [''] * i
self.labels = labels
xradius = self.width / 2.0
yradius = self.height / 2.0
centerx = self.x + xradius
centery = self.y + yradius
if self.direction == "anticlockwise":
whichWay = 1
else:
whichWay = -1
g = Group()
startAngle = self.startAngle #% 360
styleCount = len(self.slices)
irf = self.innerRadiusFraction
if multi:
#multi-series doughnut
ndata = len(data)
if irf is None:
yir = (yradius / 2.5) / ndata
xir = (xradius / 2.5) / ndata
else:
yir = yradius * irf
xir = xradius * irf
ydr = (yradius - yir) / ndata
xdr = (xradius - xir) / ndata
for sn, series in enumerate(normData):
for i, angle in enumerate(series):
endAngle = (startAngle + (angle * whichWay)) #% 360
aa = abs(startAngle - endAngle)
if aa < 1e-5:
startAngle = endAngle
continue
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
startAngle = endAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[sn, i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
yr1 = yir + sn * ydr
yr = yr1 + ydr
xr1 = xir + sn * xdr
xr = xr1 + xdr
if len(series) > 1:
theSector = Wedge(cx,
cy,
xr,
a1,
a2,
yradius=yr,
radius1=xr1,
yradius1=yr1)
else:
theSector = Wedge(cx,
cy,
xr,
a1,
a2,
yradius=yr,
radius1=xr1,
yradius1=yr1,
annular=True)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
shader = sectorStyle.shadingKind
if shader:
nshades = aa / float(sectorStyle.shadingAngle)
if nshades > 1:
shader = colors.Whiter if shader == 'lighten' else colors.Blacker
nshades = 1 + int(nshades)
shadingAmount = 1 - sectorStyle.shadingAmount
if sectorStyle.shadingDirection == 'normal':
dsh = (1 - shadingAmount) / float(nshades - 1)
shf1 = shadingAmount
else:
dsh = (shadingAmount - 1) / float(nshades - 1)
shf1 = 1
shda = (a2 - a1) / float(nshades)
shsc = sectorStyle.fillColor
theSector.fillColor = None
for ish in range(nshades):
sha1 = a1 + ish * shda
sha2 = a1 + (ish + 1) * shda
shc = shader(shsc, shf1 + dsh * ish)
if len(series) > 1:
shSector = Wedge(cx,
cy,
xr,
sha1,
sha2,
yradius=yr,
radius1=xr1,
yradius1=yr1)
else:
shSector = Wedge(cx,
cy,
xr,
sha1,
sha2,
yradius=yr,
radius1=xr1,
yradius1=yr1,
annular=True)
shSector.fillColor = shc
shSector.strokeColor = None
shSector.strokeWidth = 0
g.add(shSector)
g.add(theSector)
if sn == 0 and sectorStyle.visible and sectorStyle.label_visible:
text = self.getSeriesName(i, '')
if text:
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
rx = xradius * labelRadius
ry = yradius * labelRadius
labelX = centerx + (0.5 * self.width *
cos(aveAngleRadians) *
labelRadius)
labelY = centery + (0.5 * self.height *
sin(aveAngleRadians) *
labelRadius)
l = _addWedgeLabel(self, text, averageAngle,
labelX, labelY, sectorStyle)
if checkLabelOverlap:
l._origdata = {
'x': labelX,
'y': labelY,
'angle': averageAngle,
'rx': rx,
'ry': ry,
'cx': cx,
'cy': cy,
'bounds': l.getBounds(),
}
L_add(l)
else:
#single series doughnut
if irf is None:
yir = yradius / 2.5
xir = xradius / 2.5
else:
yir = yradius * irf
xir = xradius * irf
for i, angle in enumerate(normData):
endAngle = (startAngle + (angle * whichWay)) #% 360
aa = abs(startAngle - endAngle)
if aa < 1e-5:
startAngle = endAngle
continue
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
startAngle = endAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if n > 1:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
radius1=xir,
yradius1=yir)
elif n == 1:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
radius1=xir,
yradius1=yir,
annular=True)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
shader = sectorStyle.shadingKind
if shader:
nshades = aa / float(sectorStyle.shadingAngle)
if nshades > 1:
shader = colors.Whiter if shader == 'lighten' else colors.Blacker
nshades = 1 + int(nshades)
shadingAmount = 1 - sectorStyle.shadingAmount
if sectorStyle.shadingDirection == 'normal':
dsh = (1 - shadingAmount) / float(nshades - 1)
shf1 = shadingAmount
else:
dsh = (shadingAmount - 1) / float(nshades - 1)
shf1 = 1
shda = (a2 - a1) / float(nshades)
shsc = sectorStyle.fillColor
theSector.fillColor = None
for ish in range(nshades):
sha1 = a1 + ish * shda
sha2 = a1 + (ish + 1) * shda
shc = shader(shsc, shf1 + dsh * ish)
if n > 1:
shSector = Wedge(cx,
cy,
xradius,
sha1,
sha2,
yradius=yradius,
radius1=xir,
yradius1=yir)
elif n == 1:
shSector = Wedge(cx,
cy,
xradius,
sha1,
sha2,
yradius=yradius,
radius1=xir,
yradius1=yir,
annular=True)
shSector.fillColor = shc
shSector.strokeColor = None
shSector.strokeWidth = 0
g.add(shSector)
g.add(theSector)
# now draw a label
if labels[
i] and sectorStyle.visible and sectorStyle.label_visible:
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
labelX = centerx + (0.5 * self.width *
cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height *
sin(aveAngleRadians) * labelRadius)
rx = xradius * labelRadius
ry = yradius * labelRadius
l = _addWedgeLabel(self, labels[i], averageAngle, labelX,
labelY, sectorStyle)
if checkLabelOverlap:
l._origdata = {
'x': labelX,
'y': labelY,
'angle': averageAngle,
'rx': rx,
'ry': ry,
'cx': cx,
'cy': cy,
'bounds': l.getBounds(),
}
L_add(l)
if checkLabelOverlap and L:
fixLabelOverlaps(L)
for l in L:
g.add(l)
return g
def makeSectors(self):
# normalize slice data
if type(self.data) in (ListType, TupleType) and type(self.data[0]) in (ListType, TupleType):
#it's a nested list, more than one sequence
normData = []
n = []
for l in self.data:
t = self.normalizeData(l)
normData.append(t)
n.append(len(t))
self._seriesCount = max(n)
else:
normData = self.normalizeData(self.data)
n = len(normData)
self._seriesCount = n
#labels
checkLabelOverlap = self.checkLabelOverlap
L = []
L_add = L.append
if self.labels is None:
labels = []
if type(n) not in (ListType,TupleType):
labels = [''] * n
else:
for m in n:
labels = list(labels) + [''] * m
else:
labels = self.labels
#there's no point in raising errors for less than enough labels if
#we silently create all for the extreme case of no labels.
if type(n) not in (ListType,TupleType):
i = n-len(labels)
if i>0:
labels = list(labels) + [''] * i
else:
tlab = 0
for m in n:
tlab += m
i = tlab-len(labels)
if i>0:
labels = list(labels) + [''] * i
xradius = self.width/2.0
yradius = self.height/2.0
centerx = self.x + xradius
centery = self.y + yradius
if self.direction == "anticlockwise":
whichWay = 1
else:
whichWay = -1
g = Group()
startAngle = self.startAngle #% 360
styleCount = len(self.slices)
if type(self.data[0]) in (ListType, TupleType):
#multi-series doughnut
iradius = (self.height/5.0)/len(self.data)
for sn,series in enumerate(normData):
for i,angle in enumerate(series):
endAngle = (startAngle + (angle * whichWay)) #% 360
if abs(startAngle-endAngle)<1e-5:
startAngle = endAngle
continue
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
startAngle = endAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[i%styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle * pi/180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if type(n) in (ListType,TupleType):
theSector = Wedge(cx, cy, xradius+(sn*iradius)-iradius, a1, a2, yradius=yradius+(sn*iradius)-iradius, radius1=yradius+(sn*iradius)-(2*iradius))
else:
theSector = Wedge(cx, cy, xradius, a1, a2, yradius=yradius, radius1=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
if sn == 0:
text = self.getSeriesName(i,'')
if text:
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle*pi/180.0
labelRadius = sectorStyle.labelRadius
rx = xradius*labelRadius
ry = yradius*labelRadius
labelX = centerx + (0.5 * self.width * cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height * sin(aveAngleRadians) * labelRadius)
l = _addWedgeLabel(self,text,averageAngle,labelX,labelY,sectorStyle)
if checkLabelOverlap:
l._origdata = { 'x': labelX, 'y':labelY, 'angle': averageAngle,
'rx': rx, 'ry':ry, 'cx':cx, 'cy':cy,
'bounds': l.getBounds(),
}
L_add(l)
else:
#single series doughnut
iradius = self.height/5.0
for i,angle in enumerate(normData):
endAngle = (startAngle + (angle * whichWay)) #% 360
if abs(startAngle-endAngle)<1e-5:
startAngle = endAngle
continue
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
startAngle = endAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[i%styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle * pi/180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if n > 1:
theSector = Wedge(cx, cy, xradius, a1, a2, yradius=yradius, radius1=iradius)
elif n==1:
theSector = Wedge(cx, cy, xradius, a1, a2, yradius=yradius, iradius=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
# now draw a label
if labels[i] != "":
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle*pi/180.0
labelRadius = sectorStyle.labelRadius
labelX = centerx + (0.5 * self.width * cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height * sin(aveAngleRadians) * labelRadius)
rx = xradius*labelRadius
ry = yradius*labelRadius
l = _addWedgeLabel(self,labels[i],averageAngle,labelX,labelY,sectorStyle)
if checkLabelOverlap:
l._origdata = { 'x': labelX, 'y':labelY, 'angle': averageAngle,
'rx': rx, 'ry':ry, 'cx':cx, 'cy':cy,
'bounds': l.getBounds(),
}
L_add(l)
if checkLabelOverlap and L:
fixLabelOverlaps(L)
for l in L: g.add(l)
return g
def makeWedges(self):
angles = self.makeAngles()
n = len(angles)
labels = _fixLabels(self.labels,n)
self._seriesCount = n
styleCount = len(self.slices)
plMode = self.pointerLabelMode
if plMode:
checkLabelOverlap = False
PL=self.makePointerLabels(angles,plMode)
xradius = PL.xradius
yradius = PL.yradius
centerx = PL.centerx
centery = PL.centery
PL_data = PL.data
gSN = lambda i: ''
else:
xradius = self.width*0.5
yradius = self.height*0.5
centerx = self.x + xradius
centery = self.y + yradius
if self.xradius: xradius = self.xradius
if self.yradius: yradius = self.yradius
if self.sameRadii: xradius=yradius=min(xradius,yradius)
checkLabelOverlap = self.checkLabelOverlap
gSN = lambda i: self.getSeriesName(i,'')
g = Group()
g_add = g.add
if checkLabelOverlap:
L = []
L_add = L.append
else:
L_add = g_add
for i,(a1,a2) in angles:
if a2 is None: continue
#if we didn't use %stylecount here we'd end up with the later wedges
#all having the default style
wedgeStyle = self.slices[i%styleCount]
if not wedgeStyle.visible: continue
# is it a popout?
cx, cy = centerx, centery
text = gSN(i)
popout = wedgeStyle.popout
if text or popout:
averageAngle = (a1+a2)/2.0
aveAngleRadians = averageAngle/_180_pi
cosAA = cos(aveAngleRadians)
sinAA = sin(aveAngleRadians)
if popout:
# pop out the wedge
cx = centerx + popout*cosAA
cy = centery + popout*sinAA
if n > 1:
theWedge = Wedge(cx, cy, xradius, a1, a2, yradius=yradius)
elif n==1:
theWedge = Ellipse(cx, cy, xradius, yradius)
theWedge.fillColor = wedgeStyle.fillColor
theWedge.strokeColor = wedgeStyle.strokeColor
theWedge.strokeWidth = wedgeStyle.strokeWidth
theWedge.strokeDashArray = wedgeStyle.strokeDashArray
g_add(theWedge)
if wedgeStyle.label_visible:
if text:
labelRadius = wedgeStyle.labelRadius
rx = xradius*labelRadius
ry = yradius*labelRadius
labelX = cx + rx*cosAA
labelY = cy + ry*sinAA
_addWedgeLabel(self,text,L_add,averageAngle,labelX,labelY,wedgeStyle)
if checkLabelOverlap:
l = L[-1]
l._origdata = { 'x': labelX, 'y':labelY, 'angle': averageAngle,
'rx': rx, 'ry':ry, 'cx':cx, 'cy':cy,
'bounds': l.getBounds(),
}
elif plMode and PL_data:
l = PL_data[i]
if l:
data = l._origdata
sinM = data['smid']
cosM = data['cmid']
lX = cx + xradius*cosM
lY = cy + yradius*sinM
lpel = wedgeStyle.label_pointer_elbowLength
lXi = lX + lpel*cosM
lYi = lY + lpel*sinM
L_add(PolyLine((lX,lY,lXi,lYi,l.x,l.y),
strokeWidth=wedgeStyle.label_pointer_strokeWidth,
strokeColor=wedgeStyle.label_pointer_strokeColor))
L_add(l)
if checkLabelOverlap and L:
fixLabelOverlaps(L)
map(g_add,L)
return g
def makeSectors(self):
# normalize slice data
if type(self.data) in (ListType, TupleType) and type(
self.data[0]) in (ListType, TupleType):
#it's a nested list, more than one sequence
normData = []
n = []
for l in self.data:
t = self.normalizeData(l)
normData.append(t)
n.append(len(t))
self._seriesCount = max(n)
else:
normData = self.normalizeData(self.data)
n = len(normData)
self._seriesCount = n
#labels
if self.labels is None:
labels = []
if type(n) not in (ListType, TupleType):
labels = [''] * n
else:
for m in n:
labels = list(labels) + [''] * m
else:
labels = self.labels
#there's no point in raising errors for less than enough labels if
#we silently create all for the extreme case of no labels.
if type(n) not in (ListType, TupleType):
i = n - len(labels)
if i > 0:
labels = list(labels) + [''] * i
else:
tlab = 0
for m in n:
tlab = tlab + m
i = tlab - len(labels)
if i > 0:
labels = list(labels) + [''] * i
xradius = self.width / 2.0
yradius = self.height / 2.0
centerx = self.x + xradius
centery = self.y + yradius
if self.direction == "anticlockwise":
whichWay = 1
else:
whichWay = -1
g = Group()
sn = 0
startAngle = self.startAngle #% 360
styleCount = len(self.slices)
if type(self.data[0]) in (ListType, TupleType):
#multi-series doughnut
iradius = (self.height / 5.0) / len(self.data)
for series in normData:
i = 0
for angle in series:
endAngle = (startAngle + (angle * whichWay)) #% 360
if abs(startAngle - endAngle) >= 1e-5:
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if type(n) in (ListType, TupleType):
theSector = Wedge(
cx,
cy,
xradius + (sn * iradius) - iradius,
a1,
a2,
yradius=yradius + (sn * iradius) - iradius,
radius1=yradius + (sn * iradius) - (2 * iradius))
else:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
radius1=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
startAngle = endAngle
text = self.getSeriesName(i, '')
if text:
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
labelX = centerx + (0.5 * self.width *
cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height *
sin(aveAngleRadians) * labelRadius)
_addWedgeLabel(self, text, g.add, averageAngle, labelX,
labelY, sectorStyle)
i = i + 1
sn = sn + 1
else:
i = 0
#single series doughnut
iradius = self.height / 5.0
for angle in normData:
endAngle = (startAngle + (angle * whichWay)) #% 360
if abs(startAngle - endAngle) >= 1e-5:
if startAngle < endAngle:
a1 = startAngle
a2 = endAngle
else:
a1 = endAngle
a2 = startAngle
#if we didn't use %stylecount here we'd end up with the later sectors
#all having the default style
sectorStyle = self.slices[i % styleCount]
# is it a popout?
cx, cy = centerx, centery
if sectorStyle.popout != 0:
# pop out the sector
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
popdistance = sectorStyle.popout
cx = centerx + popdistance * cos(aveAngleRadians)
cy = centery + popdistance * sin(aveAngleRadians)
if n > 1:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
radius1=iradius)
elif n == 1:
theSector = Wedge(cx,
cy,
xradius,
a1,
a2,
yradius=yradius,
iradius=iradius)
theSector.fillColor = sectorStyle.fillColor
theSector.strokeColor = sectorStyle.strokeColor
theSector.strokeWidth = sectorStyle.strokeWidth
theSector.strokeDashArray = sectorStyle.strokeDashArray
g.add(theSector)
# now draw a label
if labels[i] != "":
averageAngle = (a1 + a2) / 2.0
aveAngleRadians = averageAngle * pi / 180.0
labelRadius = sectorStyle.labelRadius
labelX = centerx + (0.5 * self.width *
cos(aveAngleRadians) * labelRadius)
labelY = centery + (0.5 * self.height *
sin(aveAngleRadians) * labelRadius)
theLabel = String(labelX, labelY, labels[i])
theLabel.textAnchor = "middle"
theLabel.fontSize = sectorStyle.fontSize
theLabel.fontName = sectorStyle.fontName
theLabel.fillColor = sectorStyle.fontColor
g.add(theLabel)
startAngle = endAngle
i = i + 1
return g