Python SVGdraw.rect方法代码示例

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
 def fill(self,elt):
     pattern=SVGdraw.SVGelement('pattern',attributes=
                                {"height":"20", "width":"20",
                                 "patternUnits": "userSpaceOnUse",
                                 "patternContentUnits": "userSpaceOnUse",
                                 "id": "semy%04d"%blazon.Ordinary.id})
     blazon.Ordinary.id+=1
     # Just in case we try to countercharge it.  It doesn't work anyway.
     self.colors=(self.background,self.charge.tincture)
     charge2=copy.deepcopy(self.charge)
     self.charge.moveto((5,15))
     self.charge.scale(.1)
     charge2.moveto((15,5))
     charge2.scale(.1)
     #pattern.addElement(SVGdraw.rect(0,0,30,30,stroke="black",
     #                                stroke_width=".3",fill="none"))
     pattern.addElement(self.charge.finalizeSVG())
     pattern.addElement(charge2.finalizeSVG())
     blazon.Ordinary.defs.append(pattern)
     newelt=SVGdraw.group()
     elt=self.background.fill(elt)
     newelt.addElement(elt)
     newbase=SVGdraw.rect(x=-blazon.Ordinary.FESSPTX,
                          y=-blazon.Ordinary.FESSPTY,
                          width=blazon.Ordinary.WIDTH,
                          height=blazon.Ordinary.HEIGHT,
                          fill="url(#%s)"%pattern.attributes["id"])
     newelt.addElement(newbase)
     return newelt

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
 def build(self):
     (sx, sy) = self._srcchgset.position()
     h_offset = self._srcchgset.tag_offset(self._h)
     self._position = (sx + (self._srcchgset.extent()[0])/2,
                       sy - (3*self._h)/2 + h_offset)
     x = self._position[0]+(self._w-self._tw)/2
     y = self._position[1]
     r = UNIT/2
     rect = SVG.rect(x,y,self._tw,self._h,
                     self._srcchgset.strokecolor(),
                     self._srcchgset.fillcolor(), 
                     self._srcchgset.strokewidth())
     rect.attributes['rx'] = r
     rect.attributes['ry'] = r        
     rect.attributes['opacity'] = str(self._opacity/100.0) 
     text = SVG.text(self._position[0]+self._w/2, 
                     self._position[1]+self._h/2+UNIT/4,
                     "%s" % self._title.encode('utf-8'), 
                     self._srcchgset.fontsize(), 
                     self._srcchgset.fontname())
     txc = SvgColor('white')
     text.attributes['style'] = 'fill:%s; text-anchor: middle' % txc.rgb()
     name = self._title.encode('utf-8').replace('/','')
     g = SVG.group('grp%d' % self._revision, elements=[rect, text])
     link = "%s/changeset/%d" % (self._parent.urlbase(), self._revision)
     self._link = SVG.link(link, elements=[g])
     self._link.attributes['id'] = 'rev%d' % self._revision
     self._link.attributes['style'] = \
         'color: %s; background-color: %s' % \
             (self._srcchgset.fillcolor(), self._srcchgset.strokecolor())

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
	def doGrid(self, canvas, rows, verticalOffset, partHeight, columns, horizontalOffset, partWidth, gridsize, lineColor, fillColor, penWidth):
		polySize = str(gridsize) + self.units
		for polyRow in range(0, rows):
			polyTop = verticalOffset + polyRow*partHeight
			polyTopStr = str(polyTop) + self.units

			#do stuff for hexagons
			rowcolumns = columns
			rowoffset = 0
			if self.type == 'hex':
				if polyRow % 2 == 0:
					if (self.width-(horizontalOffset+self.rightMargin-.01)) >= (columns*partWidth + gridsize):
						rowcolumns = columns + 1
				else:
					rowoffset = gridsize/2 + gridsize/4

			for polyColumn in range(0, rowcolumns):
				polyLeft = horizontalOffset + polyColumn*partWidth
				polyLeft += rowoffset
				polyLeftStr = str(polyLeft) + self.units
				
				if self.type == 'hex':
					gridshape = hexagon(gridsize, polyLeft, polyTop, self.units, stroke=lineColor, fill=fillColor, stroke_width=penWidth)
				else:
					gridshape = SVGdraw.rect(polyLeftStr, polyTopStr, polySize, polySize, stroke=lineColor, fill=fillColor, stroke_width=penWidth)
				
				canvas.addElement(gridshape)
		return canvas

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
 def VairPattern(self):
    pattern=SVGdraw.SVGelement(type="pattern",attributes=
                               {"patternContentUnits":"userSpaceOnUse",
                                "height":"8",
                                "id":"vair-in-pale%04d"%blazon.Ordinary.id,
                                "patternUnits":"userSpaceOnUse",
                                "width":"8"})
    pattern.addElement(self.color1.fill(SVGdraw.rect(x="0", y="0", width="8", height="8")))
    pattern.addElement(self.color2.fill(SVGdraw.SVGelement(type='path',
                                                           attributes=
                                          {"d":"M0,8 l2,-2 l0,-4 l2,-2 l2,2 l0,4 l2,2 z"})))
    self.color="vair-in-pale%04d"%blazon.Ordinary.id
    blazon.Ordinary.id+=1
    return pattern

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
    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

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
    def getElements(self, x, y, map_node2height ):

        elements = []
        for n in self.mTree.get_terminals():

            t = self.mTree.node(n).data.taxon

            if t not in self.mMapId2Cluster:
                continue
            cluster = self.mMapId2Cluster[t]
            if cluster not in self.mMapCluster2Colour:
                self.mMapCluster2Colour[cluster] = COLOURS[len(self.mMapCluster2Colour) % len(COLOURS) ]

            colour = self.mMapCluster2Colour[cluster]
            elements.append( SVGdraw.rect( x, y + map_node2height[n] - self.mBoxWidth / 2, self.mBoxWidth, self.mBoxWidth,
                                           stroke = "rgb(%i,%i,%i)" % colour,
                                           fill = "rgb(%i,%i,%i)" % colour) )
                
        return elements

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
 def build(self):
     self._position = self._parent.position()
     x = self._position[0]+(self._w-self._tw)/2
     y = self._position[1]
     r = UNIT/2
     rect = SVG.rect(x,y,self._tw,self._h,
                     self._parent.fillcolor(), 
                     self._parent.strokecolor(), 
                     self._parent.strokewidth())
     rect.attributes['rx'] = r
     rect.attributes['ry'] = r        
     text = SVG.text(self._position[0]++self._w/2, 
                     self._position[1]+self._h/2+UNIT/6,
                     "/%s" % self._title.encode('utf-8'), 
                     self._parent.fontsize(), self._parent.fontname())
     text.attributes['style'] = 'text-anchor: middle'
     name = self._title.encode('utf-8').replace('/','')
     g = SVG.group('grp%s' % name, elements=[rect, text])
     href = Href(self._parent.urlbase())
     self._link = SVG.link(plink(href.browser(self._title)), elements=[g])

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]

