def drawTitle(self, theTopOffset):
"""Add a title to the composition.
Args:
theTopOffset - vertical offset at which the map should be drawn
Returns:
float - the height of the label as rendered
Raises:
None
"""
LOGGER.debug('InaSAFE Map drawTitle called')
myFontSize = 14
myFontWeight = QtGui.QFont.Bold
myItalicsFlag = False
myFont = QtGui.QFont('verdana', myFontSize, myFontWeight,
myItalicsFlag)
myLabel = QgsComposerLabel(self.composition)
myLabel.setFont(myFont)
myHeading = self.tr('InaSAFE - Indonesia Scenario Assessment'
' for Emergencies')
myLabel.setText(myHeading)
myLabel.adjustSizeToText()
myLabelHeight = 10.0 # determined using qgis map composer
myLabelWidth = 170.0 # item - position and size...option
myLeftOffset = self.pageWidth - self.pageMargin - myLabelWidth
myLabel.setItemPosition(
myLeftOffset,
theTopOffset - 2, # -2 to push it up a little
myLabelWidth,
myLabelHeight,
)
myLabel.setFrame(self.showFramesFlag)
self.composition.addItem(myLabel)
return myLabelHeight
def drawImpactTitle(self, theTopOffset):
"""Draw the map subtitle - obtained from the impact layer keywords.
Args:
theTopOffset - vertical offset at which to begin drawing
Returns:
float - the height of the label as rendered
Raises:
None
"""
LOGGER.debug('InaSAFE Map drawImpactTitle called')
myTitle = self.getMapTitle()
if myTitle is None:
myTitle = ''
myFontSize = 20
myFontWeight = QtGui.QFont.Bold
myItalicsFlag = False
myFont = QtGui.QFont('verdana', myFontSize, myFontWeight,
myItalicsFlag)
myLabel = QgsComposerLabel(self.composition)
myLabel.setFont(myFont)
myHeading = myTitle
myLabel.setText(myHeading)
myLabelWidth = self.pageWidth - (self.pageMargin * 2)
myLabelHeight = 12
myLabel.setItemPosition(self.pageMargin, theTopOffset, myLabelWidth,
myLabelHeight)
myLabel.setFrame(self.showFramesFlag)
self.composition.addItem(myLabel)
return myLabelHeight
def layerRenderByComposer(self, layer, outName):
self.hideOtherLayers(layer)
mapRenderer = self.iface.mapCanvas().mapRenderer()
mapRenderer.setLayerSet([layer.id()])
c = QgsComposition(mapRenderer)
c.setPlotStyle(QgsComposition.Print)
c.setPaperSize(297, 210)
c.setPrintResolution(300)
x, y = 0, 0
w, h = c.paperWidth(), c.paperHeight()
composerMap = QgsComposerMap(c, x, y, w, h)
composerMap.setMapCanvas(self.iface.mapCanvas())
c.addItem(composerMap)
legend = QgsComposerLegend(c)
root = QgsProject.instance().layerTreeRoot().clone()
root = self.buildLegendLayerTree(root, [layer])
legend.modelV2().setRootGroup(root)
legend.setItemPosition(250, 20)
legend.setResizeToContents(True)
c.addItem(legend)
label = QgsComposerLabel(c)
label.setMarginX(125)
label.setMarginY(10)
label.setText(layer.name())
label.setFont(QFont('PMinliu', 20, QFont.Bold))
label.adjustSizeToText()
c.addItem(label)
item = QgsComposerScaleBar(c)
item.setStyle('Double Box') # optionally modify the style
item.setComposerMap(composerMap)
item.applyDefaultSize()
item.setItemPosition(10, 190)
c.addItem(item)
dpmm = 300 / 25.4
width = int(dpmm * c.paperWidth())
width = int(width / 2) * 2
height = int(dpmm * c.paperHeight())
height = int(height / 2) * 2
Dots = int(dpmm * 1000 / 2) * 2
# create output image and initialize it
image = QImage(QSize(width, height), QImage.Format_ARGB32)
image.setDotsPerMeterX(Dots)
image.setDotsPerMeterY(Dots)
image.fill(0)
# render the composition
imagePainter = QPainter(image)
c.renderPage(imagePainter, 0)
imagePainter.end()
outName = os.path.join(self.workingFolder, outName + '.png')
image.save(outName, "png")
return outName
def draw_impact_title(self, top_offset):
"""Draw the map subtitle - obtained from the impact layer keywords.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The height of the label as rendered.
:rtype: float
"""
LOGGER.debug('InaSAFE Map drawImpactTitle called')
title = self.map_title()
if title is None:
title = ''
font_size = 20
font_weight = QtGui.QFont.Bold
italics_flag = False
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
heading = title
label.setText(heading)
label_width = self.page_width - (self.page_margin * 2)
label_height = 12
label.setItemPosition(self.page_margin, top_offset, label_width,
label_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
return label_height
def drawDisclaimer(self):
"""Add a disclaimer to the composition.
Args:
None
Returns:
None
Raises:
None
"""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
myFontSize = 10
myFontWeight = QtGui.QFont.Normal
myItalicsFlag = True
myFont = QtGui.QFont('verdana', myFontSize, myFontWeight,
myItalicsFlag)
myLabel = QgsComposerLabel(self.composition)
myLabel.setFont(myFont)
myLabel.setText(self.disclaimer)
myLabel.adjustSizeToText()
myLabelHeight = 7.0 # mm determined using qgis map composer
myLabelWidth = self.pageWidth # item - position and size...option
myLeftOffset = self.pageMargin
myTopOffset = self.pageHeight - self.pageMargin
myLabel.setItemPosition(
myLeftOffset,
myTopOffset,
myLabelWidth,
myLabelHeight,
)
myLabel.setFrame(self.showFramesFlag)
self.composition.addItem(myLabel)
def draw_title(self, top_offset):
"""Add a title to the composition.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The height of the label as rendered.
:rtype: float
"""
LOGGER.debug('InaSAFE Map drawTitle called')
font_size = 14
font_weight = QtGui.QFont.Bold
italics_flag = False
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
heading = self.tr(
'InaSAFE - Indonesia Scenario Assessment for Emergencies')
label.setText(heading)
label.adjustSizeToText()
label_height = 10.0 # determined using qgis map composer
label_width = 170.0 # item - position and size...option
left_offset = self.page_width - self.page_margin - label_width
label.setItemPosition(
left_offset,
top_offset - 2, # -2 to push it up a little
label_width,
label_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
return label_height
def buildComposerLabel(self, key, item, page):
'''
Add a QgsLabel to composition for an item and page
'''
cl = QgsComposerLabel(self.currentComposition)
# 1st page is a map for parcelle
dpage = page - 1
if self.etype == 'parcelle' and self.iface:
dpage = page
cl.setItemPosition(
item['position'][0],
item['position'][1] + (dpage) * (self.pageHeight + 10),
item['position'][2], item['position'][3], False, -1)
cl.setVAlign(item['align'][0])
cl.setHAlign(item['align'][1])
content = self.getContentForGivenItem(key, item, page)
cl.setMargin(0)
cl.setHtmlState(2)
cl.setText(content)
cl.setFrameEnabled(False)
if 'bgcolor' in item:
cl.setBackgroundColor(item['bgcolor'])
if 'htmlState' in item:
cl.setHtmlState(item['htmlState'])
if 'font' in item:
cl.setFont(item['font'])
self.currentComposition.addItem(cl)
def draw_impact_title(self, top_offset):
"""Draw the map subtitle - obtained from the impact layer keywords.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The height of the label as rendered.
:rtype: float
"""
LOGGER.debug('InaSAFE Map drawImpactTitle called')
myTitle = self.map_title()
if myTitle is None:
myTitle = ''
myFontSize = 20
myFontWeight = QtGui.QFont.Bold
myItalicsFlag = False
myFont = QtGui.QFont('verdana', myFontSize, myFontWeight,
myItalicsFlag)
myLabel = QgsComposerLabel(self.composition)
myLabel.setFont(myFont)
myHeading = myTitle
myLabel.setText(myHeading)
myLabelWidth = self.pageWidth - (self.pageMargin * 2)
myLabelHeight = 12
myLabel.setItemPosition(self.pageMargin, top_offset, myLabelWidth,
myLabelHeight)
myLabel.setFrame(self.showFramesFlag)
self.composition.addItem(myLabel)
return myLabelHeight
def drawHostAndTime(self, theTopOffset):
"""Add a disclaimer to the composition.
Args:
theTopOffset - vertical offset at which to begin drawing
Returns:
None
Raises:
None
"""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
#elapsed_time: 11.612545
#user: timlinux
#host_name: ultrabook
#time_stamp: 2012-10-13_23:10:31
#myUser = self.keywordIO.readKeywords(self.layer, 'user')
#myHost = self.keywordIO.readKeywords(self.layer, 'host_name')
myDateTime = self.keywordIO.readKeywords(self.layer, 'time_stamp')
myTokens = myDateTime.split('_')
myDate = myTokens[0]
myTime = myTokens[1]
#myElapsedTime = self.keywordIO.readKeywords(self.layer,
# 'elapsed_time')
#myElapsedTime = humaniseSeconds(myElapsedTime)
myLongVersion = get_version()
myTokens = myLongVersion.split('.')
myVersion = '%s.%s.%s' % (myTokens[0], myTokens[1], myTokens[2])
myLabelText = self.tr(
'Date and time of assessment: %1 %2\n'
'Special note: This assessment is a guide - we '
'strongly recommend that you ground truth the '
'results shown here before deploying resources '
'and / or personnel.\n'
'Assessment carried out using InaSAFE release '
'%3 (QGIS plugin version).').arg(myDate).arg(myTime).arg(myVersion)
myFontSize = 6
myFontWeight = QtGui.QFont.Normal
myItalicsFlag = True
myFont = QtGui.QFont('verdana', myFontSize, myFontWeight,
myItalicsFlag)
myLabel = QgsComposerLabel(self.composition)
myLabel.setFont(myFont)
myLabel.setText(myLabelText)
myLabel.adjustSizeToText()
myLabelHeight = 50.0 # mm determined using qgis map composer
myLabelWidth = (self.pageWidth / 2) - self.pageMargin
myLeftOffset = self.pageWidth / 2 # put in right half of page
myLabel.setItemPosition(
myLeftOffset,
theTopOffset,
myLabelWidth,
myLabelHeight,
)
myLabel.setFrame(self.showFramesFlag)
self.composition.addItem(myLabel)
def draw_host_and_time(self, top_offset):
"""Add a note with hostname and time to the composition.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
#elapsed_time: 11.612545
#user: timlinux
#host_name: ultrabook
#time_stamp: 2012-10-13_23:10:31
#myUser = self.keyword_io.readKeywords(self.layer, 'user')
#myHost = self.keyword_io.readKeywords(self.layer, 'host_name')
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
#myElapsedTime = self.keyword_io.readKeywords(self.layer,
# 'elapsed_time')
#myElapsedTime = humaniseSeconds(myElapsedTime)
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
label_text = self.tr(
'Date and time of assessment: %s %s\n'
'Special note: This assessment is a guide - we strongly recommend '
'that you ground truth the results shown here before deploying '
'resources and / or personnel.\n'
'Assessment carried out using InaSAFE release %s (QGIS '
'plugin version).') % (date, time, version)
font_size = 6
font_weight = QtGui.QFont.Normal
italics_flag = True
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(label_text)
label.adjustSizeToText()
label_height = 50.0 # mm determined using qgis map composer
label_width = (self.page_width / 2) - self.page_margin
left_offset = self.page_width / 2 # put in right half of page
label.setItemPosition(
left_offset,
top_offset,
label_width,
label_height,
)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def testDataDefinedBackgroundColor(self):
mapSettings = QgsMapSettings() # NOQA
composition = QgsComposition(QgsProject.instance())
composition.setPaperSize(297, 210)
item = QgsComposerLabel(composition)
composition.addComposerLabel(item)
item.setBackgroundColor(QColor(255, 0, 0))
self.assertEqual(item.backgroundColor(), QColor(255, 0, 0))
self.assertEqual(item.brush().color().name(), QColor(255, 0, 0).name())
item.dataDefinedProperties().setProperty(QgsComposerObject.BackgroundColor, QgsProperty.fromExpression("'blue'"))
item.refreshDataDefinedProperty()
self.assertEqual(item.backgroundColor(), QColor(255, 0, 0)) # should not change
self.assertEqual(item.brush().color().name(), QColor(0, 0, 255).name())
def testCase(self):
TEST_DATA_DIR = unitTestDataPath()
vectorFileInfo = QFileInfo(TEST_DATA_DIR + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsProject.instance().addMapLayers([mVectorLayer])
# create composition with composer map
mapSettings = QgsMapSettings()
mapSettings.setLayers([mVectorLayer])
mComposition = QgsComposition(QgsProject.instance())
mComposition.setPaperSize(297, 210)
mLabel = QgsComposerLabel(mComposition)
mComposition.addComposerLabel(mLabel)
self.evaluation_test(mComposition, mLabel)
self.feature_evaluation_test(mComposition, mLabel, mVectorLayer)
self.page_evaluation_test(mComposition, mLabel, mVectorLayer)
def setSelectionTool(self):
self.view.deleteSelectedItems()
font = QFont("Arial", 14)
newLabelItem = QgsComposerLabel(self.scene)
newLabelItem.setText("QGIS")
newLabelItem.setFont(font)
newLabelItem.setItemPosition(self.scenePoint.x(), self.scenePoint.y())
newLabelItem.adjustSizeToText()
self.scene.addItem(newLabelItem)
# selectItemPoint = self.scene.composerItemAt(self.scenePoint)
newLabelItem.setSelected(True)
self.groupBox.setEnabled(True)
self.selectedLabelItem = newLabelItem
# txt = self.selectedLabelItem.text()
# textDoc = QTextDocument(txt)
self.labelText.setPlainText(self.selectedLabelItem.text())
# self.scene.setSelectedItem(self.newLabelItem)
self.view.setCurrentTool(QgsComposerView.Select)
# self.selectedLabelItem = self.view.currentTool()
self.textItemAction.setChecked(False)
def testCase(self):
TEST_DATA_DIR = unitTestDataPath()
vectorFileInfo = QFileInfo( TEST_DATA_DIR + "/france_parts.shp")
mVectorLayer = QgsVectorLayer( vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr" )
QgsMapLayerRegistry.instance().addMapLayers( [mVectorLayer] )
# create composition with composer map
mMapRenderer = QgsMapRenderer()
layerStringList = []
layerStringList.append( mVectorLayer.id() )
mMapRenderer.setLayerSet( layerStringList )
mMapRenderer.setProjectionsEnabled( False )
mComposition = QgsComposition( mMapRenderer )
mComposition.setPaperSize( 297, 210 )
mLabel = QgsComposerLabel( mComposition )
mComposition.addComposerLabel( mLabel )
self.evaluation_test( mComposition, mLabel )
self.feature_evaluation_test( mComposition, mLabel, mVectorLayer )
self.page_evaluation_test( mComposition, mLabel, mVectorLayer )
def draw_disclaimer(self):
"""Add a disclaimer to the composition."""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
font_size = 10
font_weight = QtGui.QFont.Normal
italics_flag = True
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(self.disclaimer)
label.adjustSizeToText()
label_height = 7.0 # mm determined using qgis map composer
label_width = self.page_width # item - position and size...option
left_offset = self.page_margin
top_offset = self.page_height - self.page_margin
label.setItemPosition(
left_offset,
top_offset,
label_width,
label_height,
)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def drawScaleBar(self, theComposerMap, theTopOffset):
"""Add a numeric scale to the bottom left of the map
We draw the scale bar manually because QGIS does not yet support
rendering a scalebar for a geographic map in km.
.. seealso:: :meth:`drawNativeScaleBar`
Args:
* theComposerMap - QgsComposerMap instance used as the basis
scale calculations.
* theTopOffset - vertical offset at which the map should be drawn
Returns:
None
Raises:
Any exceptions raised by the InaSAFE library will be propagated.
"""
LOGGER.debug('InaSAFE Map drawScaleBar called')
myCanvas = self.iface.mapCanvas()
myRenderer = myCanvas.mapRenderer()
#
# Add a linear map scale
#
myDistanceArea = QgsDistanceArea()
myDistanceArea.setSourceCrs(myRenderer.destinationCrs().srsid())
myDistanceArea.setProjectionsEnabled(True)
# Determine how wide our map is in km/m
# Starting point at BL corner
myComposerExtent = theComposerMap.extent()
myStartPoint = QgsPoint(myComposerExtent.xMinimum(),
myComposerExtent.yMinimum())
# Ending point at BR corner
myEndPoint = QgsPoint(myComposerExtent.xMaximum(),
myComposerExtent.yMinimum())
myGroundDistance = myDistanceArea.measureLine(myStartPoint, myEndPoint)
# Get the equivalent map distance per page mm
myMapWidth = self.mapWidth
# How far is 1mm on map on the ground in meters?
myMMToGroundDistance = myGroundDistance / myMapWidth
#print 'MM:', myMMDistance
# How long we want the scale bar to be in relation to the map
myScaleBarToMapRatio = 0.5
# How many divisions the scale bar should have
myTickCount = 5
myScaleBarWidthMM = myMapWidth * myScaleBarToMapRatio
myPrintSegmentWidthMM = myScaleBarWidthMM / myTickCount
# Segment width in real world (m)
# We apply some logic here so that segments are displayed in meters
# if each segment is less that 1000m otherwise km. Also the segment
# lengths are rounded down to human looking numbers e.g. 1km not 1.1km
myUnits = ''
myGroundSegmentWidth = myPrintSegmentWidthMM * myMMToGroundDistance
if myGroundSegmentWidth < 1000:
myUnits = 'm'
myGroundSegmentWidth = round(myGroundSegmentWidth)
# adjust the segment width now to account for rounding
myPrintSegmentWidthMM = myGroundSegmentWidth / myMMToGroundDistance
else:
myUnits = 'km'
# Segment with in real world (km)
myGroundSegmentWidth = round(myGroundSegmentWidth / 1000)
myPrintSegmentWidthMM = ((myGroundSegmentWidth * 1000) /
myMMToGroundDistance)
# Now adjust the scalebar width to account for rounding
myScaleBarWidthMM = myTickCount * myPrintSegmentWidthMM
#print "SBWMM:", myScaleBarWidthMM
#print "SWMM:", myPrintSegmentWidthMM
#print "SWM:", myGroundSegmentWidthM
#print "SWKM:", myGroundSegmentWidthKM
# start drawing in line segments
myScaleBarHeight = 5 # mm
myLineWidth = 0.3 # mm
myInsetDistance = 7 # how much to inset the scalebar into the map by
myScaleBarX = self.pageMargin + myInsetDistance
myScaleBarY = (theTopOffset + self.mapHeight - myInsetDistance -
myScaleBarHeight) # mm
# Draw an outer background box - shamelessly hardcoded buffer
myRect = QgsComposerShape(
myScaleBarX - 4, # left edge
myScaleBarY - 3, # top edge
myScaleBarWidthMM + 13, # right edge
myScaleBarHeight + 6, # bottom edge
self.composition)
myRect.setShapeType(QgsComposerShape.Rectangle)
myRect.setLineWidth(myLineWidth)
myRect.setFrame(False)
myBrush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
# workaround for missing setTransparentFill missing from python api
myRect.setBrush(myBrush)
self.composition.addItem(myRect)
# Set up the tick label font
myFontWeight = QtGui.QFont.Normal
myFontSize = 6
myItalicsFlag = False
myFont = QtGui.QFont('verdana', myFontSize, myFontWeight,
myItalicsFlag)
# Draw the bottom line
myUpshift = 0.3 # shift the bottom line up for better rendering
myRect = QgsComposerShape(myScaleBarX,
myScaleBarY + myScaleBarHeight - myUpshift,
myScaleBarWidthMM, 0.1, self.composition)
myRect.setShapeType(QgsComposerShape.Rectangle)
myRect.setLineWidth(myLineWidth)
myRect.setFrame(False)
self.composition.addItem(myRect)
# Now draw the scalebar ticks
for myTickCountIterator in range(0, myTickCount + 1):
myDistanceSuffix = ''
if myTickCountIterator == myTickCount:
myDistanceSuffix = ' ' + myUnits
myRealWorldDistance = (
'%.0f%s' %
(myTickCountIterator * myGroundSegmentWidth, myDistanceSuffix))
#print 'RW:', myRealWorldDistance
myMMOffset = myScaleBarX + (myTickCountIterator *
myPrintSegmentWidthMM)
#print 'MM:', myMMOffset
myTickHeight = myScaleBarHeight / 2
# Lines are not exposed by the api yet so we
# bodge drawing lines using rectangles with 1px height or width
myTickWidth = 0.1 # width or rectangle to be drawn
myUpTickLine = QgsComposerShape(
myMMOffset, myScaleBarY + myScaleBarHeight - myTickHeight,
myTickWidth, myTickHeight, self.composition)
myUpTickLine.setShapeType(QgsComposerShape.Rectangle)
myUpTickLine.setLineWidth(myLineWidth)
myUpTickLine.setFrame(False)
self.composition.addItem(myUpTickLine)
#
# Add a tick label
#
myLabel = QgsComposerLabel(self.composition)
myLabel.setFont(myFont)
myLabel.setText(myRealWorldDistance)
myLabel.adjustSizeToText()
myLabel.setItemPosition(myMMOffset - 3, myScaleBarY - myTickHeight)
myLabel.setFrame(self.showFramesFlag)
self.composition.addItem(myLabel)
def testCase(self):
self.TEST_DATA_DIR = unitTestDataPath()
tmppath = tempfile.mkdtemp()
for file in glob.glob(
os.path.join(self.TEST_DATA_DIR, 'france_parts.*')):
shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath)
vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp")
mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(),
vectorFileInfo.completeBaseName(), "ogr")
QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer])
# create composition with composer map
self.mapSettings = QgsMapSettings()
layerStringList = []
layerStringList.append(mVectorLayer.id())
self.mapSettings.setLayers(layerStringList)
self.mapSettings.setCrsTransformEnabled(True)
self.mapSettings.setMapUnits(QGis.Meters)
# select epsg:2154
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(2154)
self.mapSettings.setDestinationCrs(crs)
self.mComposition = QgsComposition(self.mapSettings)
self.mComposition.setPaperSize(297, 210)
# fix the renderer, fill with green
props = {"color": "0,127,0"}
fillSymbol = QgsFillSymbolV2.createSimple(props)
renderer = QgsSingleSymbolRendererV2(fillSymbol)
mVectorLayer.setRendererV2(renderer)
# the atlas map
self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130)
self.mAtlasMap.setFrameEnabled(True)
self.mComposition.addComposerMap(self.mAtlasMap)
# the atlas
self.mAtlas = self.mComposition.atlasComposition()
self.mAtlas.setCoverageLayer(mVectorLayer)
self.mAtlas.setEnabled(True)
self.mComposition.setAtlasMode(QgsComposition.ExportAtlas)
# an overview
mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50)
mOverview.setFrameEnabled(True)
mOverview.setOverviewFrameMap(self.mAtlasMap.id())
self.mComposition.addComposerMap(mOverview)
nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887)
mOverview.setNewExtent(nextent)
# set the fill symbol of the overview map
props2 = {"color": "127,0,0,127"}
fillSymbol2 = QgsFillSymbolV2.createSimple(props2)
mOverview.setOverviewFrameMapSymbol(fillSymbol2)
# header label
self.mLabel1 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel1)
self.mLabel1.setText("[% \"NAME_1\" %] area")
self.mLabel1.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel1.adjustSizeToText()
self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15))
qWarning(
"header label font: %s exactMatch:%s" %
(self.mLabel1.font().toString(), self.mLabel1.font().exactMatch()))
# feature number label
self.mLabel2 = QgsComposerLabel(self.mComposition)
self.mComposition.addComposerLabel(self.mLabel2)
self.mLabel2.setText("# [%$feature || ' / ' || $numfeatures%]")
self.mLabel2.setFont(QgsFontUtils.getStandardTestFont())
self.mLabel2.adjustSizeToText()
self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15))
qWarning(
"feature number label font: %s exactMatch:%s" %
(self.mLabel2.font().toString(), self.mLabel2.font().exactMatch()))
self.filename_test()
self.autoscale_render_test()
self.autoscale_render_test_old_api()
self.fixedscale_render_test()
self.predefinedscales_render_test()
self.hidden_render_test()
self.legend_test()
shutil.rmtree(tmppath, True)
def createTempleteAction(self):
if self.templeteCreateAction.isChecked() and self.basePMCheck:
font = QFont("Arial", 13)
font.setItalic(True)
self.compLabel1 = QgsComposerLabel(self.scene)
self.compLabel1.setFont(font)
self.compLabel1.setText("South China Sea")
self.compLabel1.setBackgroundEnabled(False)
self.compLabel1.setItemPosition(156, 100)
self.compLabel1.adjustSizeToText()
self.compLabel1.setItemRotation(60)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel1)
self.compLabel2 = QgsComposerLabel(self.scene)
self.compLabel2.setFont(font)
self.compLabel2.setText("Straits Of Malacca")
self.compLabel2.setBackgroundEnabled(False)
self.compLabel2.setItemPosition(35, 100)
self.compLabel2.adjustSizeToText()
self.compLabel2.setItemRotation(60)
self.scene.addItem(self.compLabel2)
font.setItalic(False)
self.compLabel3 = QgsComposerLabel(self.scene)
self.compLabel3.setFont(font)
self.compLabel3.setBackgroundEnabled(False)
self.compLabel3.setText("THAILAND")
self.compLabel3.setItemPosition(68, 60)
self.compLabel3.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel3)
# self.templeteCreateAction.setChecked(False)
self.compLabel4 = QgsComposerLabel(self.scene)
self.compLabel4.setFont(font)
self.compLabel4.setBackgroundEnabled(False)
self.compLabel4.setText("SINGAPORE")
self.compLabel4.setItemPosition(141, 218)
self.compLabel4.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel4)
self.templeteCreateAction.setChecked(False)
self.compLabel4.setSelected(True)
elif self.templeteCreateAction.isChecked(
) and self.basePMCheck == False:
font = QFont("Arial", 14)
font.setItalic(True)
self.compLabel5 = QgsComposerLabel(self.scene)
self.compLabel5.setFont(font)
self.compLabel5.setText("South China Sea")
self.compLabel5.setBackgroundEnabled(False)
self.compLabel5.setItemPosition(108, 86)
self.compLabel5.adjustSizeToText()
self.compLabel5.setItemRotation(-45)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel5)
self.compLabel6 = QgsComposerLabel(self.scene)
self.compLabel6.setFont(font)
self.compLabel6.setText("Sulu Sea")
self.compLabel6.setBackgroundEnabled(False)
self.compLabel6.setItemPosition(236, 38)
self.compLabel6.adjustSizeToText()
self.compLabel6.setItemRotation(45)
self.scene.addItem(self.compLabel6)
font.setItalic(False)
self.compLabel7 = QgsComposerLabel(self.scene)
self.compLabel7.setFont(font)
self.compLabel7.setBackgroundEnabled(False)
self.compLabel7.setText("Celebes Sea")
self.compLabel7.setItemPosition(242, 112)
self.compLabel7.adjustSizeToText()
self.compLabel7.setItemRotation(-45)
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel7)
# self.templeteCreateAction.setChecked(False)
self.compLabel8 = QgsComposerLabel(self.scene)
self.compLabel8.setFont(font)
self.compLabel8.setBackgroundEnabled(False)
self.compLabel8.setText("INDONESIA\n(Kalimantan)")
self.compLabel8.setItemPosition(172, 148, 32, 16)
# self.compLabel8.setHAlign(Qt.AlignHCenter)
# self.compLabel8.setVAlign(Qt.AlignVCenter)
# self.compLabel8.setFrameEnabled(False)
# self.compLabel8.setItemPosition()
# self.compLabel8.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel8)
self.compLabel9 = QgsComposerLabel(self.scene)
self.compLabel9.setFont(font)
self.compLabel9.setBackgroundEnabled(False)
self.compLabel9.setText("BRUNEI")
self.compLabel9.setItemPosition(136, 83)
self.compLabel9.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel9)
self.templeteCreateAction.setChecked(False)
pass
def composer(self, setData, flag=True):
paperWidth = setData["Width"]
paperHeight = setData["Height"]
mapRenderer = define._canvas.mapRenderer()
# comp = None
comp = QgsComposition(mapRenderer)
comp.setPlotStyle(QgsComposition.Print)
comp.setPaperSize(paperWidth, paperHeight)
# rectangleAll = QgsComposerShape(comp)
# rectangleAll.setItemPosition(3, 3, paperWidth - 3, paperHeight - 3)
# rectangleAll.setShapeType(1)
# comp.addItem(rectangleAll)
self.txt1 = QgsComposerLabel(comp)
self.txt1.setItemPosition(20, 20)
self.txt1.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt1.setFont(font)
self.txt1.setText(setData["TextData"][0])
self.txt1.adjustSizeToText()
comp.addItem(self.txt1)
self.txt2 = QgsComposerLabel(comp)
self.txt2.setItemPosition(int(paperWidth / 2) + 10, 20)
self.txt2.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt2.setFont(font)
self.txt2.setText(setData["TextData"][1])
self.txt2.adjustSizeToText()
comp.addItem(self.txt2)
self.txt3 = QgsComposerLabel(comp)
self.txt3.setItemPosition(paperWidth - 40, 20)
self.txt3.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt3.setFont(font)
self.txt3.setText(setData["TextData"][2])
self.txt3.adjustSizeToText()
comp.addItem(self.txt3)
w = int((paperWidth - 40) / 4)
self.txt4 = QgsComposerLabel(comp)
self.txt4.setItemPosition(20, 35)
self.txt4.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt4.setFont(font)
self.txt4.setText(setData["TextData"][3])
self.txt4.adjustSizeToText()
comp.addItem(self.txt4)
self.txt5 = QgsComposerLabel(comp)
self.txt5.setItemPosition(20 + w, 35)
self.txt5.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt5.setFont(font)
self.txt5.setText(setData["TextData"][4])
self.txt5.adjustSizeToText()
comp.addItem(self.txt5)
self.txt6 = QgsComposerLabel(comp)
self.txt6.setItemPosition(20 + w * 2, 35)
self.txt6.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt6.setFont(font)
self.txt6.setText(setData["TextData"][5])
self.txt6.adjustSizeToText()
comp.addItem(self.txt6)
self.txt7 = QgsComposerLabel(comp)
self.txt7.setItemPosition(20 + w * 3, 35)
self.txt7.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt7.setFont(font)
self.txt7.setText(setData["TextData"][6])
self.txt7.adjustSizeToText()
comp.addItem(self.txt7)
# if flag:
x, y = 20, 45
composerMap = QgsComposerMap(comp, x, y, paperWidth - 40, 150)
# composerMap.setPreviewMode(QgsComposerMap.Render)
# composerMap.setGridEnabled(False)
#rect = composerMap.currentMapExtent ()
renderer = composerMap.mapRenderer()
newExtent = renderer.extent()
#Make sure the width/height ratio is the same as in current composer map extent.
#This is to keep the map item frame and the page layout fixed
currentMapExtent = composerMap.currentMapExtent()
currentWidthHeightRatio = currentMapExtent.width(
) / currentMapExtent.height()
newWidthHeightRatio = newExtent.width() / newExtent.height()
if currentWidthHeightRatio < newWidthHeightRatio:
#enlarge height of new extent, ensuring the map center stays the same
newHeight = newExtent.width() / currentWidthHeightRatio
deltaHeight = newHeight - newExtent.height()
newExtent.setYMinimum(newExtent.yMinimum() - deltaHeight / 2)
newExtent.setYMaximum(newExtent.yMaximum() + deltaHeight / 2)
else:
#enlarge width of new extent, ensuring the map center stays the same
newWidth = currentWidthHeightRatio * newExtent.height()
deltaWidth = newWidth - newExtent.width()
newExtent.setXMinimum(newExtent.xMinimum() - deltaWidth / 2)
newExtent.setXMaximum(newExtent.xMaximum() + deltaWidth / 2)
composerMap.beginCommand("Map extent changed")
composerMap.setNewExtent(newExtent)
composerMap.endCommand()
# composerMap.setNewScale(3500)
composerMap.setFrameEnabled(True)
composerMap.setFrameOutlineWidth(1.0)
composerMap.setPreviewMode(QgsComposerMap.Render)
composerMap.updateCachedImage()
composerMap.setGridEnabled(True)
composerMap.setGridPenColor(QColor(255, 255, 255, 0))
composerMap.setGridPenWidth(0.0)
#composerMap.setGridStyle(QgsComposerMap.FrameAnnotationsOnly)
composerMap.setGridIntervalX(1.0)
composerMap.setGridIntervalY(1.0)
# mySymbol1 = composerMap.gridLineSymbol ()
# mySymbol1.setAlpha(0)
#composerMap.setGridLineSymbol(mySymbol1)
composerMap.setShowGridAnnotation(True)
composerMap.setGridAnnotationFormat(1)
composerMap.setGridAnnotationPrecision(0)
composerMap.setGridAnnotationDirection(1, 0)
composerMap.setGridAnnotationDirection(1, 1)
comp.addItem(composerMap)
w = int((paperWidth - 40) / 3)
self.txt8 = QgsComposerLabel(comp)
self.txt8.setItemPosition(20, 225)
self.txt8.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt8.setFont(font)
self.txt8.setText(setData["TextData"][7])
self.txt8.adjustSizeToText()
comp.addItem(self.txt8)
self.txt9 = QgsComposerLabel(comp)
self.txt9.setItemPosition(20 + w, 225)
self.txt9.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt9.setFont(font)
self.txt9.setText(setData["TextData"][8])
self.txt9.adjustSizeToText()
comp.addItem(self.txt9)
self.txt10 = QgsComposerLabel(comp)
self.txt10.setItemPosition(20 + w * 2, 225)
self.txt10.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt10.setFont(font)
self.txt10.setText(setData["TextData"][9])
self.txt10.adjustSizeToText()
comp.addItem(self.txt10)
# profileRect = QgsComposerPicture(comp)
# profileRect.setItemPosition(20, 200, paperWidth - 40, 50)
# comp.addItem(profileRect)
self.txt11 = QgsComposerLabel(comp)
self.txt11.setItemPosition(20, paperHeight - 30)
self.txt11.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt11.setFont(font)
self.txt11.setText(setData["TextData"][10])
self.txt11.adjustSizeToText()
comp.addItem(self.txt11)
self.txt12 = QgsComposerLabel(comp)
self.txt12.setItemPosition(20 + w, paperHeight - 30)
self.txt12.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt12.setFont(font)
self.txt12.setText(setData["TextData"][11])
self.txt12.adjustSizeToText()
comp.addItem(self.txt12)
self.txt13 = QgsComposerLabel(comp)
self.txt13.setItemPosition(20 + w * 2, paperHeight - 30)
self.txt13.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt13.setFont(font)
self.txt13.setText(setData["TextData"][12])
self.txt13.adjustSizeToText()
comp.addItem(self.txt13)
# gpw = QGraphicsProxyWidget()
self.tblView = QTableView()
tableHeight = None
tableWidth = None
if self.tableChangedValue == None:
self.tblView.setFixedWidth(paperWidth - 40)
tableHeight = 50
tableWidth = paperWidth - 40
self.tblView.setFixedHeight(tableHeight)
else:
self.tblView.setFixedWidth(self.tableChangedValue["Width"])
self.tblView.setFixedHeight(self.tableChangedValue["Height"])
tableHeight = self.tableChangedValue["Height"]
tableWidth = self.tableChangedValue["Width"]
self.tblView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.tblView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
hHeder = self.tblView.horizontalHeader()
hHeder.setVisible(False)
vHeder = self.tblView.verticalHeader()
vHeder.setVisible(False)
# if flag:
self.stdModel = QStandardItemModel()
self.data.__setitem__("TableWidth", tableWidth)
self.data.__setitem__("TableHeight", tableHeight)
self.setTableView(self.tblView, self.stdModel, self.data)
self.calcALT()
self.calcTimeRate()
self.gpw = QGraphicsProxyWidget()
self.gpw.setWidget(self.tblView)
# gpw.setWidget(tblView)
if self.tableChangedValue == None:
self.gpw.setPos(20, 210)
font = QFont()
font.setPixelSize(2)
self.gpw.setFont(font)
else:
self.gpw.setPos(self.tableChangedValue["X"],
self.tableChangedValue["Y"])
font = QFont()
font.setPixelSize(self.tableChangedValue["FontSize"])
self.gpw.setFont(font)
# tblView.setFrameRect(QRect(20, 210, paperWidth - 40, 50))
comp.addItem(self.gpw)
self.connect(self.stdModel, SIGNAL("itemChanged(QStandardItem *)"),
self.stdModel_itemChanged)
return comp
def draw_scalebar(self, composer_map, top_offset):
"""Add a numeric scale to the bottom left of the map.
We draw the scale bar manually because QGIS does not yet support
rendering a scale bar for a geographic map in km.
.. seealso:: :meth:`drawNativeScaleBar`
:param composer_map: Composer map on which to draw the scalebar.
:type composer_map: QgsComposerMap
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawScaleBar called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
#
# Add a linear map scale
#
distance_area = QgsDistanceArea()
distance_area.setSourceCrs(renderer.destinationCrs().srsid())
distance_area.setEllipsoidalMode(True)
# Determine how wide our map is in km/m
# Starting point at BL corner
composer_extent = composer_map.extent()
start_point = QgsPoint(composer_extent.xMinimum(),
composer_extent.yMinimum())
# Ending point at BR corner
end_point = QgsPoint(composer_extent.xMaximum(),
composer_extent.yMinimum())
ground_distance = distance_area.measureLine(start_point, end_point)
# Get the equivalent map distance per page mm
map_width = self.mapWidth
# How far is 1mm on map on the ground in meters?
mm_to_ground = ground_distance / map_width
#print 'MM:', myMMDistance
# How long we want the scale bar to be in relation to the map
scalebar_to_map_ratio = 0.5
# How many divisions the scale bar should have
tick_count = 5
scale_bar_width_mm = map_width * scalebar_to_map_ratio
print_segment_width_mm = scale_bar_width_mm / tick_count
# Segment width in real world (m)
# We apply some logic here so that segments are displayed in meters
# if each segment is less that 1000m otherwise km. Also the segment
# lengths are rounded down to human looking numbers e.g. 1km not 1.1km
units = ''
ground_segment_width = print_segment_width_mm * mm_to_ground
if ground_segment_width < 1000:
units = 'm'
ground_segment_width = round(ground_segment_width)
# adjust the segment width now to account for rounding
print_segment_width_mm = ground_segment_width / mm_to_ground
else:
units = 'km'
# Segment with in real world (km)
ground_segment_width = round(ground_segment_width / 1000)
print_segment_width_mm = ((ground_segment_width * 1000) /
mm_to_ground)
# Now adjust the scalebar width to account for rounding
scale_bar_width_mm = tick_count * print_segment_width_mm
#print "SBWMM:", scale_bar_width_mm
#print "SWMM:", print_segment_width_mm
#print "SWM:", myGroundSegmentWidthM
#print "SWKM:", myGroundSegmentWidthKM
# start drawing in line segments
scalebar_height = 5 # mm
line_width = 0.3 # mm
inset_distance = 7 # how much to inset the scalebar into the map by
scalebar_x = self.page_margin + inset_distance
scalebar_y = (top_offset + self.map_height - inset_distance -
scalebar_height) # mm
# Draw an outer background box - shamelessly hardcoded buffer
rectangle = QgsComposerShape(
scalebar_x - 4, # left edge
scalebar_y - 3, # top edge
scale_bar_width_mm + 13, # right edge
scalebar_height + 6, # bottom edge
self.composition)
rectangle.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(255, 255, 255))
pen.setWidthF(line_width)
rectangle.setPen(pen)
#rectangle.setLineWidth(line_width)
rectangle.setFrameEnabled(False)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
# workaround for missing setTransparentFill missing from python api
rectangle.setBrush(brush)
self.composition.addItem(rectangle)
# Set up the tick label font
font_weight = QtGui.QFont.Normal
font_size = 6
italics_flag = False
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
# Draw the bottom line
up_shift = 0.3 # shift the bottom line up for better rendering
rectangle = QgsComposerShape(scalebar_x,
scalebar_y + scalebar_height - up_shift,
scale_bar_width_mm, 0.1, self.composition)
rectangle.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(255, 255, 255))
pen.setWidthF(line_width)
rectangle.setPen(pen)
#rectangle.setLineWidth(line_width)
rectangle.setFrameEnabled(False)
self.composition.addItem(rectangle)
# Now draw the scalebar ticks
for tick_counter in range(0, tick_count + 1):
distance_suffix = ''
if tick_counter == tick_count:
distance_suffix = ' ' + units
real_world_distance = (
'%.0f%s' %
(tick_counter * ground_segment_width, distance_suffix))
#print 'RW:', myRealWorldDistance
mm_offset = scalebar_x + (tick_counter * print_segment_width_mm)
#print 'MM:', mm_offset
tick_height = scalebar_height / 2
# Lines are not exposed by the api yet so we
# bodge drawing lines using rectangles with 1px height or width
tick_width = 0.1 # width or rectangle to be drawn
uptick_line = QgsComposerShape(
mm_offset, scalebar_y + scalebar_height - tick_height,
tick_width, tick_height, self.composition)
uptick_line.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setWidthF(line_width)
uptick_line.setPen(pen)
#uptick_line.setLineWidth(line_width)
uptick_line.setFrameEnabled(False)
self.composition.addItem(uptick_line)
#
# Add a tick label
#
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(real_world_distance)
label.adjustSizeToText()
label.setItemPosition(mm_offset - 3, scalebar_y - tick_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
