Ejemplo n.º 1
0
    def getElements( self, node_id, x, y1, y2 ):

        e = []
        e.append(SVGdraw.line( x, y1, x, y2,
                                stroke = "rgb(%i,%i,%i)" % BLACK,
                                stroke_width = 1 ))
        return e
Ejemplo n.º 2
0
 def build(self):
     sp = self._head.position('s')
     dp = self._tail.position('n')
     self._extent = (abs(dp[0]-sp[0]),abs(dp[1]-sp[1]))
     self._widget = SVG.line(sp[0], sp[1], dp[0], dp[1], self._color, 
                             self._parent.strokewidth())
     self._widget.attributes['stroke-dasharray']='4,4'
Ejemplo n.º 3
0
 def build(self):
     sp = self._dest.position('n')
     dp = self._source.position('s')
     self._extent = (abs(dp[0]-sp[0]),abs(dp[1]-sp[1]))
     self._widget = SVG.line(sp[0], sp[1], dp[0], dp[1], self._color, 
                             self._parent.strokewidth())
     self._widget.attributes['marker-end'] = \
         self._parent.svgarrow(self._color, False)
Ejemplo n.º 4
0
    def getElements( self, node_id, x1, x2, y ):

        e = []
        if not self.mNoBranch:
            e.append(SVGdraw.line( x1, y, x2, y,
                                   stroke = "rgb(%i,%i,%i)" % BLACK,
                                   stroke_width = 1 ) )
        return e
Ejemplo n.º 5
0
    def getElements( self, node_id, x1, x2, y ):

        e = []
        e.append(SVGdraw.line( x1, y, x2, y,
                               stroke = "rgb(%i,%i,%i)" % BLACK,
                               stroke_width = 1 ) )
        
        e += self.mDecorator1.getElements( node_id, x1, x2, y )
        e += self.mDecorator2.getElements( node_id, x1, x2, y + self.mFontSize )        
        
        return e
    def writeScale( self ):
        """write scales."""

        current_x = self.mScaleX
        current_y = self.mScaleY + self.mScaleHeight

        nboxes = len(self.mColourThresholds)
        # box size for legend in x-direction
        # subtract size of right-most axis label so that it takes the
        # same width as self.mDataWidth.
        box_size_x = math.ceil( (self.mDataWidth -
                                (self.mScaleFontSize * len(self.mFormatNumberLegend % self.mColourThresholds[-1])))
                                / nboxes )

        # change font size such that it labels will fit between tick-marks
        self.mScaleFontSize = min( self.mScaleFontSize,
                                   (box_size_x * self.mScaleNumTicks * 1.5) / len(self.mFormatNumberLegend % self.mColourThresholds[-1]) )
        
        for x in range(nboxes):

            e = SVGdraw.rect( current_x,
                              current_y,
                              box_size_x,
                              self.mScaleBoxSizeY,                                   
                              fill = "rgb(%i,%i,%i)" % self.mColours[x],
                              stroke = "rgb(%i,%i,%i)" % self.mColours[x])                                   
            
            self.addElement(e)
            
            if x % self.mScaleNumTicks == 0:

                e = SVGdraw.line( current_x,
                                  current_y,
                                  current_x,
                                  current_y + self.mScaleBoxSizeY,
                                  stroke = "rgb(%i,%i,%i)" % BLACK,
                                  stroke_width = 5)
                self.addElement(e)
                
                e = SVGdraw.text( current_x,
                                  current_y - self.mScaleBoxSizeY,
                                  self.mFormatNumberLegend % self.mColourThresholds[x],
                                  self.mScaleFontSize,
                                  self.mScaleFont,
                                  stroke = "rgb(%i,%i,%i)" % BLACK,
                                  text_anchor = "start")
                self.addElement(e)
            
            
            current_x += box_size_x
    def writeGrid( self ):
        """add grid lines."""

        middlex = self.mDataMiddleX
        middley = self.mDataMiddleY

        ## print separators
        for c in range(len(self.contigs)):

            contig = self.contigs[c]
            
            pos = self.getPosition( contig, "+", 0)
            angle = self.getAngle( pos )

            x,y = self.getPosOnArc( angle, self.mRadius )
            
            e = SVGdraw.line( middlex,
                              middley,
                              x, 
                              y,
                              stroke = "rgb(%i,%i,%i)" % BLACK,
                              stroke_width = self.mGridStrokeWidth )

            self.addElement(e, self.mPlaneGrid )

            if c < len(self.contigs) - 1:
                next_angle = self.getAngle(self.getPosition( self.contigs[c+1], "+", 0 ) )
            else:
                next_angle = 360
            
            x,y = self.getPosOnArc( angle + float(next_angle - angle) / 2, self.mRadiusStart / 2)
            
            e = SVGdraw.text( x,
                              y,
                              contig,
                              self.mGridFontSize,
                              self.mGridFont,
                              stroke = "rgb(%i,%i,%i)" % BLACK,
                              text_anchor = "start" )
            # do not rotate text:
            # transform="rotate(%i,%i,%i)" % ( angle, x, y ))

            self.addElement(e)