#.........这里部分代码省略.........
                else:
                    self.mRadius = self.mRadiusFallBack
                    
                self.mLastMax = max(self.mLastMax, ma)
        else:
            if self.mLastMax > mi:
                self.mRadius += self.mRadiusIncrement
                if with_separator: self.addSeparator()

        self.mPreviousMin = mi
        self.mPreviousMax = ma
        self.mPreviousCis = cis
        
        self.mRadiusMax = max(self.mRadius, self.mRadiusMax)

        ########################################################
        ########################################################
        ########################################################            
        ## draw points 
        ########################################################                    
        link_colour = master_colour
        link_rad_width = self.mLinkRadStrokeWidth
        link_arc_width = self.mLinkArcStrokeWidth
        new_points = {}
        for pos1, pos2, gene, quality, chr in points:

            angle = self.getAngle( (pos1 + pos2) / 2 )
            
            x,y = self.getPosOnArc( angle, self.mRadius )

            try:
                symbol = quality2symbol[quality]
            except KeyError:
                symbol = "rect"

            if quality in quality2mask:
                colour = self.mLinkColourSymbolMasked
                link_colour = self.mLinkColourMasked
                link_rad_width = self.mLinkStrokeWidthMasked
                link_arc_width = self.mLinkStrokeWidthMasked
            else:
                colour = master_colour

            if gene in self.mPreviousPoints:
                continue
            
            new_points[gene] = (x, y, angle, quality, chr)
            
            if symbol == "circle":
                ee = SVGdraw.circle( x, y, self.mLinkSymbolSize,
                                     fill = "rgb(%i,%i,%i)" % colour,
                                     stroke="black",
                                     stroke_width = self.mLinkStrokeWidthSymbol )
            elif symbol == "rect":
                ee =  SVGdraw.rect( x-self.mLinkSymbolSize/2, y-self.mLinkSymbolSize/2,
                                    self.mLinkSymbolSize, self.mLinkSymbolSize,
                                    fill = "rgb(%i,%i,%i)" % colour,
                                    stroke="black",
                                    stroke_width = self.mLinkStrokeWidthSymbol )

            if url:
                e = SVGdraw.link( url % gene )
                e.addElement( ee )
            else:
                e = ee
                

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
	def doGrid(self, canvas, rows, verticalOffset, partHeight, columns, horizontalOffset, partWidth, gridsize, lineColor, fillColor, penWidth):
		polySize = str(gridsize) + self.units

		group = SVGdraw.group()
		group.attributes['id'] = 'map'
		group.attributes['rows'] = rows
		group.attributes['columns'] = columns
		group.attributes['cells'] = rows * columns

		# for id
		index = 0
		
		#print "%s rows, %s columns" % ( rows, columns )

		for polyRow in range(0, rows):
			polyTop = verticalOffset + polyRow*partHeight
			polyTopStr = str(polyTop) + self.units

			#do stuff for hexagons
			rowcolumns = columns
			rowoffset = 0
			if self.type == 'hex' or self.type == 'hexpath':
				if polyRow % 2 == 0:
					if (self.width-(horizontalOffset+self.rightMargin-.01)) >= (columns*partWidth + gridsize):
						rowcolumns = columns + 1
				else:
					rowoffset = gridsize/2 + gridsize/4

			for polyColumn in range(0, rowcolumns):
				polyLeft = horizontalOffset + polyColumn*partWidth
				polyLeft += rowoffset
				polyLeftStr = str(polyLeft) + self.units

				if self.type == 'hex':
					gridshape = hexagon(gridsize, polyLeft, polyTop, self.units, stroke=lineColor, fill=fillColor, stroke_width=penWidth)

				elif self.type == 'hexpath':
					gridshape = hexpath(gridsize, polyLeft, polyTop, self.units, stroke=lineColor, fill=fillColor, stroke_width=penWidth)

				else:
					gridshape = SVGdraw.rect(polyLeftStr, polyTopStr, polySize, polySize, stroke=lineColor, fill=fillColor, stroke_width=penWidth)

				"""
				positions = {
					'cell_NW': (index - columns    ),
					'cell_N' : (index - columns * 2),
					'cell_NE': (index - columns + 1),
					'cell_SE': (index + columns    ),
					'cell_S' : (index + columns * 2),
					'cell_SW': (index + columns - 1)
				}
				"""

				gridshape.attributes['id'] = 'cell_' + str(index)
				gridshape.attributes['row'] = str(polyRow)
				gridshape.attributes['col'] = str(polyColumn)

				neighbors_class = [ ]

				evenRow = (polyRow % 2 == 0)
				evenCol = (polyColumn % 2 == 0)
				id = -1

				#print "i%s: polyRow=%s polyColumn=%s" % ( index, polyRow, polyColumn )

				# North OK
				id = index - columns * 2
				if id >= 0:
					neighbors_class.append( "N:cell_" + str(id) )
					#gridshape.attributes['cell_N']  = "cell_" + str(id)

				# South OK
				id = index + columns * 2
				if id <= rows * columns:
					#gridshape.attributes['cell_S']  = "cell_" + str(id)
					neighbors_class.append( "S:cell_" + str(id) )

				# NorthWest OK
				if evenRow:
					if polyColumn > 0:
						id = (index - columns) - 1
				else:
					id = (index - columns)
				if id >= 0:
					neighbors_class.append( "NW:cell_" + str(id) )

				# NorthEst OK
				if polyColumn < columns:
					if evenRow:
						id = index - columns
					elif polyColumn < columns - 1:
						id = index - columns + 1

					if id >= 0:
						neighbors_class.append( "NE:cell_" + str(id) )
						#gridshape.attributes['cell_NW'] = "cell_" + str(id)

				# SouthEst OK
				if evenRow:
					id = index + columns
