예제 #1
0
파일: eventcal.py 프로젝트: tschalch/pyTray
    def getTalkRect(self, startTime, duration, trackId, text):
        "Return shapes for a specific talk"
        g = Group()
        y_bottom = self.scaleTime(startTime + duration)
        y_top = self.scaleTime(startTime)
        y_height = y_top - y_bottom

        if trackId is None:
            #spans all columns
            x = self._colLeftEdges[1]
            width = self.width - self._colWidths[0]
        else:
            #trackId is 1-based and these arrays have the margin info in column
            #zero, so no need to add 1
            x = self._colLeftEdges[trackId]
            width = self._colWidths[trackId]

        lab = Label()
        lab.setText(text)
        lab.setOrigin(x + 0.5*width, y_bottom+0.5*y_height)
        lab.boxAnchor = 'c'
        lab.width = width
        lab.height = y_height
        lab.fontSize = 6

        r = Rect(x, y_bottom, width, y_height, fillColor=colors.cyan)
        g.add(r)
        g.add(lab)

        #now for a label
        # would expect to color-code and add text
        return g
예제 #2
0
def addScale(drawing, xmap, y, start, end, tickLen=10, dx=3, dy=6,
  textAnchor='middle', boxAnchor='s', fontSize=12,
  strokeWidth=1, strokeColor=colors.black, scale=1.0, format='%ibp'):
    x1 = xmap(start)
    x2 = xmap(end)
    line = Line(x1+dx,y,x2-dx,y,
        strokeWidth=strokeWidth, strokeColor=strokeColor)
    drawing.add(line)
    
    leftTick = Line(x1+dx,y-0.5*tickLen,x1+dx,y+0.5*tickLen,
        strokeWidth=strokeWidth, strokeColor=strokeColor)
    drawing.add(leftTick)
    
    rightTick = Line(x2-dx,y-0.5*tickLen,x2-dx,y+0.5*tickLen,
        strokeWidth=strokeWidth, strokeColor=strokeColor)
    drawing.add(rightTick)
    
    label = Label()
    label.setOrigin(0.5*(x1+x2), y+dy)
    
    distance = float(end-start)/scale
    label.setText(format % (distance/scale))
    label.fontSize = fontSize
    label.textAnchor = textAnchor
    label.boxAnchor = boxAnchor
    drawing.add(label)
예제 #3
0
    def getTalkRect(self, startTime, duration, trackId, text):
        "Return shapes for a specific talk"
        g = Group()
        y_bottom = self.scaleTime(startTime + duration)
        y_top = self.scaleTime(startTime)
        y_height = y_top - y_bottom

        if trackId is None:
            #spans all columns
            x = self._colLeftEdges[1]
            width = self.width - self._colWidths[0]
        else:
            #trackId is 1-based and these arrays have the margin info in column
            #zero, so no need to add 1
            x = self._colLeftEdges[trackId]
            width = self._colWidths[trackId]

        lab = Label()
        lab.setText(text)
        lab.setOrigin(x + 0.5 * width, y_bottom + 0.5 * y_height)
        lab.boxAnchor = 'c'
        lab.width = width
        lab.height = y_height
        lab.fontSize = 6

        r = Rect(x, y_bottom, width, y_height, fillColor=colors.cyan)
        g.add(r)
        g.add(lab)

        #now for a label
        # would expect to color-code and add text
        return g
예제 #4
0
 def draw(self):
     # general widget bits
     w = float(self.length)
     h = float(self.height)
     g = shapes.Group()
     
     body = shapes.Polygon(
         [self.x-0.5*w, self.y-0.5*w,
          self.x-0.5*w, self.y+0.5*w,
          self.x+0.5*w, self.y],
         fillColor=self.fillColor,
         strokeColor=self.strokeColor,
         strokeWidth=self.strokeWidth)
     g.add(body)
     
     if self.label:
         b = g.getBounds()
         s = Label()
         s.setText(self.label)
         s.setOrigin(self.x+0.5*w, self.y-h/2+b[3]-b[1]+4)
         s.boxAnchor = self.boxAnchor
         s.textAnchor = self.textAnchor
         s.fontName = 'Helvetica'
         s.fontSize = self.fontSize
         s.angle = self.labelAngle
         g.add(s)
     
     return g
예제 #5
0
파일: report.py 프로젝트: rayene/netpylab
    def draw_travels(self):
        for p in self.world.packets:
            if self.detailed:
                txt = p.command()
            else:
                txt = "(%d) %s" % (p.number, p.description)
            last_action = (0,0)
            for ts in p.trip:
                action = self.packet_actions[ts.action]
                if ts.actor not in self.verticals:
                    self.verticals[ts.actor] = self.verticals[ts.actor.node]
                x2,y2 = self.verticals[ts.actor], -ts.time*self.yzoom
                if action.sprite:
                    self.sequence_diagram.add(shapes.Circle(x2, y2, 
                    action.size,  fillColor=action.color, strokeWidth=1 ))

                if action.travel:
                    if action.travel_desc:
                        # self.sequence_diagram.add(shapes.String((last_action[0] + x)/2,(last_action[1]+y)/2, label, fill=colors.black, textAnchor = 'middle'))
                        x1, y1 = last_action[0], last_action[1]
                        l = Label()
                        l.setText(txt) 
                        l.angle = atan2((y2-y1)/2, (x2-x1))*360.0/pi
                        l.dy = 10
                        l.setOrigin((x1 + x2)/2,(y1+y2)/2)
                        self.sequence_diagram.add(l)
                        
                        #anchor = Paragraph('<a name="diagram%d"/>' %p.number, styles['Normal'])
                    self.sequence_diagram.add(shapes.Line(last_action[0],last_action[1],x2,y2, strokeColor=colors.black, strokeWidth=1))
                    self.max_y = min(y2, self.max_y, last_action[1])
                last_action = (x2,y2)
예제 #6
0
def getHumPlot():
    drawing = Drawing(400, 200)
    humedad = [getHumedad()]
    lp = LinePlot()
    lp.x = 50
    lp.y = 50
    lp.height = 125
    lp.width = 300
    lp.data = humedad

    ydlabel = Label()
    ydlabel.setText("Humedad (%)")
    ydlabel.angle = 90
    ydlabel.setOrigin(20, 120)

    lp.joinedLines = 2
    lp.lines[0].symbol = makeMarker('Circle')
    lp.lines[0].strokeColor = colors.blue
    lp.xValueAxis.valueMin = 0
    lp.xValueAxis.valueMax = 30
    lp.yValueAxis.valueMin = 0
    lp.yValueAxis.valueMax = 100
    #lp.xValueAxis.visible=False
    #lp.yValueAxis.visible=False #Hide 2nd plot its Yaxis
    drawing.add(lp)
    drawing.add(ydlabel)
    drawing.add(String(130, 200, "Gráfico de humedad", fontSize=16))

    return drawing
예제 #7
0
def add_findings_by_provider_chart():
    drawing = Drawing(300, 200)
    data = get_findings_by_provider()
    maxVal = max(data[0])

    if (maxVal > 1000):
        multiplier = 1000
        step = 4 * multiplier
    else:
        multiplier = 100
        step = 4 * multiplier

    value_step = int(ceil(maxVal / step)) * multiplier

    if (value_step < 10):
        value_step = 10

    bar = HorizontalBarChart()
    bar.x = 30
    bar.y = 0
    bar.height = 100
    bar.width = 400
    bar.data = data
    bar.strokeColor = colors.white
    bar.valueAxis.valueMin = 0
    bar.valueAxis.valueMax = maxVal * 2  ## graph displa twice as much as max violation
    bar.valueAxis.valueStep = value_step  ## Convert to neartest 100
    bar.categoryAxis.labels.boxAnchor = 'ne'
    bar.categoryAxis.labels.dx = -10
    bar.categoryAxis.labels.dy = -2
    bar.categoryAxis.labels.fontName = 'Helvetica'
    bar.categoryAxis.categoryNames = ["AWS", "Azure"]
    bar.bars[(0, 0)].fillColor = HexColor("#434476")
    bar.bars[(0, 1)].fillColor = HexColor("#B170DB")
    bar.barWidth = 3.5
    bar.barSpacing = 0.1
    bar.barLabelFormat = '%d'
    bar.barLabels.nudge = 15
    bar.bars[0].strokeColor = None

    drawing.add(bar)
    #  add_legend(drawing, bar)
    yLabel = Label()
    yLabel.setText("Number of Findings")
    yLabel.fontSize = 10
    yLabel.fontName = 'Helvetica'
    yLabel.dx = 250
    yLabel.dy = -30

    chartLabel = Label()
    chartLabel.setText("Findings by Provider")
    chartLabel.fontSize = 10
    chartLabel.fillColor = HexColor("#737373")
    chartLabel.fontName = 'Helvetica-Bold'
    chartLabel.dx = 250
    chartLabel.dy = 160

    drawing.add(chartLabel)
    drawing.add(yLabel)
    fields.append(drawing)