Ejemplo n.º 8
0
	def toSVG(self):
		#modification du maximum en X : depend du nombre d'element
		global XMAX
		XMAX = len(self.infos)*(BAR_THICKNESS+SPACE)
		# creation du document
		doc=SVGdraw.drawing()
		svg=SVGdraw.svg(None, '100%','100%')
		
		# creation des patterns pour les axes et la grille
		axeX = SVGdraw.pattern(id="axeX",width="20",height="10",patternUnits="userSpaceOnUse")
		axeX.addElement(SVGdraw.path("M 0 0, L 0 10","none","black","0.25"))
		axeX.addElement(SVGdraw.path("M 10 10, V 5","none","lightgray","0.25"))
		axeY = SVGdraw.pattern(id="axeY",width="10",height="20",patternUnits="userSpaceOnUse")
		axeY.addElement(SVGdraw.path("M 0 0, L 10 0","none","black","0.25"))
		axeY.addElement(SVGdraw.path("M 5 10, L 10 10","none","lightgray","0.25"))
		grid = SVGdraw.pattern(id="grid",width="10",height="10",patternUnits="userSpaceOnUse")
		grid.addElement(SVGdraw.path("M 0 0, L 10 0, L 10 10,L 0 10, L 0 0","none","lightgray","0.25"))

		defs=SVGdraw.defs()
		defs.addElement(axeX)
		defs.addElement(axeY)
		defs.addElement(grid)
		svg.addElement(defs)
		
		group=SVGdraw.group(transform="translate(130,130) scale(1,-1)")
		
		# dessin de la grille de fond
		group.addElement(SVGdraw.rect(0,0,XMAX,YMAX,"url(#grid)","lightgray","0.25"))
	
		# dessin des axes
		group.addElement(SVGdraw.rect(0,-10,XMAX,10,"url(#axeX)"))
		group.addElement(SVGdraw.rect(-10,0,10,YMAX,"url(#axeY)"))
		group.addElement(SVGdraw.line(0,0,XMAX,0,"black",1))
		group.addElement(SVGdraw.line(0,0,0,YMAX,"black",1))
		# dessin des fleches des axes
		group.addElement(SVGdraw.polygon([[-3,YMAX],[3,YMAX],[0,YMAX+10]], "black","white"))
		group.addElement(SVGdraw.polygon([[XMAX,-3],[XMAX,3],[XMAX+10,0]], "black","white"))
		
		textgroup=SVGdraw.group(transform="scale(1,-1)")
		# graduations
		for y in range(0,YMAX+STEP,STEP):
			textgroup.addElement(SVGdraw.text(-STEP,y, str(y), 8, text_anchor="middle", transform="translate(0,%d)"%(-y*2)))
		textgroup.addElement(SVGdraw.text(0,YMAX+SPACE, r"%", 8, transform="translate(0,%d)"%(-(YMAX+SPACE)*2)))
		
		# ajout de la legende principale
		legendText = "Repertoire %s - taille %.02f ko"%(self.rootName,float(self.totalSize/1024.0))
		textgroup.addElement(SVGdraw.text(XMAX,YMAX+3*SPACE, legendText,12, "verdana", 
			text_anchor="end", fill="darkblue",transform="translate(0,%d)"%(-(YMAX+3*SPACE)*2)))
		
		group.addElement(textgroup)
		
		# tri des elements selon la taille occupee
		self.infos.sort(self.tupleCmp)
		
		xincr=0
		#self.infos
		for (name,size) in self.infos:
			# calcul du pourcentage de place occupe
			pourcent = (100.0*float(size))/float(self.totalSize)
			height=int(pourcent*YMAX/100);
			# insertion du texte de l'emplacement sur le disque et de la taille occupee en Ko
			legendText = "%s (%### ###.02f ko)"%(name,float(size/1024.0))
			legend = SVGdraw.text(xincr+BAR_THICKNESS/2, -10,legendText,8,"verdana",text_anchor="begin",fill="blue")
			legend.attributes["transform"]="scale(1,-1) translate(0,20) rotate(45,%d,-10)"%(xincr+BAR_THICKNESS/2)
			group.addElement(legend)
			
			#insertion de la barre representant le pourcentage
			group.addElement(SVGdraw.rect(xincr,0,BAR_THICKNESS, height,"green","black",opacity=0.5))
			
			#insertion de la taille en pourcentage a gauche de la barre
			pourcentText=SVGdraw.text(xincr+BAR_THICKNESS/2, height+SPACE,"%02.01f%% "%pourcent,6,
				"arial", text_anchor="middle", fill="black")
			pourcentText.attributes["transform"]="scale(1,-1) translate(0,-%d)"%((height+SPACE)*2)
			group.addElement(pourcentText)
			# augmentation du l'abscisse en X
			xincr = xincr+BAR_THICKNESS+SPACE
			
		svg.addElement(group)
		doc.setSVG(svg)
		doc.toXml(self.svgURL)