#.........这里部分代码省略.........

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
	def doGrid(self, canvas, rows, verticalOffset, partHeight, columns, horizontalOffset, partWidth, gridsize, lineColor, fillColor, penWidth):
		polySize = str(gridsize) + self.units
		polyCount = 0
		thebes = SVGdraw.text(20, 20, "Thebes")
		canvas.addElement(thebes)
		name = SVGdraw.text(200, 20, "Map For " + self.name)
		canvas.addElement(name)
		warning = SVGdraw.text(500, 20, "NOT IN GAME")
		canvas.addElement(warning)

		for polyRow in range(0, rows):
			polyTop = verticalOffset + polyRow*partHeight
			polyTopStr = str(polyTop) + self.units

			#do stuff for hexagons
			rowcolumns = columns
			rowoffset = 0
			if self.type == 'hex':
				if polyRow % 2 == 0:
					if (self.width-(horizontalOffset+self.rightMargin-.01)) >= (columns*partWidth + gridsize):
						rowcolumns = columns + 1
				else:
					rowoffset = gridsize/2 + gridsize/4

			for polyColumn in range(0, rowcolumns):
				polyLeft = horizontalOffset + polyColumn*partWidth
				polyLeft += rowoffset
				polyLeftStr = str(polyLeft) + self.units
				polyCount += 1
				
				if self.type == 'hex':
					nodeID = 100 * polyColumn + polyRow

					if (nodeID in self.nodes) or (self.drawAll):
						gridshape = hexagon(gridsize, polyLeft, polyTop, self.units, stroke=lineColor, fill=fillColor, stroke_width=penWidth)
						if self.drawNumbers:
							if (polyRow < 10):
								polyRowStr = "0" + str(polyRow)
							else:
								polyRowStr = str(polyRow)
							gridtext = SVGdraw.text(90 * (polyLeft + partHeight - .10), 90 * (polyTop + partHeight - .15),str(polyColumn)+polyRowStr,font_size=11);
							canvas.addElement(gridtext)
						canvas.addElement(gridshape)
						if nodeID in self.nodes:
							if self.drawDesc:
								gridname = SVGdraw.text(90 * (polyLeft + partHeight - .16), 90 * (polyTop + partHeight + .13),self.nodes[nodeID]["name"],font_size=9);
								canvas.addElement(gridname)

								griddesc = SVGdraw.text(90 * (polyLeft + partHeight - .2), 90 * (polyTop + partHeight + .02),self.nodes[nodeID]["desc"],font_size=8);
								canvas.addElement(griddesc)
							else:
								gridname = SVGdraw.text(90 * (polyLeft + partHeight - .16), 90 * (polyTop + partHeight + .02),self.nodes[nodeID]["name"],font_size=12);
								canvas.addElement(gridname)



				else:
					gridshape = SVGdraw.rect(polyLeftStr, polyTopStr, polySize, polySize, stroke=lineColor, fill=fillColor, stroke_width=penWidth)
					canvas.addElement(gridshape)
				

		return canvas

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
	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)

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
	def doGrid(self, canvas, rows, verticalOffset, partHeight, columns, horizontalOffset, partWidth, gridsize, lineColor, fillColor, penWidth):
		polySize = str(gridsize) + self.units

		group = SVGdraw.group()
		group.attributes['id'] = 'map'
		group.attributes['rows'] = rows
		group.attributes['columns'] = columns
		group.attributes['cells'] = rows * columns

		# for id
		index = 0

		#print "%s COLUMNS" % columns
		#print "%s ROWS" % rows

		for polyRow in range(0, rows):
			polyTop = verticalOffset + polyRow*partHeight
			polyTopStr = str(polyTop) + self.units

			#do stuff for hexagons
			rowcolumns = columns
			rowoffset = 0
			if self.type == 'hex' or self.type == 'hexpath':
				if polyRow % 2 == 0:
					if (self.width-(horizontalOffset+self.rightMargin-.01)) >= (columns*partWidth + gridsize):
						rowcolumns = columns + 1
				else:
					rowoffset = gridsize/2 + gridsize/4

			for polyColumn in range(0, rowcolumns):
				polyLeft = horizontalOffset + polyColumn*partWidth
				polyLeft += rowoffset
				polyLeftStr = str(polyLeft) + self.units

				if self.type == 'hex':
					gridshape = hexagon(gridsize, polyLeft, polyTop, self.units, stroke=lineColor, fill=fillColor, stroke_width=penWidth)

				elif self.type == 'hexpath':
					gridshape = hexpath(gridsize, polyLeft, polyTop, self.units, stroke=lineColor, fill=fillColor, stroke_width=penWidth)

				else:
					gridshape = SVGdraw.rect(polyLeftStr, polyTopStr, polySize, polySize, stroke=lineColor, fill=fillColor, stroke_width=penWidth)

				"""
				positions = {
					'cell_NW': (index - rows),
					'cell_N' : (index - rows * 2),
					'cell_NE': (index - rows + 1),
					'cell_SE': (index + rows),
					'cell_S' : (index + rows * 2),
					'cell_SW': (index + rows - 1)
				}
				"""

				gridshape.attributes['id'] = 'cell_' + str(index)

				neighbors_class = 'neighbors-'

				id = index - columns
				if id >= 0:
					#gridshape.attributes['cell_NW'] = "cell_" + str(id)
					neighbors_class += "cell_" + str(id) + '-'

				id = index - columns * 2
				if id >= 0:
					#gridshape.attributes['cell_N']  = "cell_" + str(id)
					neighbors_class += "cell_" + str(id) + '-'

				id = index - columns + 1
				if id >= 0:
					#gridshape.attributes['cell_NE'] = "cell_" + str(id)
					neighbors_class += "cell_" + str(id) + '-'

				id = index + columns - 1
				if id <= rows * columns:
					#gridshape.attributes['cell_SE'] = "cell_" + str(id)
					neighbors_class += "cell_" + str(id) + '-'

				id = index + columns * 2
				if id <= rows * columns:
					#gridshape.attributes['cell_S']  = "cell_" + str(id)
					neighbors_class += "cell_" + str(id) + '-'

				id = index + columns
				if id <= rows * columns:
					#gridshape.attributes['cell_SW'] = "cell_" + str(id)
					neighbors_class += "cell_" + str(id) + '-'

				gridshape.attributes['class'] = neighbors_class

				index = index + 1

				group.addElement(gridshape)

		canvas.addElement(group)
		return canvas