예제 #8
0
def addChromosomes(drawing, chrNames, chrSizes, xmap, ymap, w=0.1*DPI, fillColor=colors.skyblue, strokeColor=colors.skyblue):
    for i,chrom in enumerate(chrNames):
        x = xmap(i+1)
        y = ymap(chrSizes[chrom])
        h = ymap(1)-ymap(chrSizes[chrom])
        
        chromosome = Rect(x,y,w,h, strokeColor=strokeColor, fillColor=fillColor)
        drawing.add(chromosome)
        
        topCap = Wedge(x+0.5*w, y+h, 0.5*w, 0, 180, strokeColor=strokeColor, fillColor=fillColor)
        bottomCap = Wedge(x+0.5*w, y, 0.5*w, 180, 0, strokeColor=strokeColor, fillColor=fillColor)
        drawing.add(topCap)
        drawing.add(bottomCap)
        
        label = Label()
        label.setOrigin(xmap(i+1)+w/2, ymap(0))
        label.boxAnchor = 's'
        label.textAnchor = 'middle'
        label.dx = 0
        label.dy = DPI/10
        label.setText(chrom)
        label.fontSize = 36
        label.fontName = 'Helvetica'
        drawing.add(label)
        
        chrLength = Label()
        chrLength.setOrigin(xmap(i+1)+w/2, ymap(chrSizes[chrom]))
        chrLength.boxAnchor = 'n'
        chrLength.textAnchor = 'middle'
        chrLength.dx = 0
        chrLength.dy = -DPI/10
        chrLength.setText('%iMb' % int(chrSizes[chrom]/1e6))
        chrLength.fontSize = 24
        chrLength.fontName = 'Helvetica'
        drawing.add(chrLength)
예제 #9
0
    def colorTest(self):
        from reportlab.graphics.shapes import Rect
        from reportlab.graphics.charts.textlabels import Label
        self.colorRangeStatic(130)

        dim=25
        width = self.PAGE_WIDTH-150
        inrow = 8 #int(width/dim)
        height = int(len(self.colors)/inrow)
        if len(self.colors)%inrow > 0:
            height +=1
        height *= dim
        drawing = Drawing(width, height)
        for i,col in enumerate(self.colors):
            x = (i%inrow)*dim
            y = int(i/inrow)*dim
            rec = Rect(x=x,y=y,width=dim,height=dim)
            rec.fillColor = col
            drawing.add(rec)
            lab = Label()
            lab.x=x+dim/2
            lab.y=y+dim/2
            lab.setText('%d'%i)
            drawing.add(lab)
        return drawing
예제 #10
0
 def _drawLabels(self, label, labelCenter, y, width):
     """
     Draw the label given in a given area originating at (x,y) with width 'width'
     """
     fontName = 'Times-Roman'
     fontSize = 10
     #Limit the length of the label to the boundaries of the chartAreaWidth
     
     strWidth = self._stringWidth(label, fontName, fontSize)
     #Calculate the area taken by one character
     oneCharWidth = self._stringWidth(label[0], fontName, fontSize)
     #If the given string needs more size, reduce the string to a length which fits
     #in the given area
     if strWidth > width:
         maxPossibleLen = int(width/oneCharWidth)
         label = label[:maxPossibleLen]
         strWidth = self._stringWidth(label, fontName, fontSize)
         
     x = (labelCenter - ((strWidth)/2))
     Label_Graph = Label()
     Label_Graph.fontName = fontName
     Label_Graph.fontSize = fontSize
     #Label_Graph.angle = 0
     Label_Graph.boxAnchor = 'n'
     Label_Graph.x = x
     Label_Graph.y = y
     Label_Graph.setText(label)
     self.drawing.add(Label_Graph)
예제 #11
0
def graphout_stackedBar(data, labels, X, Y):
	drawing = Drawing(X*inch, Y*inch)
	bar = VerticalBarChart()
	bar.x = 50
	bar.y = 50
	bar.width = (X-2)*inch
	bar.height = (Y-1)*inch
	bar.data = data
	bar.bars.strokeWidth = 0
	bar.categoryAxis.style='stacked'
	bar.categoryAxis.labels.boxAnchor = 'ne'
	bar.categoryAxis.labels.dx = -2
	bar.categoryAxis.labels.dy = -2
	bar.categoryAxis.labels.angle = 45
	bar.categoryAxis.categoryNames = labels

	# ensure bar chart and legend coloring matches
	for i in range(len(data)):
		bar.bars[i].fillColor = colorList[i]
	
	# Create a title for the y-axis
	yLabel = Label()
	yLabel.setOrigin(0, 50) # for reference, the graph origin is (50, 50)
	yLabel.boxAnchor = 'c'
	yLabel.angle = 90
	yLabel.setText('Data Storage [GB]')
	yLabel.fontSize=16
	yLabel.dy = 1.25*inch
	drawing.add(yLabel)
	drawing.add(bar)
	return drawing
예제 #12
0
def comparison_graphs(comparison_values, location, emission, default_emissions,
                      default_location):
    s = Spacer(9 * inch, .2 * inch)
    Elements.append(s)
    drawing = Drawing(0, 0)

    if not default_location:
        bc = gen_bar_graphs(comparison_values, location, emission)
        bc.y = -120
        bc.height = 125
        bc.width = 300
        drawing.add(bc)
    else:
        bc1 = gen_bar_graphs(default_emissions[:3], location, emission)
        bc2 = gen_bar_graphs(default_emissions[3:6], location, emission)
        bc3 = gen_bar_graphs(default_emissions[6:], location, emission)

        offset = -257
        bc1.x = -10 + offset
        bc2.x = 190 + offset
        bc3.x = 390 + offset
        drawing.add(bc1)
        drawing.add(bc2)
        drawing.add(bc3)

        label_offset = offset + 80
        label1, label2, label3 = Label(), Label(), Label()
        label1.setText("Global (excluding Europe and US)")
        label1.x, label1.y = -17 + label_offset, -160
        label1.fontName = "Times-Bold"

        label2.setText("Europe")
        label2.x, label2.y = 185 + label_offset, -160
        label2.fontName = "Times-Bold"

        label3.setText("United States")
        label3.x, label3.y = 385 + label_offset, -160
        label3.fontName = "Times-Bold"

        drawing.add(label1)
        drawing.add(label2)
        drawing.add(label3)

    if_elsewhere_para = Paragraph(
        '<font face="times" size=12>Kilograms of CO<sub rise = -10 size' +
        ' = 8>2 </sub> emissions for the function if the computation had been performed elsewhere</font>',
        style=styles["Normal"])
    graph_data = [['Emission Comparison'], [if_elsewhere_para], [drawing]]
    graph_table = Table(graph_data, [6.5 * inch],
                        [.25 * inch, .25 * inch, .25 * inch],
                        hAlign="CENTER")
    graph_table.setStyle(
        TableStyle([('FONT', (0, 0), (0, 0), "Times-Bold"),
                    ('FONT', (0, 1), (0, 1), "Times-Roman"),
                    ('FONTSIZE', (0, 0), (0, 0), 13),
                    ('FONTSIZE', (0, 1), (0, 1), 12),
                    ('ALIGN', (0, 0), (-1, -1), "CENTER")]))

    Elements.append(graph_table)
예제 #13
0
def add_trends_new_resolved_findings_chart():
    drawing = Drawing(200, 200)

    data, month = get_new_resolved_trends()

    max_val_new_findings = max(data[0])
    max_val_resolved_findings = max(data[1])

    maxVal = max(max_val_new_findings, max_val_resolved_findings)

    if (maxVal > 1000):
        multiplier = 1000
        step = 4 * multiplier
    else:
        multiplier = 100
        step = 4 * multiplier

    value_step = int(ceil(maxVal / step)) * multiplier

    if (value_step < 10):
        value_step = 1

    bar = VerticalBarChart()
    bar.x = 25
    bar.y = -35
    bar.height = 100
    bar.width = doc.width
    bar.barWidth = 2
    bar.data = data
    bar.valueAxis.valueMin = 0
    bar.valueAxis.valueMax = int(
        maxVal * 2)  ## graph displa twice as much as max violation
    bar.valueAxis.valueStep = value_step  ## Convert to neartest step
    bar.categoryAxis.categoryNames = month
    bar.bars[0].strokeColor = None
    bar.bars[1].strokeColor = None
    bar.bars[0].fillColor = HexColor("#E57300")
    bar.bars[1].fillColor = HexColor("#408F00")

    chartLabel = Label()
    chartLabel.setText("Trends - New Findings")
    chartLabel.fontSize = 10
    chartLabel.fillColor = HexColor("#737373")
    chartLabel.fontName = 'Helvetica-Bold'
    chartLabel.dx = 250
    chartLabel.dy = 90

    legend = Legend()
    legend.alignment = 'right'
    legend.colorNamePairs = [[HexColor("#E57300"), "New Findings"],
                             [HexColor("#408F00"), "Resolved Findings"]]
    legend.columnMaximum = 2
    legend.x = 400
    legend.y = 120

    drawing.add(legend)
    drawing.add(chartLabel)
    drawing.add(bar)
    fields.append(drawing)