Ejemplo n.º 9
0
def dbgLn(x1,y1,x2,y2,c='red',w=3):
    debugw.append(SVG.line(x1,y1,x2,y2,c,w))
Ejemplo n.º 10
0
 def build(self):
     SvgBaseChangeset.build(self)
     (fgc, bgc) = (self._strokecolor, self._fillcolor)
     txc = self._textcolor
     if 'firstchangeset' in self._classes:
         (fgc, bgc) = (bgc, fgc)
     if 'lastchangeset' in self._classes:
         bgc = SvgColor('black')
         txc = SvgColor('white')
         
     widgets = []
     if self._shape == 'circle':
         widgets.append(SVG.circle(self._position[0], self._position[1],
                                   self._radius, bgc, fgc,
                                   self._parent.strokewidth()))
         if self._enhance:
             (x,y) = self._position
             (d,hr) = (self._radius*SQRT3/2, self._radius/2)
             widgets.append(SVG.line(x-d,y-hr,x+d,y-hr, 
                                     fgc, self._parent.strokewidth()))
             widgets.append(SVG.line(x-d,y+hr,x+d,y+hr, 
                                     fgc, self._parent.strokewidth()))
                           
     elif self._shape == 'square':
         r = UNIT/6
         size = self._radius-r
         widgets.append(SVG.rect(self._position[0]-size, 
                                 self._position[1]-size,
                                 2*size, 2*size, bgc, fgc,
                                 self._parent.strokewidth()))
         outline.attributes['rx'] = r
         outline.attributes['ry'] = r        
         
     elif self._shape == 'hexa':
         (x,y) = self._position
         (r,hr) = (self._radius, self._radius/2)
         pd = SVG.pathdata()
         pd.move(x,y-r)
         pd.line(x+r,y-hr)
         pd.line(x+r,y+hr)
         pd.line(x,y+r)
         pd.line(x-r,y+hr)
         pd.line(x-r,y-hr)
         pd.line(x,y-r)
         widgets.append(SVG.path(pd, bgc, fgc, 
                                 self._parent.strokewidth()))
     else:
         raise AssertionError, \
               "unsupported changeset shape (%d)" % self._revision
     title = SVG.text(self._position[0], 
                      self._position[1] + UNIT/6,
                      str(self._revision), 
                      self._parent.fontsize(), self._parent.fontname())
     title.attributes['style'] = 'fill:%s; text-anchor: middle' % txc.rgb()
     widgets.append(title)
     g = SVG.group('grp%d' % self._revision, elements=widgets)
     link = "%s/changeset/%d" % (self._parent.urlbase(), self._revision)
     self._link = SVG.link(link, elements=[g])
     if self._revision:
         self._link.attributes['style'] = \
             'color: %s; background-color: %s' % \
                 (self._strokecolor, self._fillcolor)
         self._link.attributes['id'] = 'rev%d' % self._revision
         self._link.attributes['class'] = ' '.join(self._classes)