# 需要导入模块: import SVGdraw [as 别名]
# 或者: from SVGdraw import rect [as 别名]
    def svgout(self,stroke_width=0.3,scale=20,circle_radius=0.3,
               startat=None,coloriter=None,crossings=True,circradius=None,circscale=1):
        # if circradius is some positive number, try to draw a circular(!) diagram
        # circscale is how much to scale the y-dimension by (how thick a circle)
#        try:
#            if type(SVGdraw)!=type(__builtins__):
#		raise Exception("SVGdraw not a module?")
#                return None
#        except NameError:
#	    raise Exception("No SVGDraw found")
#            return None

        cols=['#000000', 
              '#800000', '#808000', '#008080', '#000080',
              '#ff2000', '#ffff20', '#20ffff', '#0020ff',
              '#ff0080', '#ff8000', '#8000ff', '#80ff00']
        if circradius:
            sz=(2*self.ymax*circscale+2+2*circradius)
            svg=SVGdraw.svg(width="%dpx"%(sz*scale), height="%dpx"%(sz*scale),
                            viewBox=[-sz+self.xmodulus/2.0, -sz, 2*sz, 2*sz])
            def transform(x,y):
                # Have to flip it over...
                r=self.ymax*circscale+circradius-y*circscale
                theta=2*math.pi*x/self.xmodulus-math.pi
                return [sz/2+r*math.cos(theta), sz/2+r*math.sin(theta)]
        else:
            svg=SVGdraw.svg(width="%dpx"%((self.xmodulus+2)*scale),
                            height="%dpx"%((self.ymax+2)*scale),
                            viewBox=[-1, -1, self.xmodulus+2,
                                      self.ymax+2])
            def transform(x,y):
                return [x,y]
                        
        defs=SVGdraw.defs(id="defs")
        plusmask=SVGdraw.SVGelement("mask",
                                    attributes={"id":"plusmask"})
        minusmask=SVGdraw.SVGelement("mask",
                                     attributes={"id":"minusmask"})
        if circradius:
            sz=1+2*self.ymax*circscale+2*circradius # Whatever, something big.
            r=SVGdraw.rect(x=-sz, y=-sz, width=sz*2,height=sz*2,fill='white')
        else:
            r=SVGdraw.rect(x=-1,y=-1,width=self.xmodulus+2,height=self.ymax+2,
                           fill='white')
        plusmask.addElement(r)
        minusmask.addElement(r)
        defs.addElement(plusmask)
        defs.addElement(minusmask)
        svg.addElement(defs)
        maingroup=SVGdraw.group(id="main")
        # I've come to expect them this way up...
        maingroup.attributes['transform']='scale(1,-1) translate(0,%d)'% \
            (-self.ymax)
        svg.addElement(maingroup)
        # Positive slopes and negative slopes.
        plus=SVGdraw.group(id="plus",mask="url(#plusmask)")
        minus=SVGdraw.group(id="minus",mask="url(#minusmask)")
        maingroup.addElement(plus)
        maingroup.addElement(minus)
        circgroup=SVGdraw.group(id="circgroup")
        maingroup.addElement(circgroup)
        strands=self.strands(self.pivots[0])
        circuit=None
        if coloriter is None:
            if len(strands)>1:
                # Multistranded; color it by strand.
                def multicoloriter():
                    counter=0
                    lastcircuit=None
                    while True:
                        if circuit != lastcircuit:
                            lastcircuit=circuit
                            counter+=1
                        yield cols[counter%len(cols)]
                coloriter=multicoloriter()
            else:
                def singlecoloriter(): # for singlestranders!
                    colcounter=0
                    colordiv=len(self.pivots)/6
                    while True:
                        yield cols[int(colcounter/colordiv)%len(cols)]
                        colcounter+=1
                coloriter=singlecoloriter()

            
        for circuit in strands:
            # If there's a startat parameter, and it appears in this list,
            # slosh the list around so it's first
            if startat and startat in circuit:
                ind=circuit.index(startat)
                circuit=circuit[ind:]+circuit[0:ind]
            for i in range(0,len(circuit)):
                here=circuit[i]
                nxt=circuit[(i+1)%len(circuit)]
                col=coloriter.next()
                if type(col)==int: # let iterator generate indexes
                    col=cols[col%len(cols)]
                if circradius:
                    path=[here,nxt]
                else:
#.........这里部分代码省略.........