예제 #14
0
def addChromosomes(drawing,
                   chrNames,
                   chrSizes,
                   xmap,
                   ymap,
                   w=0.1 * DPI,
                   fillColor=colors.skyblue,
                   strokeColor=colors.skyblue):
    for i, chrom in enumerate(chrNames):
        x = xmap(i + 1)
        y = ymap(chrSizes[chrom])
        h = ymap(1) - ymap(chrSizes[chrom])

        chromosome = Rect(x,
                          y,
                          w,
                          h,
                          strokeColor=strokeColor,
                          fillColor=fillColor)
        drawing.add(chromosome)

        topCap = Wedge(x + 0.5 * w,
                       y + h,
                       0.5 * w,
                       0,
                       180,
                       strokeColor=strokeColor,
                       fillColor=fillColor)
        bottomCap = Wedge(x + 0.5 * w,
                          y,
                          0.5 * w,
                          180,
                          0,
                          strokeColor=strokeColor,
                          fillColor=fillColor)
        drawing.add(topCap)
        drawing.add(bottomCap)

        label = Label()
        label.setOrigin(xmap(i + 1) + w / 2, ymap(0))
        label.boxAnchor = 's'
        label.textAnchor = 'middle'
        label.dx = 0
        label.dy = DPI / 10
        label.setText(chrom)
        label.fontSize = 36
        label.fontName = 'Helvetica'
        drawing.add(label)

        chrLength = Label()
        chrLength.setOrigin(xmap(i + 1) + w / 2, ymap(chrSizes[chrom]))
        chrLength.boxAnchor = 'n'
        chrLength.textAnchor = 'middle'
        chrLength.dx = 0
        chrLength.dy = -DPI / 10
        chrLength.setText('%iMb' % int(chrSizes[chrom] / 1e6))
        chrLength.fontSize = 24
        chrLength.fontName = 'Helvetica'
        drawing.add(chrLength)
예제 #15
0
def write_label(label, width, height, person):
    text = "\n".join((person['name'], person['addresses'][0]))
    lab = Label()
    lab.setOrigin(8, height - 5)
    lab.fontSize = 14
    lab.setText(text)
    lab.boxAnchor = 'nw'
    label.add(lab)
예제 #16
0
 def title_draw(self, x, y, text):
     chart_title = Label()
     chart_title.x = x
     chart_title.y = y
     chart_title.fontName = 'FreeSansBold'
     chart_title.fontSize = 16
     chart_title.textAnchor = 'middle'
     chart_title.setText(text)
     return chart_title
예제 #17
0
파일: pdf.py 프로젝트: jink8904/mysite
 def title_draw(self, x, y, text):
     chart_title = Label()
     chart_title.x = x
     chart_title.y = y
     chart_title.fontName = 'FreeSansBold'
     chart_title.fontSize = 16
     chart_title.textAnchor = 'middle'
     chart_title.setText(text)
     return chart_title
예제 #18
0
 def header_draw(self, x, y, text):
     chart_title = Label()
     chart_title.x = x
     chart_title.y = y
     chart_title.fontName = 'RobotoBold'
     chart_title.fontSize = 9
     chart_title.textAnchor = 'middle'
     chart_title.setText(text)
     return chart_title
예제 #19
0
 def draw(self):
     # general widget bits
     w = float(self.length)
     h = float(self.height)
     # print self.label,w,h
     
     # Set minimum size
     if abs(w)<self.wmin:
         xmid = self.x+0.5*w
         w = w/abs(w) * self.wmin
         self.x = xmid-0.5*w
     
     g = shapes.Group()
     if abs(w)>self.wNoTail:
         # arrow specific bits
         body = shapes.Rect(x=self.x, y=self.y-self.aspectRatio*h/2,
             width=2*(w/3),
             height=self.aspectRatio*h,
             fillColor=self.fillColor,
             strokeColor=self.strokeColor,
             strokeWidth=self.strokeWidth)
         g.add(body)
         
         head = shapes.Polygon(
             points=[self.x+w, self.y,
                 self.x+2*(w/3), self.y+h/2,
                 self.x+2*(w/3), self.y-h/2,
                 self.x+w, self.y],
             fillColor=self.fillColor,
             strokeColor=self.strokeColor,
             strokeWidth=self.strokeWidth)
         g.add(head)
     else:
         head = shapes.Polygon(
             points=[self.x+w, self.y,
                 self.x, self.y+h/2,
                 self.x, self.y-h/2,
                 self.x+w, self.y],
             fillColor=self.fillColor,
             strokeColor=self.strokeColor,
             strokeWidth=self.strokeWidth)
         g.add(head)
     
     if self.label:
         b = g.getBounds()
         s = Label()
         s.setText(self.label)
         s.setOrigin(self.x+0.5*w+self.labeldx, self.y-h/2+b[3]-b[1]+self.labeldy)
         s.boxAnchor = self.boxAnchor
         s.textAnchor = self.textAnchor
         s.fontName = 'Helvetica'
         s.fontSize = self.fontSize
         s.angle = self.labelAngle
         g.add(s)
     
     return g
예제 #20
0
def add_trends_open_findings_chart():
    drawing = Drawing(300, 200)

    data, months = get_open_findings_trends()
    maxVal = max(data[0])

    if (maxVal > 1000):
        multiplier = 1000
        step = 4 * multiplier
    else:
        multiplier = 100
        step = 4 * multiplier

    value_step = int(ceil(maxVal / step)) * multiplier

    if (value_step < 10):
        value_step = 1

    lc = HorizontalLineChart()
    lc.x = 25
    lc.y = 40
    lc.height = 100
    lc.width = doc.width
    lc.lines.symbol = makeMarker('Square')
    lc.joinedLines = 1
    lc.data = data
    lc.categoryAxis.categoryNames = months
    lc.categoryAxis.labels.boxAnchor = 'c'
    # lc.categoryAxis.valueMin = months[0]
    lc.valueAxis.valueMin = 0
    lc.valueAxis.valueStep = value_step
    lc.valueAxis.valueMax = max(data[0]) * 2
    lc.lines[0].strokeColor = colors.green
    #lc.fillColor = colors.whitesmoke
    #lc.inFill = 1
    #lc.categoryAxis.labels.dx = -20
    #lc.categoryAxis.labels.dy = -10
    lc.lineLabelFormat = "%d"

    chartLabel = Label()
    chartLabel.setText("Trends - Total Open Findings")
    chartLabel.fontSize = 10
    chartLabel.fillColor = HexColor("#737373")
    chartLabel.fontName = 'Helvetica-Bold'

    chartLabel.dx = 250
    chartLabel.dy = 160

    drawing.add(chartLabel)
    drawing.add(lc)
    fields.append(drawing)
예제 #21
0
def add_azure_findings_by_severity_chart():
    drawing = Drawing(doc.width / 2 - 18, doc.height / 2 - 45)
    aws, azure = get_all_violations_by_severity()
    rules = [azure]

    maxVal = max(rules[0])

    if (maxVal > 1000):
        multiplier = 1000
        step = 4 * multiplier
    else:
        multiplier = 100
        step = 4 * multiplier

    value_step = int(ceil(maxVal / step)) * multiplier

    if (value_step < 10):
        value_step = 1

    bar = VerticalBarChart()
    bar.x = 10
    bar.y = 70
    bar.height = doc.height / 4
    bar.width = doc.width / 2 - 40
    bar.barWidth = 2
    bar.barSpacing = 0.5
    bar.data = rules
    bar.valueAxis.valueMin = 0
    bar.valueAxis.valueMax = int(
        maxVal * 1.5)  ## graph displa twice as much as max violation
    bar.valueAxis.valueStep = value_step  ## Convert to neartest 10
    bar.categoryAxis.categoryNames = ["high", "medium", "low"]
    bar.barLabelFormat = '%d'
    bar.barLabels.nudge = 15
    bar.bars[0].fillColor = HexColor("#B170DB")
    bar.bars[0].strokeColor = None
    bar.categoryAxis.labels.boxAnchor = 'n'

    chartLabel = Label()
    chartLabel.setText("Findings by Severity - Azure")
    chartLabel.fontSize = 10
    chartLabel.fontName = 'Helvetica-Bold'
    chartLabel.fillColor = HexColor("#737373")
    chartLabel.dx = doc.rightMargin
    chartLabel.dy = doc.height - 80

    drawing.add(chartLabel)
    drawing.add(bar)
    fields.append(drawing)
예제 #22
0
def autoLegender( chart,title=''):
    width = 448
    height = 230
    d = Drawing(width,height)
    lab = Label()
    lab.x = 220  #x和y是文字的位置坐标
    lab.y = 210
    lab.setText(title)
    # lab.fontName = 'song' #增加对中文字体的支持
    lab.fontSize = 20
    d.add(lab)
    d.background = Rect(0,0,width,height,strokeWidth=1,strokeColor="#868686",fillColor=None) #边框颜色
    d.add(chart)

    return d
예제 #23
0
def addLabel(drawing, x, y, text, fontName='Helvetica', fontSize=11, dy=0,
             angle=0, boxAnchor='sw', textAnchor='start'):
    """Add a label to the drawing. 
    This interface here is inconsistent in that it requires pixel coords. FIX
    This just sets convenient defaults for Label."""
    label = Label()
    label.setText(text)
    label.setOrigin(x, y)
    label.fontName = fontName
    label.fontSize = fontSize
    label.boxAnchor = boxAnchor
    label.textAnchor = textAnchor
    label.dy = dy
    label.angle = angle
    drawing.add(label)