Ejemplo n.º 11
0
    def writeFooter( self ):
        """write footer.

        The footer contains the legend.
        """
        total_branch_length = (max(self.mNodeWidthsEnd) - min(self.mNodeWidthsStart)) / self.mBranchScaleFactor
        
        self.mFooterX = self.getHeaderWidth()
        self.mFooterY = self.getHeaderHeight() + self.mDataHeight + self.mSeparatorHeight

        ruler_start = self.mFooterX
        ruler_end = self.mFooterX + int(total_branch_length * self.mBranchScaleFactor)

        if "ruler" in self.mRulerElements:
            ## full length ruler with tick marks and labels
            e = SVGdraw.line( ruler_start,
                              self.mFooterY + self.mRulerTickSize + 1,
                              ruler_end,
                              self.mFooterY + self.mRulerTickSize + 1,
                              stroke = "rgb(%i,%i,%i)" % BLACK,
                              stroke_width = 1 )
            self.addElement( e )

            ## get reasonable intervalls

        increment = self.mRulerIncrement * self.mBranchScaleFactor

        ## adjust increment for extremely long trees
        if (ruler_end - ruler_start) / increment > 1000:
            increment = (ruler_end - ruler_start) / 1000.0
            self.mRulerIncrement = increment / self.mBranchScaleFactor
        
        if "right-ticks" in self.mRulerElements:

            x = ruler_end
            while x >= ruler_start:
                e = SVGdraw.line( x,
                                  self.mFooterY,
                                  x,
                                  self.mFooterY + 2 * self.mRulerTickSize + 1,
                                  stroke = "rgb(%i,%i,%i)" % BLACK,
                                  stroke_width = 1 )
                self.addElement( e )
                x -= self.mRulerIncrement * self.mBranchScaleFactor
                
            self.mFooterY += 2 * self.mRulerTickSize + 1 + self.mSeparatorHeight

        if "left-ticks" in self.mRulerElements:
            
            x = ruler_start
            while x <= ruler_end:
                e = SVGdraw.line( x,
                                  self.mFooterY,
                                  x,
                                  self.mFooterY + 2 * self.mRulerTickSize + 1,
                                  stroke = "rgb(%i,%i,%i)" % BLACK,
                                  stroke_width = 1 )
                self.addElement( e )
                x += increment
                
            self.mFooterY += 2 * self.mRulerTickSize + 1 + self.mSeparatorHeight

        if "scale" in self.mRulerElements:

            w = int(self.mRulerIncrement * self.mBranchScaleFactor)
            
            e = SVGdraw.line( ruler_end,
                              self.mFooterY + self.mRulerTickSize + 1,
                              ruler_end - w,
                              self.mFooterY + self.mRulerTickSize + 1,
                              stroke = "rgb(%i,%i,%i)" % BLACK,
                              stroke_width = 1 )
            
            self.addElement( e )
            
            e = SVGdraw.line( ruler_end,
                              self.mFooterY,
                              ruler_end,
                              self.mFooterY + 2 * self.mRulerTickSize + 1,
                              stroke = "rgb(%i,%i,%i)" % BLACK,
                              stroke_width = 1 )
            
            self.addElement( e )

            e = SVGdraw.line( ruler_end - w,
                              self.mFooterY,
                              ruler_end - w,
                              self.mFooterY + 2 * self.mRulerTickSize + 1,
                              stroke = "rgb(%i,%i,%i)" % BLACK,
                              stroke_width = 1 )
            
            self.addElement( e )

            e = SVGdraw.text( ruler_end - w / 2,
                              self.mFooterY + 2 * self.mRulerTickSize + 1 + self.mRulerFontSize ,
                              self.mRulerFormat % self.mRulerIncrement,
                              self.mRulerFontSize,
                              self.mRulerFont,
                              stroke = "rgb(%i,%i,%i)" % BLACK,
                              text_anchor = "middle" )

            self.addElement(e)
            self.mFooterY += 2 * self.mRulerTickSize + 1 + self.mRulerFontSize 
            
        e, self.mFooterX, self.mFooterY = self.mDecoratorExternalNodes.getLegend( self.mFooterX, self.mFooterY )
        self.addElements(e)
        e, self.mFooterX, self.mFooterY = self.mDecoratorInternalNodes.getLegend( self.mFooterX, self.mFooterY )
        self.addElements(e)