예제 #24
0
파일: lineplots.py 프로젝트: eaudeweb/naaya
    def draw(self):
        ascent = getFont(self.xValueAxis.labels.fontName).face.ascent
        if ascent == 0:
            ascent = 0.718  # default (from helvetica)
        ascent = ascent * self.xValueAxis.labels.fontSize  # normalize

        # basic LinePlot - does the Axes, Ticks etc
        lp = LinePlot.draw(self)

        xLabel = self.xLabel
        if xLabel:  # Overall label for the X-axis
            xl = Label()
            xl.x = (self.x + self.width) / 2.0
            xl.y = 0
            xl.fontName = self.xValueAxis.labels.fontName
            xl.fontSize = self.xValueAxis.labels.fontSize
            xl.setText(xLabel)
            lp.add(xl)

        yLabel = self.yLabel
        if yLabel:  # Overall label for the Y-axis
            yl = Label()
            yl.angle = 90
            yl.x = 0
            yl.y = self.y + self.height / 2.0
            yl.fontName = self.yValueAxis.labels.fontName
            yl.fontSize = self.yValueAxis.labels.fontSize
            yl.setText(yLabel)
            lp.add(yl)

        # do a bounding box - in the same style as the axes
        if self.outerBorderOn:
            lp.add(
                Rect(
                    self.x,
                    self.y,
                    self.width,
                    self.height,
                    strokeColor=self.outerBorderColor,
                    strokeWidth=self.yValueAxis.strokeWidth,
                    fillColor=None,
                )
            )

        lp.shift(self.leftPadding, self.bottomPadding)

        return lp
예제 #25
0
def addPointyCompoundFeature(drawing, xmap, y, gene, 
  strokeColor=None, fillColor=colors.blue, intronColor=colors.blue,
  glyph=PointyBlock, height=12, utrHeight=6, rise=8, 
  labeldy=10, fontSize=10, textAnchor='middle', boxAnchor='s'):
    """Adds a pointy compound feature to the drawing. This is typically
    several exons joined by zig-zag lines with an arrow showing strand."""
    if gene.strand=='+':
        x1,x2 = xmap(gene.start), xmap(gene.end)
    else:
        x2,x1 = xmap(gene.start), xmap(gene.end)
    y = y+height/2
    y1 = y
    line = Line(x1,y1,x2,y1,strokeColor=intronColor)
    drawing.add(line)
    
    for exon in gene:
        if exon.strand=='+':
            x1,x2 = xmap(exon.start), xmap(exon.end)
        else:
            x2,x1 = xmap(exon.start), xmap(exon.end)
        
        g = glyph()
        g.x = x1
        g.y = y
        if exon.kind.lower()=='utr':
            g.height = utrHeight
        else:
            g.height = height
        g.length = x2-x1
        g.fillColor = fillColor
        if strokeColor:
            g.strokeColor = strokeColor
        else:
            g.strokeColor = fillColor
        g.fontSize = fontSize
        drawing.add(g)
    
    label = Label()
    label.setText(gene.name)
    x = 0.5*(gene.start+gene.end)
    label.setOrigin(x,y)
    label.dy = labeldy
    label.textAnchor = textAnchor
    label.boxAnchor = boxAnchor
    drawing.add(label)
예제 #26
0
    def draw(self):
        ascent = getFont(self.xValueAxis.labels.fontName).face.ascent
        if ascent == 0:
            ascent = 0.718  # default (from helvetica)
        ascent = ascent * self.xValueAxis.labels.fontSize  # normalize

        #basic LinePlot - does the Axes, Ticks etc
        lp = LinePlot.draw(self)

        xLabel = self.xLabel
        if xLabel:  #Overall label for the X-axis
            xl = Label()
            xl.x = (self.x + self.width) / 2.0
            xl.y = 0
            xl.fontName = self.xValueAxis.labels.fontName
            xl.fontSize = self.xValueAxis.labels.fontSize
            xl.setText(xLabel)
            lp.add(xl)

        yLabel = self.yLabel
        if yLabel:  #Overall label for the Y-axis
            yl = Label()
            yl.angle = 90
            yl.x = 0
            yl.y = (self.y + self.height / 2.0)
            yl.fontName = self.yValueAxis.labels.fontName
            yl.fontSize = self.yValueAxis.labels.fontSize
            yl.setText(yLabel)
            lp.add(yl)

        # do a bounding box - in the same style as the axes
        if self.outerBorderOn:
            lp.add(
                Rect(self.x,
                     self.y,
                     self.width,
                     self.height,
                     strokeColor=self.outerBorderColor,
                     strokeWidth=self.yValueAxis.strokeWidth,
                     fillColor=None))

        lp.shift(self.leftPadding, self.bottomPadding)

        return lp
예제 #27
0
파일: graph.py 프로젝트: SF73/Diamfab
def genLayers2(ls):
    #ls =(titre, taille)
    c = ['#ffeea0', '#ff88ff', '#bbd5e8']
    length = 4 * cm
    #    ls = np.asarray(ls)
    l = []
    for i in range(len(ls)):
        l.append((ls[i][0], ls[i][1]))
    ls = np.asarray(l, dtype=np.str)
    d = Drawing(4 * cm, 100)
    xpos = 0
    ls[:, 1] = layersize2(ls[:, 1])
    tickness = ls[:, 1].astype(np.float32)
    for i in range(len(ls)):
        lab = Label()
        lab.textAnchor = 'middle'
        color = c[0]
        labelTxt = str(ls[:, 0][i])
        if '+' in labelTxt:
            color = c[1]
        elif '-' in labelTxt:
            color = c[2]
        lab.setText(ls[:, 0][i])
        if i > 0:
            d.add(
                Rect(xpos,
                     np.cumsum(tickness)[i - 1],
                     length,
                     tickness[i],
                     fillColor=colors.HexColor(color)))
            lab.setOrigin(xpos + 2 * cm,
                          np.cumsum(tickness)[i - 1] + tickness[i] / 2)
        else:
            d.add(
                Rect(xpos,
                     0,
                     length,
                     tickness[i],
                     fillColor=colors.HexColor(color)))
            lab.setOrigin(xpos + 2 * cm, tickness[i] / 2)
        d.add(lab)

    return d
예제 #28
0
def addAxis(drawing, xmap, y, strokeWidth=1, minorStrokeWidth=0.5, 
  tickDir='down', autoTicks=False, nTicks=20, tickLen=5, fontSize=10, nMinorTicks=80, 
  minorTickLen=2, angle=0, dx=0, dy=-2, textAnchor='middle', boxAnchor=None, 
  scale=1.0, format='%i'):
    """Add a horizontal axis to the drawing.
    
    To do: Round tick positions
    """
    line = Line(xmap.x0, y, xmap.x1, y, strokeWidth=strokeWidth)
    drawing.add(line)
    
    if not boxAnchor:
        if tickDir=='down':
            boxAnchor = 'n'
        else:
            boxAnchor = 's'
    signum = {'up': -1, 'down': 1}[tickDir]
    
    if nTicks>0:
        ticks = tick_generator(xmap.start, xmap.end, n=nTicks, convert=int)
    
    for p in ticks:
        x = xmap(p)
        line = Line(x, y, x, y-signum*tickLen, strokeWidth=strokeWidth)
        drawing.add(line)
        s = Label()
        s.setOrigin(x, y-signum*tickLen)
        s.setText(format % (p/scale))
        s.dx = dx
        s.dy = signum*dy
        s.fontName = 'Helvetica'
        s.fontSize = fontSize
        s.textAnchor = textAnchor
        s.boxAnchor = boxAnchor
        s.angle = angle
        drawing.add(s)
    
    minorticks = tick_generator(xmap.start, xmap.end, n=nMinorTicks, convert=int)
    for p in minorticks:
        x = xmap(p)
        line = Line(x, y, x, y-signum*minorTickLen, strokeWidth=minorStrokeWidth)
        drawing.add(line)
예제 #29
0
def simple_label():
    drawing = shapes.Drawing(width=400, height=200)

    drawing.add(shapes.Rect(200, 100, 10, 10, fillColor=colors.red))

    x = 50
    angle = 0
    for item in range(3):
        label = Label()
        label.setOrigin(200, 100)
        label.boxAnchor = 'se'
        label.angle = angle
        #label.boxStrokeColor = colors.black
        label.setText('ReportLab label')
        drawing.add(label)

        x += 25
        angle += 45

    renderPDF.drawToFile(drawing, 'simple_label.pdf')
예제 #30
0
def radar(datos):
    tamanio = datos["tamanio"]
    data = datos["data"]
    labels = datos["labels"]
    colores = datos["colores"]
    titulo = datos["titulo"]

    grafico = SpiderChart()
    grafico.width = tamanio
    grafico.height = tamanio
    grafico.x = 0
    grafico.y = 0
    grafico.data = data
    grafico.labels = labels
    grafico.spokes.labelRadius = 1.125
    grafico.spokes.strokeDashArray = (10,5)
    grafico.spokeLabels.fontSize = FONTSIZE
    grafico.spokeLabels.fontName = "Helvetica"
    grafico.strands[0].fillColor = colors.HexColor(colores[0])
    grafico.strands[0].strokeColor = None
    grafico.strands[0].strokeWidth = 1
    grafico.strands[1].fillColor = None
    grafico.strands[1].strokeColor = colors.HexColor(colores[1])
    grafico.strands[1].strokeWidth = 2
    grafico.strandLabels.format = 'values'
    grafico.strandLabels.fontSize = FONTSIZE-1
    grafico.strandLabels.fontName = "Helvetica"
    grafico.strandLabels.fillColor = colors.black
    for i in range(len(datos["data"][0])):
        grafico.strandLabels[0,i]._text = "%2.2f" % data[0][i]
        grafico.strandLabels[0,i].dy = FONTSIZE
        grafico.strandLabels[1,i]._text = "%2.2f" % data[1][i]
        grafico.strandLabels[1,i].dy = -FONTSIZE
    retorno = crearDrawing(grafico)
    if titulo:
        etiqueta = Label()
        etiqueta.fontSize = FONTSIZE
        etiqueta.fontName = "Helvetica-Bold"
        etiqueta.setText(titulo)
        etiquetar(retorno, etiqueta, tamanio/2.0, 0.0)
    return retorno
예제 #31
0
    def _drawLabels(self, Title, xAxis, yAxis):
        self.graphCenterX = self.width/2
        self.graphCenterY = self.height/2
        Label_Xaxis = Label()
        Label_Xaxis.fontSize = 7
        Label_Xaxis.angle = 0
        Label_Xaxis.dx = self.graphCenterX - 50
        Label_Xaxis.dy = 0
        Label_Xaxis.boxAnchor = 's'
        Label_Xaxis.setText(xAxis)
        self.drawing.add(Label_Xaxis)

        Label_Yaxis = Label()
        Label_Yaxis.fontSize = 7
        Label_Yaxis.angle = 90
        Label_Yaxis.boxAnchor = 'n'
        Label_Yaxis.dx = -5
        Label_Yaxis.dy = self.graphCenterY
        Label_Yaxis.setText(yAxis)
        self.drawing.add(Label_Yaxis)

        Label_Graph = Label()
        Label_Graph.fontSize = 10
        Label_Graph.angle = 0
        Label_Graph.boxAnchor = 'n'
        Label_Graph.dx = self.graphCenterX - 50
        Label_Graph.dy = self.height
        Label_Graph.setText(Title)
        self.drawing.add(Label_Graph)
예제 #32
0
def autoLegender(chart,
                 title='',
                 width=448,
                 height=230,
                 order='off',
                 categories=[],
                 use_colors=[]):
    d = Drawing(width, height)
    d.add(chart)
    lab = Label()
    lab.x = width / 2  #x和y是title文字的位置坐标
    lab.y = 21 / 23 * height
    lab.fontName = 'song'  #增加对中文字体的支持
    lab.fontSize = 20
    lab.setText(title)
    d.add(lab)
    #颜色图例说明等
    if categories != [] and use_colors != []:
        leg = Legend()
        leg.x = 500  # 说明的x轴坐标
        leg.y = 0  # 说明的y轴坐标
        leg.boxAnchor = 'se'
        # leg.strokeWidth = 4
        leg.strokeColor = None
        leg.subCols[1].align = 'right'
        leg.columnMaximum = 10  # 图例说明一列最多显示的个数
        leg.fontName = 'song'
        leg.alignment = 'right'
        leg.colorNamePairs = list(zip(use_colors, tuple(categories)))
        d.add(leg)
    if order == 'on':
        d.background = Rect(0,
                            0,
                            width,
                            height,
                            strokeWidth=1,
                            strokeColor="#868686",
                            fillColor=None)  #边框颜色
    return d
예제 #33
0
def torta(datos):
    tamanio = datos["tamanio"]
    data = datos["data"]
    labels = datos["labels"]
    colores = datos["colores"]
    titulo = datos["titulo"]

    grafico = Pie()
    grafico.x = 10
    grafico.y = 10
    grafico.startAngle = 45
    grafico.width = tamanio
    grafico.height = tamanio
    grafico.data = data
    grafico.labels = labels
    grafico.slices.fontName = "Helvetica"
    grafico.slices.fontSize = FONTSIZE
    grafico.simpleLabels = False
    grafico.sideLabels = 1
    grafico.sideLabelsOffset = 0.075
    grafico.slices.label_simple_pointer = False
    grafico.slices.label_pointer_elbowLength = 0.5
    grafico.slices.label_pointer_piePad = 3
    grafico.slices.label_pointer_edgePad = 3
    grafico.slices.label_pointer_strokeColor = colors.black
    grafico.slices.label_pointer_strokeWidth = 0.75
    grafico.slices.strokeWidth=1.5
    grafico.slices.strokeColor=colors.white
    for i in range(len(colores)):
        grafico.slices[i].fillColor = colors.HexColor(colores[i])
    retorno = crearDrawing(grafico)
    if titulo:
        etiqueta = Label()
        etiqueta.fontSize = FONTSIZE
        etiqueta.fontName = "Helvetica-Bold"
        etiqueta.setText(titulo)
        etiquetar(retorno, etiqueta, tamanio/2.0, 0.0)
    return retorno
예제 #34
0
def border():
    draw = Drawing(1, 1)
    rect = Polygon(points=[
        -12, cm / 6, (PAGE_WIDTH - (RIGHT_MARGIN + LEFT_MARGIN)), cm / 6,
        PAGE_WIDTH - (RIGHT_MARGIN + LEFT_MARGIN),
        -1 * (PAGE_HEIGHT - (TOP_MARGIN + BOTTOM_MARGIN + cm / 2)), -12,
        -1 * (PAGE_HEIGHT - (TOP_MARGIN + BOTTOM_MARGIN + cm / 2))
    ],
                   strokeColor=Color(*charts.BG_COLOR))
    rect.fillColor = Color(*charts.BG_COLOR, 0.1)
    draw.add(rect)
    draw.add(Circle(100, 90, 5, fillColor=colors.green))
    lab = Label()
    lab.setOrigin(350, -50)
    lab.boxAnchor = 'ne'
    lab.fillColor = Color(*charts.BG_COLOR, 0.15)
    lab.fontSize = 72
    lab.angle = 60
    lab.dx = 0
    lab.dy = 0
    lab.setText('Wisdom Tests')
    draw.add(lab)
    return draw
예제 #35
0
def barras(datos):
    alto = datos["alto"]
    ancho = datos["ancho"]
    data = datos["data"]
    labels = datos["labels"]
    colores = datos["colores"]

    grafico = VerticalBarChart()
    grafico.x = 30
    grafico.y = 0
    grafico.height = alto
    grafico.width = ancho
    grafico.data = data
    grafico.barSpacing = 1.25
    for i in range(len(colores)):
        color = colors.HexColor(colores[i])
        grafico.bars[i].strokeColor = color
        grafico.bars[i].fillColor = color
    grafico.valueAxis.labels.fontName = "Helvetica"
    grafico.valueAxis.labels.fontSize = FONTSIZE
    grafico.valueAxis.valueMin = 0
    grafico.valueAxis.valueMax = 100
    grafico.valueAxis.valueStep = 10
    grafico.categoryAxis.categoryNames = labels
    grafico.categoryAxis.labels.fontName = "Helvetica"
    grafico.categoryAxis.labels.fontSize = FONTSIZE
    grafico.categoryAxis.labels.dy = -FONTSIZE
    grafico.categoryAxis.labels.boxAnchor = 'c'
    grafico.categoryAxis.labels.angle = 0
    retorno = crearDrawing(grafico)
    etiqueta = Label()
    etiqueta.setOrigin(0, alto)
    etiqueta.fontSize = FONTSIZE
    etiqueta.fontName = "Helvetica"
    etiqueta.setText("(%)")
    retorno.add(etiqueta)
    return retorno
예제 #36
0
def addAxis(drawing, xmap, y, fontSize=8, tickLen=4, minorTickLen=2, 
 nTicks=20, strokeWidth=1, minorStrokeWidth=0.5):
    line = Line(xmap.x0, y, xmap.x1, y, strokeWidth=strokeWidth)
    drawing.add(line)

    ticks = tick_generator(xmap.start, xmap.end, n=nTicks, convert=int)
    for p in ticks:
        x = xmap(p)
        line = Line(x, y, x, y-tickLen, strokeWidth=strokeWidth)
        drawing.add(line)
        s = Label()
        s.setOrigin(x, y-tickLen)
        s.setText(str(p))
        s.fontName = 'Helvetica'
        s.fontSize = fontSize
        s.textAnchor = 'middle'
        s.boxAnchor = 'n'
        drawing.add(s)

    minorticks = tick_generator(xmap.start, xmap.end, n=50, convert=int)
    for p in minorticks:
        x = xmap(p)
        line = Line(x, y, x, y-minorTickLen, strokeWidth=minorStrokeWidth)
        drawing.add(line)
예제 #37
0
파일: graph.py 프로젝트: SF73/Diamfab
def genLayers(l0=["substrate", 30], l1=["p++", 20], l2=["p--", 50]):
    c = ['#ffeea0', '#ff88ff', '#bbd5e8']
    length = 4 * cm
    d = Drawing(4 * cm, 100)
    xpos = 0  #*(width-length-4*cm)/2
    #        layer0 = 40
    #        l1[1] = 40
    #        l2[1]= 100-layer0-l1[1]
    l0[1], l1[1], l2[1] = layersize(l0[1], l1[1], l2[1])

    d.add(Rect(xpos, 0, length, l0[1], fillColor=colors.HexColor(c[0])))
    lab = Label()
    lab.textAnchor = 'middle'
    lab.setText(l0[0])
    lab.setOrigin(xpos + 2 * cm, l0[1] / 2)
    d.add(lab)

    d.add(Rect(xpos, l0[1], length, l1[1], fillColor=colors.HexColor(c[1])))
    lab = Label()
    lab.textAnchor = 'middle'
    lab.setText(l1[0])
    lab.setOrigin(xpos + 2 * cm, l0[1] + l1[1] / 2)
    d.add(lab)

    d.add(
        Rect(xpos,
             l0[1] + l1[1],
             length,
             l2[1],
             fillColor=colors.HexColor(c[2])))
    lab = Label()
    lab.textAnchor = 'middle'
    lab.setText(l2[0])
    lab.setOrigin(xpos + 2 * cm, l0[1] + l1[1] + l2[1] / 2)
    d.add(lab)

    return d
예제 #38
0
파일: report.py 프로젝트: rayene/netpylab
    def draw_hex(self):
        print 'Reporting Hex'
        story = []
        for p in self.world.packets:
            pl,t = p.build_ps()
            XSTART = 0
            XDSTART = 210
            y = 0.0
            XMUL= 100.0
            YMUL = 10.0
            larg = 16
            YDUMP = PAGE_HEIGHT*0.80/YMUL - 10
            YDUMP = 0
            canvas = shapes.Drawing(500, 100)
            # canvas.add(shapes.Rect(0,0, 500, PAGE_HEIGHT, fillColor=colors.yellow))
            backcolor=colgen(0.6, 0.8, 1.0)
            forecolor=colgen(0.2, 0.5, 0.8)
            def hexstr(x):
                s = []
                for c in x:
                    s.append("%02x" % ord(c))
                return " ".join(s)

            my_y = 0
            shift = 0
            last_x = 0
            while t:
                bkcol = backcolor.next()
                proto,fields = t.pop()
                l = Label()
                l.setText(proto.name)
                l.boxAnchor = 'w'
                l.boxStrokeColor = colors.gray
                bc = colors.Color(bkcol[0], bkcol[1], bkcol[2] )
                l.boxFillColor = bc
                l.setOrigin(XSTART, (YDUMP-y)*YMUL)
                canvas.add(l)
                my_y = y
                for fname, fval, fdump in fields:
                    y += 1.5
                    col = forecolor.next()
                    l = Label()
                    l.boxAnchor = 'w'
                    l.setText(fname.name)
                    l.setOrigin(XSTART + (0.1 * XMUL), (YDUMP-y)*YMUL)
                    canvas.add(l)
                    
                    if fval is not None:
                        if len(fval) > 24:
                            fval = fval[:21]+"..."
                    else:
                        fval=""
                    
                    l = Label()
                    l.setText(fval)
                    xlabel, ylabel = XSTART+(1.5*XMUL), (YDUMP-y)*YMUL
                    l.setOrigin(xlabel, ylabel)
                    l.boxStrokeWidth = 2
                    l.boxAnchor = 'e'
                    canvas.add(l)
                    
                    first = True
                    while fdump:
                        dmp, fdump = fdump[:larg-shift],fdump[larg-shift:]
                        l = Label()
                        l.boxAnchor = 'w'
                        l.fontName = 'Courier'
                        l.boxFillColor = colors.Color(bkcol[0], bkcol[1], bkcol[2])
                        l.boxStrokeColor = colors.Color(col[0], col[1], col[2])
                        l.boxStrokeWidth = 2
                        xdump, ydump = XDSTART+ last_x * 0.06*XMUL, (YDUMP-my_y)*YMUL
                        l.setOrigin(xdump, ydump)
                        h = hexstr(dmp)
                        l.setText(h)
                        canvas.add(l)
                        if first:
                            link = shapes.Line(xdump, ydump, xlabel, ylabel, strokeColor=colors.Color(col[0], col[1], col[2]), strokeWidth=1)
                            canvas.add(link)
                            first = False
                        shift += len(dmp)
                        last_x += len(h) +1
                        if shift >= larg:
                            shift = 0
                            last_x = 0
                            my_y += 2
                y += 2
            scale = 0.7
            canvas.shift(0, y * YMUL*scale)
            canvas.height = min(y * YMUL *scale , PAGE_HEIGHT*0.80)
            canvas.scale(scale, scale)
            # para = Paragraph('<a name="hex%d"/>'%p.number + \
            # '<a href="#summary%d">(%d) %s</a>' % (p.number, p.number, p.description), styles['Normal'])
            # story.append([[para, Spacer(1,10), canvas]])
            para = Paragraph('<a href="#summary%d">(%d) %s</a>' % (p.number, p.number, p.description), styles['Normal'])
            story.append([[para, Spacer(1,10), canvas]])

        t = Table(story)
        t.setStyle(TableStyle([
                        ('INNERGRID', (0,0), (-1,-1), 0.1, colors.black), 
                        ('BOX', (0,0), (-1,-1), 0.1, colors.black), 
                        ]))
        return [t]
예제 #39
0
def addCompoundFeature(drawing, xmap, y, gene, 
  strokeColor=None, fillColor=colors.blue, 
  intronColor=colors.blue, intronWidth=0.5,
  glyph=Block, height=12, utrHeight=6,
  labeldy=10, fontSize=10, textAnchor='middle', boxAnchor='s'):
    """Adds a compund feature to the drawing.
    A compound feature is typically several exons joined by zig-zag lines."""
    rise = height + utrHeight
    
    intronStarts = [None]
    intronEnds = []
    heights = []
    for exon in gene:
        x1,x2 = xmap(exon.start), xmap(exon.end)
        
        kind = exon.kind.lower()
        if kind in ['exon', 'utr']:
            intronStarts.append(exon.end)
            intronEnds.append(exon.start)
        
        g = glyph()
        g.x = x1
        g.y = y+height/2
        if exon.kind.lower()=='exon':
            g.height = height
            heights.append(height)
        else:
            g.height = utrHeight
            heights.append(utrHeight)
        
        g.length = x2-x1
        g.fillColor = fillColor
        if strokeColor:
            g.strokeColor = strokeColor
        else:
            g.strokeColor = fillColor
        g.fontSize = fontSize
        drawing.add(g)
    
    for i,(intronStart,intronEnd) in enumerate(zip(intronStarts[1:], intronEnds[1:])):
        x1 = xmap(intronStart)
        x2 = xmap(0.5*(intronStart+intronEnd))
        x3 = xmap(intronEnd)
        # if abs(x3-x1)<3: continue
        # print intronStart,intronEnd,heights[i],heights[i+1]
        
        y1 = y+heights[i]/2+height/2
        y2 = y+rise
        y3 = y+heights[i+1]/2+height/2
        
        line1 = Line(x1,y1,x2,y2,strokeColor=intronColor,strokeWidth=intronWidth)
        line2 = Line(x2,y2,x3,y3,strokeColor=intronColor,strokeWidth=intronWidth)
        drawing.add(line1)
        drawing.add(line2)
    
    # Draw arrows
    if xmap.flipped:
        signum = -1
    else:
        signum = 1
    
    if gene.strand=='+':
        x1 = xmap(gene.end)
        x2 = x1 + signum*15
        x3 = x1 + signum*10
        y1 = y + 0.5*height
        y2 = y + 0.75*height
        y3 = y + 0.25*height
        line1 = Line(x1,y1,x2,y1,strokeColor=intronColor,strokeWidth=intronWidth)
        line2 = Line(x2,y1,x3,y2,strokeColor=intronColor,strokeWidth=intronWidth)
        line3 = Line(x2,y1,x3,y3,strokeColor=intronColor,strokeWidth=intronWidth)
        drawing.add(line1)
        drawing.add(line2)
        drawing.add(line3)
    else:
        x1 = xmap(gene.start)
        x2 = x1 - signum*15
        x3 = x1 - signum*10
        y1 = y + 0.5*height
        y2 = y + 0.75*height
        y3 = y + 0.25*height
        line1 = Line(x1,y1,x2,y1,strokeColor=intronColor,strokeWidth=intronWidth)
        line2 = Line(x2,y1,x3,y2,strokeColor=intronColor,strokeWidth=intronWidth)
        line3 = Line(x2,y1,x3,y3,strokeColor=intronColor,strokeWidth=intronWidth)
        drawing.add(line1)
        drawing.add(line2)
        drawing.add(line3)
    
    # if gene has attribute name...
    label = Label()
    label.setText(gene.name)
    pos = 0.5*(gene.start+gene.end)
    x = xmap(pos)
    label.setOrigin(x,y)
    label.dy = labeldy
    label.textAnchor = textAnchor
    label.boxAnchor = boxAnchor
    drawing.add(label)
예제 #40
0
    def draw(self):
        g = Group()

        #box
        g.add(Rect(self.x,self.y,len(self.xlabels)*self.gridDivWidth,len(self.ylabels)*self.gridDivWidth,
                   strokeColor=self.gridColor,
                   strokeWidth=self.strokeWidth,
                   fillColor=None))

        #internal gridding
        for f in range (1,len(self.ylabels)):
            #horizontal
            g.add(Line(strokeColor=self.gridColor,
                       strokeWidth=self.strokeWidth,
                       x1 = self.x,
                       y1 = self.y+f*self.gridDivWidth,
                       x2 = self.x+len(self.xlabels)*self.gridDivWidth,
                       y2 = self.y+f*self.gridDivWidth))
        for f in range (1,len(self.xlabels)):
            #vertical
            g.add(Line(strokeColor=self.gridColor,
                       strokeWidth=self.strokeWidth,
                       x1 = self.x+f*self.gridDivWidth,
                       y1 = self.y,
                       x2 = self.x+f*self.gridDivWidth,
                       y2 = self.y+len(self.ylabels)*self.gridDivWidth))

        # draw the 'dot'
        g.add(Circle(strokeColor=self.gridColor,
                     strokeWidth=self.strokeWidth,
                     fillColor=self.dotColor,
                     cx = self.x+(self.dotXPosition*self.gridDivWidth),
                     cy = self.y+(self.dotYPosition*self.gridDivWidth),
                     r = self.dotDiameter/2.0))

        #used for centering y-labels (below)
        ascent=getFont(self.labelFontName).face.ascent
        if ascent==0:
            ascent=0.718 # default (from helvetica)
        ascent=ascent*self.labelFontSize # normalize

        #do y-labels
        if self.ylabels != None:
            for f in range (len(self.ylabels)-1,-1,-1):
                if self.ylabels[f]!= None:
                    g.add(String(strokeColor=self.gridColor,
                             text = self.ylabels[f],
                             fontName = self.labelFontName,
                             fontSize = self.labelFontSize,
                             fillColor=_PCMYK_black,
                             x = self.x-self.labelOffset,
                             y = self.y+(f*self.gridDivWidth+(self.gridDivWidth-ascent)/2.0),
                             textAnchor = 'end'))

        #do x-labels
        if self.xlabels != None:
            for f in range (0,len(self.xlabels)):
                if self.xlabels[f]!= None:
                    l=Label()
                    l.x=self.x+(f*self.gridDivWidth)+(self.gridDivWidth+ascent)/2.0
                    l.y=self.y+(len(self.ylabels)*self.gridDivWidth)+self.labelOffset
                    l.angle=90
                    l.textAnchor='start'
                    l.fontName = self.labelFontName
                    l.fontSize = self.labelFontSize
                    l.fillColor = _PCMYK_black
                    l.setText(self.xlabels[f])
                    l.boxAnchor = 'sw'
                    l.draw()
                    g.add(l)

        return g
from reportlab.graphics import shapes
from reportlab.graphics.charts.textlabels import Label

d = Drawing(200, 100)

# mark the origin of the label
d.add(Circle(100,90, 5, fillColor=colors.green))

lab = Label()
lab.setOrigin(100,90)
lab.boxAnchor = 'ne'
lab.angle = 45
lab.dx = 0
lab.dy = -20
lab.boxStrokeColor = colors.green
lab.setText('Some\nMulti-Line\nLabel')

d.add(lab)

draw(d, 'Label example')



disc("""
In the drawing above, the label is defined relative to the green blob.
The text box should have its north-east corner ten points down from
the origin, and be rotated by 45 degrees about that corner.
""")

disc("""
At present labels have the following properties, which we believe are
lp.data = [accuracy_list]
print lp.data

lp.joinedLines = 1
lp.lines.symbol = makeMarker('Circle')
lp.lineLabelFormat = '%2.2f'
lp.strokeColor = colors.black
lp.xValueAxis.valueMin = 0
lp.xValueAxis.valueMax = 5
lp.xValueAxis.labelTextFormat = '%2.0f'
lp.yValueAxis.valueMin = 0
lp.yValueAxis.valueMax = 104
lp.yValueAxis.valueStep = 10

xlbl = Label()
xlbl.setText("No. of Clusters")
xlbl.setOrigin(310, 53)

xlbl1 = Label()
xlbl1.setText("No. Of Clusters Vs Accuracy")
xlbl1.setOrigin(310, 25)

ylbl = Label()
ylbl.setText("Accuracy\n      (%)")
ylbl.setOrigin(28, 260)

lp.lines[0].strokeColor = colors.purple
lp.lineLabels[0].strokeColor = colors.purple

d.add(lp)
d.add(xlbl)
예제 #43
0
def makeSummary(self, stype):
  logger.debug('StartQT4::makeSummary(%s)' % stype)
  pinfo = self.imageViews[-1].getSummaryDemographics()
  if pinfo is None:
    return

  reportname = self.imageViews[-1].getReportName()+'.pdf'
  filename = QtGui.QFileDialog.getSaveFileName(self, directory=reportname, filter='PDF Files *.pdf(*.pdf);;All Files *(*)')
  #filename = QtGui.QFileDialog.getSaveFileName(self, filter='PDF Files *.pdf(*.pdf);;All Files *(*)')
  if len(filename) == 0:
    return
  doc = SimpleDocTemplate(str(filename), pagesize=A4, rightMargin=1.5*cm, leftMargin=2*cm, topMargin=2*cm, bottomMargin=3*cm)
  elements = []
  #data = pinfo.items()

  for iv in self.imageViews:
    vt = iv.getVelocityText()
    if stype == 'BOTH' or stype == iv.getViewShortName():
      pinfo.append(vt)
  t=Table(pinfo, rowHeights=12)
  t.setStyle(TableStyle([('BACKGROUND',(1,1),(-2,-2),colors.green),
			('TEXTCOLOR',(0,0),(1,-1),colors.black),
			('ALIGNMENT', (0,0),(0,-1), 'RIGHT')]))

  elements.append(t)
  for iv in self.imageViews:
    if stype == 'BOTH' or stype == iv.getViewShortName():
      drawing = Drawing(400, 280)
      cd = iv.getDataPointer()
      vt = iv.getVelocityText()
      pinfo.append(vt)
      #ydata = cd.getCOMYScaled(False, 'mm').tolist()
      ydata = cd.getCOMYScaled(True, 'mm').tolist()
      xPlaneFit = cd.getYPlaneFit(units='mm', bothAxes=True).tolist()
      vdata = cd.getVelocitySlopeScaled(units='mm', bothAxes=True)
      gdata = [ydata, xPlaneFit]
      if vdata is not None:
	gdata.append(vdata.tolist())
      title = Label()
      title.setOrigin(150, 240)
      title.setText(iv.getViewName())
      ylabel = Label()
      ylabel.setOrigin(0, 100)
      ylabel.angle = 90
      ylabel.setText("Millimeters")
      xlabel = Label()
      xlabel.setOrigin(70, 0)
      xlabel.setText("Seconds")
      lp = LinePlot()
      lp.height = 230
      lp.width = 400
      lp.data = gdata
      lp.lines[0].strokeColor = colors.blue
      lp.lines[1].strokeColor = colors.red
      lp.lines[2].strokeColor = colors.green
      #lp.xValueAxis.xLabel = "Seconds"
      drawing.add(title)
      drawing.add(ylabel)
      drawing.add(xlabel)
      drawing.add(lp)
      elements.append(drawing)

  doc.build(elements, onFirstPage=self.pdfHeaderFooter, onLaterPages=self.pdfHeaderFooter)
lp.data = [pos_pers, neg_pers, nor_pos_pers, nor_neg_pers]
print lp.data

lp.joinedLines = 1
lp.lines.symbol = makeMarker('Circle')
lp.lineLabelFormat = '%2.2f'
lp.strokeColor = colors.black
lp.xValueAxis.valueMin = 0
lp.xValueAxis.valueMax = 2100
lp.xValueAxis.labelTextFormat = '%2.0f'
lp.yValueAxis.valueMin = 0
lp.yValueAxis.valueMax = 100
lp.yValueAxis.valueStep = 10

xlbl = Label()
xlbl.setText("No. of Genes")
xlbl.setOrigin(310, 72)

ylbl = Label()
ylbl.setText("Percentage\n      (%)")
ylbl.setOrigin(28, 260)

lp.lines[0].strokeColor = colors.darkgreen
lp.lineLabels[0].strokeColor = colors.darkgreen
lp.lines[1].strokeColor = colors.tomato
lp.lineLabels[1].strokeColor = colors.tomato
lp.lines[2].strokeColor = colors.aquamarine
lp.lineLabels[2].strokeColor = colors.aquamarine
lp.lines[3].strokeColor = colors.purple
lp.lineLabels[3].strokeColor = colors.purple
예제 #45
0
        legend.dy = 5
        legend.dx = 5
        legend.deltay = 5
        legend.alignment ='right'

        drawing.add(lp)
        drawing.add(legend)

        if title != None:
            label = Label()
            label.x = w
            label.y = h - 25
            label.boxAnchor = 'se'
            label.fontName = 'Helvetica'
            label.fontSize = 10
            label.setText(title)
            drawing.add(label)
        return drawing

    def drawTable(self, data):
        t = Table(data, None, None, None, 1, 1, 1)
        extraStyle = []
        for i in range(len(data[1:])):
            if data[1:][i][0] == 'Free' or data[1:][i][0] == 'Used':
                extraStyle.append(('BACKGROUND', (0, i + 1), (-1, i + 1), colors.orange))
            if data[1:][i][0] == 'SwapUsage' or data[1:][i][0] == 'LMK File':
                extraStyle.append(('BACKGROUND', (0, i + 1), (-1, i + 1), colors.lightgreen))
        t.setStyle(TableStyle([('FONT', (0, 0), (-1, -1), 'Helvetica'),
                               ('BACKGROUND', (0, 0), (-1, 0), colors.deepskyblue),
                               ('FONTSIZE', (0, 0), (-1, -1), 10),
                               ('GRID', (0, 0), (-1, -1), 1, colors.black),
예제 #46
0
from reportlab.graphics import shapes
from reportlab.graphics.charts.textlabels import Label

d = Drawing(200, 100)

# mark the origin of the label
d.add(Circle(100, 90, 5, fillColor=colors.green))

lab = Label()
lab.setOrigin(100, 90)
lab.boxAnchor = "ne"
lab.angle = 45
lab.dx = 0
lab.dy = -20
lab.boxStrokeColor = colors.green
lab.setText("Some\nMulti-Line\nLabel")

d.add(lab)

draw(d, "Label example")


disc(
    """
In the drawing above, the label is defined relative to the green blob.
The text box should have its north-east corner ten points down from
the origin, and be rotated by 45 degrees about that corner.
"""
)

disc(
예제 #47
0
파일: caly.py 프로젝트: moshahmed/astronomy
def half_year(title,city, year, startmon):
    '''startmon is the 1-indexed month to start the page on'''
    reqd, mons = get_months(year, startmon)

    LEFTMARGIN  = 5
    DAYCOLWIDTH = 50
    CELLWIDTH   = 80
    CELLHEIGHT  = 19
    TOPROWHEIGHT = 18
    WIDTH = LEFTMARGIN + DAYCOLWIDTH + CELLWIDTH*6
    HEIGHT = reqd * CELLHEIGHT + TOPROWHEIGHT

    d = shapes.Drawing(WIDTH, HEIGHT)

    lab = Label()
    lab.setOrigin(LEFTMARGIN,HEIGHT)
    lab.boxAnchor = 'nw'
    lab.setText(title)
    lab.fontName = 'Times-Bold'
    d.add(lab)

    # Month headings
    for i in range(6):
        x = LEFTMARGIN + i*CELLWIDTH + DAYCOLWIDTH + CELLWIDTH/2
        month_name = calendar.month_abbr[i + startmon]
        d.add(shapes.String(x, HEIGHT-14, month_name,
            fontSize=14, fontName='Times-Bold', textAnchor='middle'))

    # Day row headings
    for i in range(reqd):
        y = HEIGHT - i*CELLHEIGHT - TOPROWHEIGHT
        weekday_name = calendar.day_abbr[i%7]
        d.add(shapes.String(LEFTMARGIN + 10, y-14, weekday_name,
            fontSize=14))

    # Draw the day cells, for each month
    for j in range(6):
      x = LEFTMARGIN + j*CELLWIDTH + DAYCOLWIDTH
      # for each day
      for i in range(reqd):
        if i >= len(mons[j]) or not mons[j][i]:
          continue
        y = HEIGHT - i*CELLHEIGHT - TOPROWHEIGHT
        # cells for each day, light grey background if weekend
        weekend = i%7 > 4
        lightgrey = colors.HexColor(0xD0B090)
        color = weekend and lightgrey or colors.white

        # Now we have (x, y, color) for (year, month=j+startmon, day=mons[j][i])
        # Get the ephemerides for the date
        date = datetime.datetime(year, j+startmon, mons[j][i])
        (sunrise, sunset, moon_phase, moon_fm) = ephem3.ephem_one_day(city, date)

        # Insert the date cell at x, y
        d.add(shapes.Rect(x, y, CELLWIDTH, -CELLHEIGHT, fillColor=color))
        d.add(shapes.String(x+1, y-10, str(mons[j][i]), fontSize=10))
        green = colors.HexColor(0x207020)

        # Insert the moon phase
        if moon_fm:
          d.add(shapes.String(x+15, y-10, moon_fm, fontSize=8, fillColor=green))
      # for each day
    # for each month
    return d
        def _rawDraw(self, x, y):
            from reportlab.lib import colors 
            from reportlab.graphics.shapes import Drawing, Line, String, STATE_DEFAULTS
            from reportlab.graphics.charts.axes import XCategoryAxis,YValueAxis
            from reportlab.graphics.charts.textlabels import Label
            from reportlab.graphics.charts.barcharts  import VerticalBarChart
            
            self.originX = x
            self.originY = y
            self._setScale([self.dataBar])
            (x1, y1, Width, Height) = self._getGraphRegion(x, y)

            #Build the graph
            self.drawing = Drawing(self.width, self.height)

            #Size of the Axis
            SizeXaxis = 14
            countSteps = int(self.valueMax / self.valueStep)
            SizeYaxis = 0.0
            for n in range(countSteps + 1):
                eachValue = self.valueMin + n * self.valueStep
                textString = self._customSecondsLabelFormat( eachValue )
                SizeYaxis = max(SizeYaxis, self._stringWidth(textString, STATE_DEFAULTS['fontName'], STATE_DEFAULTS['fontSize']) )

            bc = VerticalBarChart()
            SizeYaxis += bc.valueAxis.tickLeft
            bc.x = x1 - x + SizeYaxis
            bc.y = y1 - y + SizeXaxis
            bc.height = Height - SizeXaxis
            bc.width  = Width  - SizeYaxis
            self.graphCenterX = bc.x + bc.width/2
            self.graphCenterY = bc.y + bc.height/2
            if self.validData:
                # add valid data to chart
                bc.data = self.dataBar
                bc.categoryAxis.categoryNames = self.dataNames
                # axis values
                bc.valueAxis.valueMin  = self.valueMin
                bc.valueAxis.valueMax  = self.valueMax
                bc.valueAxis.valueStep = self.valueStep
                # add value labels above bars
                bc.barLabelFormat = self._customSecondsLabelFormat
                bc.barLabels.dy = 0.08*inch
                bc.barLabels.fontSize = 6
            else:
                # no valid data
                bc.data = [ (0, ), ]
                bc.categoryAxis.categoryNames = [ '' ]
                bc.valueAxis.valueMin  = 0
                bc.valueAxis.valueMax  = 1
                bc.valueAxis.valueStep = 1
                Nodata = Label()
                Nodata.fontSize = 12
                Nodata.angle = 0
                Nodata.boxAnchor = 'c'
                Nodata.dx = self.graphCenterX
                Nodata.dy = self.graphCenterY
                Nodata.setText("NO VALID DATA")
                self.drawing.add(Nodata)
            
            # chart formatting
            (R,G,B) = VeriwaveYellow
            bc.bars[0].fillColor   = colors.Color(R,G,B)
            bc.valueAxis.labelTextFormat = self._customSecondsLabelFormat
            # axis labels
            bc.categoryAxis.labels.boxAnchor = 'c'
            bc.categoryAxis.labels.dx    = 0
            bc.categoryAxis.labels.dy    = -10
            bc.categoryAxis.labels.angle = 0
            bc.categoryAxis.labels.fontSize = 8

            # add chart
            self.drawing.add(bc)

            #Adjust the labels to be the center of the graph
            self._drawLabels(self.title, "", "")

            # Add Legend in upper right corner
            legendHeight  = 9 
            legendX = bc.x + 5
            legendY = bc.y + bc.height - 12
            self.drawing.add(Line(legendX, legendY + 3 , legendX + 20, legendY + 3, strokeColor=bc.bars[0].fillColor, strokeWidth=3 ))
            self.drawing.add(String(legendX + 22, legendY, 'MIN', fontName='Helvetica', fontSize=8))
            legendY -= legendHeight
            self.drawing.add(Line(legendX, legendY + 3 , legendX + 20, legendY + 3, strokeColor=bc.bars[1].fillColor, strokeWidth=3 ))
            self.drawing.add(String(legendX + 22, legendY, 'MAX', fontName='Helvetica', fontSize=8))
            legendY -= legendHeight
            self.drawing.add(Line(legendX, legendY + 3 , legendX + 20, legendY + 3, strokeColor=bc.bars[2].fillColor, strokeWidth=3 ))
            self.drawing.add(String(legendX + 22, legendY, 'AVG', fontName='Helvetica', fontSize=8))
            legendY -= legendHeight