QGIS在地图上绘制经纬网

最新推荐文章于 2024-07-19 09:18:16 发布
最新推荐文章于 2024-07-19 09:18:16 发布
阅读量8.9k 收藏 21
点赞数 3
分类专栏： qt GIS相关 文章标签： QGIS 经纬网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wb175208/article/details/102635926
版权
qt 同时被 2 个专栏收录
137 篇文章 45 订阅
订阅专栏
GIS相关
16 篇文章 5 订阅
订阅专栏

利用GIS加载经纬网的SHP数据可以显示经纬网数据，但是QGIS本身也具备显示经纬网的功能。

QGIS显示经纬网数据利用类：QgsDecorationGrid 。这个类可以构造一个SHP图层来显示出来。

在这里插入图片描述
但是我并没有使用QGIS库中的这个类，而是直接使用的源码，把这个类进行了改造，并且可以修改样式（颜色、字体等信息）。

先贴上修改过的类文件：

#ifndef QGSDECORATIONGRID_H
#define QGSDECORATIONGRID_H

#include "qgsdecorationitem.h"
#include <qgis.h>

class QPainter;
class QgsLineSymbolV2;
class QgsMarkerSymbolV2;

#include <QColor>
#include <QPen>
#include <QFont>

class QgsDecorationGrid : public QgsDecorationItem {
	Q_OBJECT
public:
	//! Constructor
	QgsDecorationGrid(QObject* parent = NULL, QgsMapCanvas* Canvas = NULL);
	//! Destructor
	virtual ~QgsDecorationGrid();

	enum GridStyle {
		Line = 0, //solid lines
		Marker = 1 //user-defined marker
	};

	enum GridAnnotationPosition {
		InsideMapFrame = 0,
		OutsideMapFrame
	};

	enum GridAnnotationDirection {
		Horizontal = 0,
		Vertical,
		HorizontalAndVertical,
		BoundaryDirection
	};

	/**Sets coordinate grid style. */
	void setGridStyle(GridStyle style) { mGridStyle = style; }
	GridStyle gridStyle() const { return mGridStyle; }

	/**Sets coordinate interval in x-direction for composergrid. */
	void setGridIntervalX(double interval) { mGridIntervalX = interval; }
	double gridIntervalX() const { return mGridIntervalX; }

	/**Sets coordinate interval in y-direction for composergrid. */
	void setGridIntervalY(double interval) { mGridIntervalY = interval; }
	double gridIntervalY() const { return mGridIntervalY; }

	/**Sets x-coordinate offset for composer grid */
	void setGridOffsetX(double offset) { mGridOffsetX = offset; }
	double gridOffsetX() const { return mGridOffsetX; }

	/**Sets y-coordinate offset for composer grid */
	void setGridOffsetY(double offset) { mGridOffsetY = offset; }
	double gridOffsetY() const { return mGridOffsetY; }

	/**Sets the pen to draw composer grid */
	void setGridPen(const QPen& p) { mGridPen = p; }
	QPen gridPen() const { return mGridPen; }
	/**Sets with of grid pen */
	void setGridPenWidth(double w) { mGridPen.setWidthF(w); }
	/**Sets the color of the grid pen */
	void setGridPenColor(const QColor& c) { mGridPen.setColor(c); }

	/**Sets font for grid annotations */
	void setGridAnnotationFont(const QFont& f) { mGridAnnotationFont = f; }
	QFont gridAnnotationFont() const { return mGridAnnotationFont; }

	/**Sets coordinate precision for grid annotations */
	void setGridAnnotationPrecision(int p) { mGridAnnotationPrecision = p; }
	int gridAnnotationPrecision() const { return mGridAnnotationPrecision; }

	/**Sets flag if grid annotation should be shown */
	void setShowGridAnnotation(bool show) { mShowGridAnnotation = show; }
	bool showGridAnnotation() const { return mShowGridAnnotation; }

	/**Sets position of grid annotations. Possibilities are inside or outside of the map frame */
	void setGridAnnotationPosition(GridAnnotationPosition p) { mGridAnnotationPosition = p; }
	GridAnnotationPosition gridAnnotationPosition() const { return mGridAnnotationPosition; }

	/**Sets distance between map frame and annotations */
	void setAnnotationFrameDistance(double d) { mAnnotationFrameDistance = d; }
	double annotationFrameDistance() const { return mAnnotationFrameDistance; }

	/**Sets grid annotation direction. Can be horizontal, vertical, direction of axis and horizontal and vertical */
	void setGridAnnotationDirection(GridAnnotationDirection d) { mGridAnnotationDirection = d; }
	GridAnnotationDirection gridAnnotationDirection() const { return mGridAnnotationDirection; }

	/**Sets length of the cros segments (if grid style is cross) */
	/* void setCrossLength( double l ) {mCrossLength = l;} */
	/* double crossLength() {return mCrossLength;} */

	/**Set symbol that is used to draw grid lines. Takes ownership*/
	void setLineSymbol(QgsLineSymbolV2* symbol);
	const QgsLineSymbolV2* lineSymbol() const { return mLineSymbol; }

	/**Set symbol that is used to draw markers. Takes ownership*/
	void setMarkerSymbol(QgsMarkerSymbolV2* symbol);
	const QgsMarkerSymbolV2* markerSymbol() const { return mMarkerSymbol; }

	/**Sets map unit type */
	void setMapUnits(QGis::UnitType t) { mMapUnits = t; }
	QGis::UnitType mapUnits() { return mMapUnits; }

	/**Set mapUnits value */
	void setDirty(bool dirty = true);
	bool isDirty();

	/**Computes interval that is approx. 1/5 of canvas extent */
	bool getIntervalFromExtent(double* values, bool useXAxis = true);
	/**Computes interval from current raster layer */
	bool getIntervalFromCurrentLayer(double* values);

	double getDefaultInterval(bool useXAxis = true);
	void GridsetEnabled(bool b);

	public slots:
	//! set values on the gui when a project is read or the gui first loaded
	void projectRead() override;
	//! save values to the project
	void saveToProject() override;

	//! this does the meaty bit of the work
	void render(QPainter *) override;
	//! Show the dialog box
	void run() override;

	//! check that map units changed and disable if necessary
	void checkMapUnitsChanged();
private:

	/**Enum for different frame borders*/
	enum Border {
		Left,
		Right,
		Bottom,
		Top
	};
	QgsMapCanvas* mapCanvas;
	/** Line or Symbol */
	GridStyle mGridStyle;
	/**Grid line interval in x-direction (map units)*/
	double mGridIntervalX;
	/**Grid line interval in y-direction (map units)*/
	double mGridIntervalY;
	/**Grid line offset in x-direction*/
	double mGridOffsetX;
	/**Grid line offset in y-direction*/
	double mGridOffsetY;
	/**Grid line pen*/
	QPen mGridPen;
	/**Font for grid line annotation*/
	QFont mGridAnnotationFont;
	/**Digits after the dot*/
	int mGridAnnotationPrecision;
	/**True if coordinate values should be drawn*/
	bool mShowGridAnnotation;
	/**Annotation position inside or outside of map frame*/
	GridAnnotationPosition mGridAnnotationPosition;
	/**Distance between map frame and annotation*/
	double mAnnotationFrameDistance;
	/**Annotation can be horizontal / vertical or different for axes*/
	GridAnnotationDirection mGridAnnotationDirection;
	/**The length of the cross sides for mGridStyle Cross*/
	/* double mCrossLength; */

	QgsLineSymbolV2* mLineSymbol;
	QgsMarkerSymbolV2* mMarkerSymbol;

	QGis::UnitType mMapUnits;

	/**Draw coordinates for mGridAnnotationType Coordinate
		@param p drawing painter
	@param hLines horizontal coordinate lines in item coordinates
		@param vLines vertical coordinate lines in item coordinates*/
	void drawCoordinateAnnotations(QPainter* p, const QList< QPair< qreal, QLineF > >& hLines, const QList< QPair< qreal, QLineF > >& vLines);
	void drawCoordinateAnnotation(QPainter* p, const QPointF& pos, QString annotationString);
	/**Draws a single annotation
		@param p drawing painter
		@param pos item coordinates where to draw
		@param rotation text rotation
		@param annotationText the text to draw*/
	void drawAnnotation(QPainter* p, const QPointF& pos, int rotation, const QString& annotationText);
	/**Returns the grid lines with associated coordinate value
		@return 0 in case of success*/
	int xGridLines(QList< QPair< qreal, QLineF > >& lines) const;
	/**Returns the grid lines for the y-coordinates. Not vertical in case of rotation
		@return 0 in case of success*/
	int yGridLines(QList< QPair< qreal, QLineF > >& lines) const;
	/**Returns the item border of a point (in item coordinates)*/
	Border borderForLineCoord(const QPointF& point, QPainter* p) const;

	/**Draws Text. Takes care about all the composer specific issues (calculation to pixel, scaling of font and painter
	 to work around the Qt font bug)*/
	void drawText(QPainter* p, double x, double y, const QString& text, const QFont& font) const;
	/**Like the above, but with a rectangle for multiline text*/
	void drawText(QPainter* p, const QRectF& rect, const QString& text, const QFont& font, Qt::AlignmentFlag halignment = Qt::AlignLeft, Qt::AlignmentFlag valignment = Qt::AlignTop) const;
	/**Returns the font width in millimeters (considers upscaling and downscaling with FONT_WORKAROUND_SCALE*/
	double textWidthMillimeters(const QFont& font, const QString& text) const;
	/**Returns the font height of a character in millimeters. */
	double fontHeightCharacterMM(const QFont& font, const QChar& c) const;
	/**Returns the font ascent in Millimeters (considers upscaling and downscaling with FONT_WORKAROUND_SCALE*/
	double fontAscentMillimeters(const QFont& font) const;
	/**Calculates font to from point size to pixel size*/
	double pixelFontSize(double pointSize) const;
	/**Returns a font where size is in pixel and font size is upscaled with FONT_WORKAROUND_SCALE*/
	QFont scaledFontPixelSize(const QFont& font) const;

	/* friend class QgsDecorationGridDialog; */
};

#endif


#include "qgsdecorationgrid.h"
#include "qgslogger.h"
#include "qgsmaplayer.h"
#include "qgsrasterlayer.h"
#include "qgsmaptopixel.h"
#include "qgspoint.h"
#include "qgsproject.h"
#include "qgssymbollayerv2utils.h" //for pointOnLineWithDistance
#include "qgssymbolv2.h" //for symbology
#include "qgsmarkersymbollayerv2.h"
#include "qgsrendercontext.h"
#include "qgsmapcanvas.h"
#include "qgsmaprenderer.h"

#include <QPainter>
#include <QAction>
#include <QPen>
#include <QPolygon>
#include <QString>
#include <QFontMetrics>
#include <QFont>
#include <QColor>
#include <QMenu>
#include <QFile>
#include <QLocale>
#include <QDomDocument>
#include <QMessageBox>

//non qt includes
#include <cmath>

#define FONT_WORKAROUND_SCALE 10 //scale factor for upscaling fontsize and downscaling painter

QgsDecorationGrid::QgsDecorationGrid(QObject* parent, QgsMapCanvas* Canvas)
	: QgsDecorationItem(parent) {
	setName("Grid");
	mapCanvas = Canvas;
	mLineSymbol = 0;
	mMarkerSymbol = 0;
	projectRead();
	connect(mapCanvas, SIGNAL(mapUnitsChanged()),
		this, SLOT(checkMapUnitsChanged()));
}

void QgsDecorationGrid::GridsetEnabled(bool b) {
	setEnabled(b);
	mapCanvas->refresh();
}

QgsDecorationGrid::~QgsDecorationGrid() {
	if (mLineSymbol) {
		delete mLineSymbol;
		mLineSymbol = NULL;
	}
	if (mMarkerSymbol) {
		delete mMarkerSymbol;
		mMarkerSymbol = NULL;
	}
}

void QgsDecorationGrid::setLineSymbol(QgsLineSymbolV2* symbol) {
	if (mLineSymbol)
		delete mLineSymbol;
	mLineSymbol = symbol;
}

void QgsDecorationGrid::setMarkerSymbol(QgsMarkerSymbolV2* symbol) {
	if (mMarkerSymbol)
		delete mMarkerSymbol;
	mMarkerSymbol = symbol;
}

void QgsDecorationGrid::projectRead() {
	QgsDecorationItem::projectRead();

	mEnabled = QgsProject::instance()->readBoolEntry(mNameConfig, "/Enabled", false);
	mMapUnits = (QGis::UnitType) QgsProject::instance()->readNumEntry(mNameConfig, "/MapUnits",
		QGis::UnknownUnit);
	mGridStyle = (GridStyle)QgsProject::instance()->readNumEntry(mNameConfig, "/Style",
		QgsDecorationGrid::Line);
	mGridIntervalX = QgsProject::instance()->readDoubleEntry(mNameConfig, "/IntervalX", 10);
	mGridIntervalY = QgsProject::instance()->readDoubleEntry(mNameConfig, "/IntervalY", 10);
	mGridOffsetX = QgsProject::instance()->readDoubleEntry(mNameConfig, "/OffsetX", 0);
	mGridOffsetY = QgsProject::instance()->readDoubleEntry(mNameConfig, "/OffsetY", 0);
	mShowGridAnnotation = QgsProject::instance()->readBoolEntry(mNameConfig, "/ShowAnnotation", false);
	mGridAnnotationPosition = InsideMapFrame; // don't allow outside frame, doesn't make sense
	mGridAnnotationDirection = (GridAnnotationDirection)QgsProject::instance()->readNumEntry(mNameConfig,
		"/AnnotationDirection", 0);
	QString fontStr = QgsProject::instance()->readEntry(mNameConfig, "/AnnotationFont", "");
	if (fontStr != "") {
		mGridAnnotationFont.fromString(fontStr);
	} else {
		mGridAnnotationFont = QFont();
		// TODO fix font scaling problem - put a slightly large font for now
		mGridAnnotationFont.setPointSize(16);
	}
	mAnnotationFrameDistance = QgsProject::instance()->readDoubleEntry(mNameConfig, "/AnnotationFrameDistance", 0);
	mGridAnnotationPrecision = QgsProject::instance()->readNumEntry(mNameConfig, "/AnnotationPrecision", 0);

	// read symbol info from xml
	QDomDocument doc;
	QDomElement elem;
	QString xml;

	if (mLineSymbol)
		setLineSymbol(0);
	xml = QgsProject::instance()->readEntry(mNameConfig, "/LineSymbol");
	if (xml != "") {
		doc.setContent(xml);
		elem = doc.documentElement();
		mLineSymbol = QgsSymbolLayerV2Utils::loadSymbol<QgsLineSymbolV2>(elem);
	}
	if (!mLineSymbol)
		mLineSymbol = new QgsLineSymbolV2();

	if (mMarkerSymbol)
		setMarkerSymbol(0);
	xml = QgsProject::instance()->readEntry(mNameConfig, "/MarkerSymbol");
	if (xml != "") {
		doc.setContent(xml);
		elem = doc.documentElement();
		mMarkerSymbol = QgsSymbolLayerV2Utils::loadSymbol<QgsMarkerSymbolV2>(elem);
	}
	if (!mMarkerSymbol) {
		// set default symbol : cross with width=3
		QgsSymbolLayerV2List symbolList;
		symbolList << new QgsSimpleMarkerSymbolLayerV2("cross", DEFAULT_SIMPLEMARKER_COLOR,
			DEFAULT_SIMPLEMARKER_BORDERCOLOR, 3, 0);
		mMarkerSymbol = new QgsMarkerSymbolV2(symbolList);
	}
}

void QgsDecorationGrid::saveToProject() {
	QgsDecorationItem::saveToProject();
	QgsProject::instance()->writeEntry(mNameConfig, "/Enabled", mEnabled);
	QgsProject::instance()->writeEntry(mNameConfig, "/MapUnits", (int)mMapUnits);
	QgsProject::instance()->writeEntry(mNameConfig, "/Style", (int)mGridStyle);
	QgsProject::instance()->writeEntry(mNameConfig, "/IntervalX", mGridIntervalX);
	QgsProject::instance()->writeEntry(mNameConfig, "/IntervalY", mGridIntervalY);
	QgsProject::instance()->writeEntry(mNameConfig, "/OffsetX", mGridOffsetX);
	QgsProject::instance()->writeEntry(mNameConfig, "/OffsetY", mGridOffsetY);
	QgsProject::instance()->writeEntry(mNameConfig, "/ShowAnnotation", mShowGridAnnotation);
	QgsProject::instance()->writeEntry(mNameConfig, "/AnnotationDirection", (int)mGridAnnotationDirection);
	QgsProject::instance()->writeEntry(mNameConfig, "/AnnotationFont", mGridAnnotationFont.toString());
	QgsProject::instance()->writeEntry(mNameConfig, "/AnnotationFrameDistance", mAnnotationFrameDistance);
	QgsProject::instance()->writeEntry(mNameConfig, "/AnnotationPrecision", mGridAnnotationPrecision);

	// write symbol info to xml
	QDomDocument doc;
	QDomElement elem;
	if (mLineSymbol) {
		elem = QgsSymbolLayerV2Utils::saveSymbol("line symbol", mLineSymbol, doc);
		doc.appendChild(elem);
		// FIXME this works, but XML will not be valid as < is replaced by &lt;
		QgsProject::instance()->writeEntry(mNameConfig, "/LineSymbol", doc.toString());
	}
	if (mMarkerSymbol) {
		doc.setContent(QString(""));
		elem = QgsSymbolLayerV2Utils::saveSymbol("marker symbol", mMarkerSymbol, doc);
		doc.appendChild(elem);
		QgsProject::instance()->writeEntry(mNameConfig, "/MarkerSymbol", doc.toString());
	}
}

void QgsDecorationGrid::run() {
	update();
	mapCanvas->refresh();
}

void QgsDecorationGrid::render(QPainter * p) {
	if (!mEnabled)
		return;
	QList< QPair< qreal, QLineF > > verticalLines;
	yGridLines(verticalLines);
	QList< QPair< qreal, QLineF > > horizontalLines;
	xGridLines(horizontalLines);
	
	QList< QPair< qreal, QLineF > >::const_iterator vIt = verticalLines.constBegin();
	QList< QPair< qreal, QLineF > >::const_iterator hIt = horizontalLines.constBegin();

	//simpler approach: draw vertical lines first, then horizontal ones
	if (mGridStyle == QgsDecorationGrid::Line) {
		if (!mLineSymbol)
			return;

		QgsRenderContext context = QgsRenderContext::fromMapSettings(mapCanvas->mapSettings());
		context.setPainter(p);
		mLineSymbol->startRender(context, 0);

		for (; vIt != verticalLines.constEnd(); ++vIt) {
		
			QVector<QPointF> poly;
			poly << vIt->second.p1() << vIt->second.p2();
			mLineSymbol->renderPolyline(QPolygonF(poly), 0, context);
		}

		for (; hIt != horizontalLines.constEnd(); ++hIt) {
			QVector<QPointF> poly;
			poly << hIt->second.p1() << hIt->second.p2();
			mLineSymbol->renderPolyline(QPolygonF(poly), 0, context);
		}

		mLineSymbol->stopRender(context);
	}
else //marker
	{
		if (!mMarkerSymbol)
			return;

		QgsRenderContext context = QgsRenderContext::fromMapSettings(mapCanvas->mapSettings());
		context.setPainter(p);
		mMarkerSymbol->startRender(context, 0);

		QPointF intersectionPoint;
		for (; vIt != verticalLines.constEnd(); ++vIt) {
			//test for intersection with every horizontal line
			hIt = horizontalLines.constBegin();
			for (; hIt != horizontalLines.constEnd(); ++hIt) {
				if (hIt->second.intersect(vIt->second, &intersectionPoint) == QLineF::BoundedIntersection) {
					mMarkerSymbol->renderPoint(intersectionPoint, 0, context);
				}
			}
		}
		mMarkerSymbol->stopRender(context);
	}
	if (mShowGridAnnotation) {
		drawCoordinateAnnotations(p, horizontalLines, verticalLines);
	}
}

void QgsDecorationGrid::drawCoordinateAnnotations(QPainter* p, const QList< QPair< qreal, QLineF > >& hLines, const QList< QPair< qreal, QLineF > >& vLines) {
	if (!p) {
		return;
	}

	QString currentAnnotationString;
	QList< QPair< qreal, QLineF > >::const_iterator it = hLines.constBegin();
	for (; it != hLines.constEnd(); ++it) {
		currentAnnotationString = QString::number(it->first, 'f', mGridAnnotationPrecision);
		drawCoordinateAnnotation(p, it->second.p1(), currentAnnotationString);
		drawCoordinateAnnotation(p, it->second.p2(), currentAnnotationString);
	}

	it = vLines.constBegin();
	for (; it != vLines.constEnd(); ++it) {
		currentAnnotationString = QString::number(it->first, 'f', mGridAnnotationPrecision);
		drawCoordinateAnnotation(p, it->second.p1(), currentAnnotationString);
		drawCoordinateAnnotation(p, it->second.p2(), currentAnnotationString);
	}
}

void QgsDecorationGrid::drawCoordinateAnnotation(QPainter* p, const QPointF& pos, QString annotationString) {
	Border frameBorder = borderForLineCoord(pos, p);
	double textWidth = textWidthMillimeters(mGridAnnotationFont, annotationString);
	//relevant for annotations is the height of digits
	double textHeight = fontHeightCharacterMM(mGridAnnotationFont, QChar('0'));
	double xpos = pos.x();
	double ypos = pos.y();
	int rotation = 0;

	if (frameBorder == Left) {

		if (mGridAnnotationPosition == InsideMapFrame) {
			if (mGridAnnotationDirection == Vertical || mGridAnnotationDirection == BoundaryDirection) {
				xpos += textHeight + mAnnotationFrameDistance;
				ypos += textWidth / 2.0;
				rotation = 270;
			} else {
				xpos += mAnnotationFrameDistance;
				ypos += textHeight / 2.0;
			}
		} else //Outside map frame
		{
			if (mGridAnnotationDirection == Vertical || mGridAnnotationDirection == BoundaryDirection) {
				xpos -= mAnnotationFrameDistance;
				ypos += textWidth / 2.0;
				rotation = 270;
			} else {
				xpos -= textWidth + mAnnotationFrameDistance;
				ypos += textHeight / 2.0;
			}
		}

	} else if (frameBorder == Right) {
		if (mGridAnnotationPosition == InsideMapFrame) {
			if (mGridAnnotationDirection == Vertical || mGridAnnotationDirection == BoundaryDirection) {
				xpos -= mAnnotationFrameDistance;
				ypos += textWidth / 2.0;
				rotation = 270;
			} else //Horizontal
			{
				xpos -= textWidth + mAnnotationFrameDistance;
				ypos += textHeight / 2.0;
			}
		} else //OutsideMapFrame
		{
			if (mGridAnnotationDirection == Vertical || mGridAnnotationDirection == BoundaryDirection) {
				xpos += textHeight + mAnnotationFrameDistance;
				ypos += textWidth / 2.0;
				rotation = 270;
			} else //Horizontal
			{
				xpos += mAnnotationFrameDistance;
				ypos += textHeight / 2.0;
			}
		}
	} else if (frameBorder == Bottom) {
		if (mGridAnnotationPosition == InsideMapFrame) {
			if (mGridAnnotationDirection == Horizontal || mGridAnnotationDirection == BoundaryDirection) {
				ypos -= mAnnotationFrameDistance;
				xpos -= textWidth / 2.0;
			} else //Vertical
			{
				xpos += textHeight / 2.0;
				ypos -= mAnnotationFrameDistance;
				rotation = 270;
			}
		} else //OutsideMapFrame
		{
			if (mGridAnnotationDirection == Horizontal || mGridAnnotationDirection == BoundaryDirection) {
				ypos += mAnnotationFrameDistance + textHeight;
				xpos -= textWidth / 2.0;
			} else //Vertical
			{
				xpos += textHeight / 2.0;
				ypos += textWidth + mAnnotationFrameDistance;
				rotation = 270;
			}
		}
	} else //Top
	{
		if (mGridAnnotationPosition == InsideMapFrame) {
			if (mGridAnnotationDirection == Horizontal || mGridAnnotationDirection == BoundaryDirection) {
				xpos -= textWidth / 2.0;
				ypos += textHeight + mAnnotationFrameDistance;
			} else //Vertical
			{
				xpos += textHeight / 2.0;
				ypos += textWidth + mAnnotationFrameDistance;
				rotation = 270;
			}
		} else //OutsideMapFrame
		{
			if (mGridAnnotationDirection == Horizontal || mGridAnnotationDirection == BoundaryDirection) {
				xpos -= textWidth / 2.0;
				ypos -= mAnnotationFrameDistance;
			} else //Vertical
			{
				xpos += textHeight / 2.0;
				ypos -= mAnnotationFrameDistance;
				rotation = 270;
			}
		}
	}

	drawAnnotation(p, QPointF(xpos, ypos), rotation, annotationString);
}
void QgsDecorationGrid::drawAnnotation(QPainter* p, const QPointF& pos, int rotation, const QString& annotationText) {
	p->save();
	p->translate(pos);
	p->rotate(rotation);
	drawText(p, 0, 0, annotationText, mGridAnnotationFont);
	p->restore();
}

QPolygonF canvasPolygon(QgsMapCanvas *canvas) {
	QPolygonF poly;

	const QgsMapCanvas& mapCanvas = *canvas;
	const QgsMapSettings& mapSettings = mapCanvas.mapSettings();
	return mapSettings.visiblePolygon();
}

bool clipByRect(QLineF& line, const QPolygonF& rect) {
	QVector<QLineF> borderLines;
	borderLines << QLineF(rect.at(0), rect.at(1));
	borderLines << QLineF(rect.at(1), rect.at(2));
	borderLines << QLineF(rect.at(2), rect.at(3));
	borderLines << QLineF(rect.at(3), rect.at(0));

	QList<QPointF> intersectionList;
	QVector<QLineF>::const_iterator it = borderLines.constBegin();
	for (; it != borderLines.constEnd(); ++it) {
		QPointF intersectionPoint;
		if (it->intersect(line, &intersectionPoint) == QLineF::BoundedIntersection) {
			intersectionList.push_back(intersectionPoint);
			if (intersectionList.size() >= 2) {
				break; //we already have two intersections, skip further tests
			}
		}
	}
	if (intersectionList.size() < 2) return false; // no intersection

	line = QLineF(intersectionList.at(0), intersectionList.at(1));
	return true;
}

QPolygonF canvasExtent(QgsMapCanvas *canvas) {
	QPolygonF poly;
	QgsRectangle extent = (*canvas).extent();
	poly << QPointF(extent.xMinimum(), extent.yMaximum());
	poly << QPointF(extent.xMaximum(), extent.yMaximum());
	poly << QPointF(extent.xMaximum(), extent.yMinimum());
	poly << QPointF(extent.xMinimum(), extent.yMinimum());
	return poly;
}

int QgsDecorationGrid::xGridLines(QList< QPair< qreal, QLineF > >& lines) const {
	// prepare horizontal lines
	lines.clear();
	if (mGridIntervalY <= 0.0) {
		return 1;
	}

	const QgsMapCanvas& mapCanvass = *mapCanvas;
	const QgsMapSettings& mapSettings = mapCanvass.mapSettings();
	const QgsMapToPixel& m2p = mapSettings.mapToPixel();

	// draw nothing if the distance between grid lines would be less than 1px
	// otherwise the grid lines would completely cover the whole map
	
	if (mGridIntervalY / mapSettings.mapUnitsPerPixel() < 1)
		return 1;

	const QPolygonF& canvasPoly = canvasPolygon(mapCanvas);
	const QPolygonF& mapPolygon = canvasExtent(mapCanvas);
	const QRectF& mapBoundingRect = mapPolygon.boundingRect();
	QLineF lineEast(mapPolygon[2], mapPolygon[1]);
	QLineF lineWest(mapPolygon[3], mapPolygon[0]);

	double len = lineEast.length();
	Q_ASSERT(fabs(len - lineWest.length()) < 1e-6); // no shear

	double roundCorrection = mapBoundingRect.top() > 0 ? 1.0 : 0.0;
	double dist = (int)((mapBoundingRect.top() - mGridOffsetY) / mGridIntervalY + roundCorrection) * mGridIntervalY + mGridOffsetY;
	dist = dist - mapBoundingRect.top();
	while (dist < len) {
		double t = dist / len;
		QPointF p0 = lineWest.pointAt(t);
		QPointF p1 = lineEast.pointAt(t);
		QLineF line(p0, p1);
		clipByRect(line, canvasPoly);
		line = QLineF(m2p.transform(QgsPoint(line.pointAt(0))).toQPointF(), m2p.transform(QgsPoint(line.pointAt(1))).toQPointF());
		lines.push_back(qMakePair(p0.y(), line));
		dist += mGridIntervalY;
	}

	return 0;
}

int QgsDecorationGrid::yGridLines(QList< QPair< qreal, QLineF > >& lines) const {
	// prepare vertical lines

	lines.clear();
	if (mGridIntervalX <= 0.0) {
		return 1;
	}

	const QgsMapCanvas& mapCanvass = *mapCanvas;
	const QgsMapSettings& mapSettings = mapCanvass.mapSettings();
	const QgsMapToPixel& m2p = mapSettings.mapToPixel();

	// draw nothing if the distance between grid lines would be less than 1px
	// otherwise the grid lines would completely cover the whole map
	if (mGridIntervalX / mapSettings.mapUnitsPerPixel() < 1)
		return 1;

	const QPolygonF& canvasPoly = canvasPolygon(mapCanvas);
	const QPolygonF& mapPolygon = canvasExtent(mapCanvas);
	QLineF lineSouth(mapPolygon[3], mapPolygon[2]);
	QLineF lineNorth(mapPolygon[0], mapPolygon[1]);

	double len = lineSouth.length();
	Q_ASSERT(fabs(len - lineNorth.length()) < 1e-6); // no shear

	const QRectF& mapBoundingRect = mapPolygon.boundingRect();
	double roundCorrection = mapBoundingRect.left() > 0 ? 1.0 : 0.0;
	double dist = (int)((mapBoundingRect.left() - mGridOffsetX) / mGridIntervalX + roundCorrection) * mGridIntervalX + mGridOffsetX;
	dist = dist - mapBoundingRect.left();
	while (dist < len) {
		double t = dist / len;
		QPointF p0(lineNorth.pointAt(t));
		QPointF p1(lineSouth.pointAt(t));
		QLineF line(p0, p1);
		clipByRect(line, canvasPoly);
		line = QLineF(m2p.transform(QgsPoint(line.pointAt(0))).toQPointF(), m2p.transform(QgsPoint(line.pointAt(1))).toQPointF());
		lines.push_back(qMakePair(p0.x(), line));
		dist += mGridIntervalX;
	}

	return 0;
}

QgsDecorationGrid::Border QgsDecorationGrid::borderForLineCoord(const QPointF& point, QPainter* p) const {
	if (point.x() <= mGridPen.widthF()) {
		return Left;
	} else if (point.x() >= (p->device()->width() - mGridPen.widthF())) {
		return Right;
	} else if (point.y() <= mGridPen.widthF()) {
		return Top;
	} else {
		return Bottom;
	}
}

void QgsDecorationGrid::drawText(QPainter* p, double x, double y, const QString& text, const QFont& font) const {
	QFont textFont = scaledFontPixelSize(font);

	p->save();
	p->setFont(textFont);
	p->setPen(mGridPen); 
	double scaleFactor = 1.0 / FONT_WORKAROUND_SCALE;
	p->scale(scaleFactor, scaleFactor);
	p->drawText(QPointF(x * FONT_WORKAROUND_SCALE, y * FONT_WORKAROUND_SCALE), text);
	p->restore();
}

void QgsDecorationGrid::drawText(QPainter* p, const QRectF& rect, const QString& text, const QFont& font, Qt::AlignmentFlag halignment, Qt::AlignmentFlag valignment) const {
	QFont textFont = scaledFontPixelSize(font);

	QRectF scaledRect(rect.x() * FONT_WORKAROUND_SCALE, rect.y() * FONT_WORKAROUND_SCALE,
		rect.width() * FONT_WORKAROUND_SCALE, rect.height() * FONT_WORKAROUND_SCALE);

	p->save();
	p->setFont(textFont);
	double scaleFactor = 1.0 / FONT_WORKAROUND_SCALE;
	p->scale(scaleFactor, scaleFactor);
	p->drawText(scaledRect, halignment | valignment | Qt::TextWordWrap, text);
	p->restore();
}

double QgsDecorationGrid::textWidthMillimeters(const QFont& font, const QString& text) const {
	QFont metricsFont = scaledFontPixelSize(font);
	QFontMetrics fontMetrics(metricsFont);
	return (fontMetrics.width(text) / FONT_WORKAROUND_SCALE);
}

double QgsDecorationGrid::fontHeightCharacterMM(const QFont& font, const QChar& c) const {
	QFont metricsFont = scaledFontPixelSize(font);
	QFontMetricsF fontMetrics(metricsFont);
	return (fontMetrics.boundingRect(c).height() / FONT_WORKAROUND_SCALE);
}

double QgsDecorationGrid::fontAscentMillimeters(const QFont& font) const {
	QFont metricsFont = scaledFontPixelSize(font);
	QFontMetricsF fontMetrics(metricsFont);
	return (fontMetrics.ascent() / FONT_WORKAROUND_SCALE);
}

double QgsDecorationGrid::pixelFontSize(double pointSize) const {
	return pointSize;
}

QFont QgsDecorationGrid::scaledFontPixelSize(const QFont& font) const {
	QFont scaledFont = font;
	double pixelSize = pixelFontSize(font.pointSizeF()) * FONT_WORKAROUND_SCALE + 0.5;
	scaledFont.setPixelSize(pixelSize);
	return scaledFont;
}

void QgsDecorationGrid::checkMapUnitsChanged() {
	// disable grid if units changed and grid is enabled, and update the canvas
	// this is to avoid problems when CRS changes to/from geographic and projected
	// a better solution would be to change the grid interval, but this is a little tricky
	// note: we could be less picky (e.g. from degrees to DMS)
	QGis::UnitType mapUnits = mapCanvas->mapSettings().mapUnits();
	if (mEnabled && (mMapUnits != mapUnits)) {
		mEnabled = false;
		mMapUnits = QGis::UnknownUnit; // make sure isDirty() returns true
		if (!mapCanvas->isFrozen()) {
			update();
		}
	}
}

bool QgsDecorationGrid::isDirty() {
	// checks if stored map units is undefined or different from canvas map units
	// or if interval is 0
	if (mMapUnits == QGis::UnknownUnit ||
		mMapUnits != mapCanvas->mapSettings().mapUnits() ||
		mGridIntervalX == 0 || mGridIntervalY == 0)
		return true;
	return false;
}

void QgsDecorationGrid::setDirty(bool dirty) {
	if (dirty) {
		mMapUnits = QGis::UnknownUnit;
	} else {
		mMapUnits = mapCanvas->mapSettings().mapUnits();
	}
}

bool QgsDecorationGrid::getIntervalFromExtent(double* values, bool useXAxis) {
	// get default interval from current extents
	// calculate a default interval that is approx (extent width)/5, adjusted so that it is a rounded number
	// e.g. 12.7 -> 10  66556 -> 70000
	double interval = 0;
	QgsRectangle extent = mapCanvas->extent();
	if (useXAxis)
		interval = (extent.xMaximum() - extent.xMinimum()) / 5;
	else
		interval = (extent.yMaximum() - extent.yMinimum()) / 5;
	QgsDebugMsg(QString("interval: %1").arg(interval));
	if (interval != 0) {
		double interval2 = 0;
		int factor = pow(10, floor(log10(interval)));
		if (factor != 0) {
			interval2 = qRound(interval / factor) * factor;
			QgsDebugMsg(QString("interval2: %1").arg(interval2));
			if (interval2 != 0)
				interval = interval2;
		}
	}
	values[0] = values[1] = interval;
	values[2] = values[3] = 0;
	return true;
}

bool QgsDecorationGrid::getIntervalFromCurrentLayer(double* values) {
	// get current layer and make sure it is a raster layer and CRSs match
	QgsMapLayer* layer = mapCanvas->currentLayer();
	if (!layer) {
		QMessageBox::warning(0, tr("Error"), tr("No active layer"));
		return false;
	}
	if (layer->type() != QgsMapLayer::RasterLayer) {
		QMessageBox::warning(0, tr("Error"), tr("Please select a raster layer"));
		return false;
	}
	QgsRasterLayer* rlayer = dynamic_cast<QgsRasterLayer*>(layer);
	if (!rlayer || rlayer->width() == 0 || rlayer->height() == 0) {
		QMessageBox::warning(0, tr("Error"), tr("Invalid raster layer"));
		return false;
	}
	const QgsCoordinateReferenceSystem& layerCRS = layer->crs();
	const QgsCoordinateReferenceSystem& mapCRS =
		mapCanvas->mapSettings().destinationCrs();
	// is this the best way to compare CRS? should we also make sure map has OTF enabled?
	// TODO calculate transformed values if necessary
	if (layerCRS != mapCRS) {
		QMessageBox::warning(0, tr("Error"), tr("Layer CRS must be equal to project CRS"));
		return false;
	}

	// calculate interval
	// TODO add a function in QgsRasterLayer to get x/y resolution from provider,
	// because this might not be 100% accurate
	QgsRectangle extent = rlayer->extent();
	values[0] = fabs(extent.xMaximum() - extent.xMinimum()) / rlayer->width();
	values[1] = fabs(extent.yMaximum() - extent.yMinimum()) / rlayer->height();

	// calculate offset - when using very high resolution rasters in geographic CRS
	// there seems to be a small shift, but this may be due to rendering issues and depends on zoom
	double ratio = extent.xMinimum() / values[0];
	values[2] = (ratio - floor(ratio)) * values[0];
	ratio = extent.yMinimum() / values[1];
	values[3] = (ratio - floor(ratio)) * values[1];

	QgsDebugMsg(QString("xmax: %1 xmin: %2 width: %3 xInterval: %4 xOffset: %5").arg(
		extent.xMaximum()).arg(extent.xMinimum()).arg(rlayer->width()).arg(values[0]).arg(values[2]));
	QgsDebugMsg(QString("ymax: %1 ymin: %2 height: %3 yInterval: %4 yOffset: %5").arg(
		extent.yMaximum()).arg(extent.yMinimum()).arg(rlayer->height()).arg(values[1]).arg(values[3]));

	return true;
}

定义一个经纬网的封装类：

#pragma once

#include <QObject>
#include <QPen>
#include <QFont>

class QgsDecorationGrid;
class QgsMapCanvas;
class QPainter;

#define QtMapGridInst() (QtMapGrid::getInstance())

class QtMapGrid : public QObject {
	Q_OBJECT
private:
	QtMapGrid(QObject *parent = nullptr);
	static QtMapGrid* _instance;
public:
	~QtMapGrid();
	static QtMapGrid* getInstance();

	void init(QgsMapCanvas* canvas);
	void showGrid(bool show);

private slots:
	void renderDecorationItems(QPainter *p);

private:
	QgsDecorationGrid * _map2DGrid = nullptr;

	bool _isShow = false;//是否显示

	QColor _gridColor = QColor(222, 155, 67);
	double _gridWidth = 0.5;

	QFont _gridFont;
};


#include <QPainter>

#include "QtMapGrid.h"
#include "qgsmapcanvas.h"
#include "qgssymbolv2.h"
#include "QgsDecorationGrid.h"

QtMapGrid* QtMapGrid::_instance = new QtMapGrid;

QtMapGrid::QtMapGrid(QObject *parent)
	: QObject(parent) {
	_gridFont.setFamily(QStringLiteral("微软雅黑"));
	_gridFont.setBold(true);
	_gridFont.setItalic(true);
	_gridFont.setPointSize(20);
}

QtMapGrid::~QtMapGrid() {
}

QtMapGrid* QtMapGrid::getInstance() {
	return _instance;
}

void QtMapGrid::init(QgsMapCanvas* canvas) {
	_map2DGrid = new QgsDecorationGrid(nullptr, canvas);
	connect(canvas, SIGNAL(renderComplete(QPainter *)), this, SLOT(renderDecorationItems(QPainter *)));
}

void QtMapGrid::showGrid(bool show) {
	_isShow = show;
	_map2DGrid->setEnabled(_isShow);
	_map2DGrid->setGridIntervalX(5.0);
	_map2DGrid->setGridIntervalY(5.0);

	//设置线型
	QgsLineSymbolV2* lineGrid =const_cast<QgsLineSymbolV2*>(_map2DGrid->lineSymbol());
	lineGrid->setColor(_gridColor);
	lineGrid->setWidth(_gridWidth);
	lineGrid->setAlpha(0.5);

	//设置字体
	_map2DGrid->setGridPenColor(QColor(0, 0, 255, 150));
	_map2DGrid->setGridAnnotationFont(_gridFont);

	_map2DGrid->setShowGridAnnotation(true);
	_map2DGrid->run();
}

void QtMapGrid::renderDecorationItems(QPainter *p) {
	_map2DGrid->render(p);
}

调用：

QtMapGridInst()->showGrid(/*false*/true);

aaa

wb175208
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
ArcGIS制图技巧
知识搬运者
04-20 1736
之后，选中刚转的经纬度图形，注意选择的是经纬网，而不是制图图框。这是由于坐标系的原因，因此我们只需要改变到合适的坐标系即可。简便方法，将语言改为英文，然后重新打开即可。】，同时在取消勾选经纬度网。然后在属性的网格里，选择【】坐标系，或者直接搜【
qgis经纬度_转载 QGIS获取城市路网数据（经纬度）
weixin_39576336的博客
12-20 2884
工作中遇到了要提取某地路网信息的需求，碰巧碰见这篇文章，完美解决了问题。转载自CSDN大神zhg_vincent的文章1 前言本文介绍如何通过QGIS来获取境内任意城市的路网数据(经纬度坐标)，并以上海市为例，一步步演示最终得到全市路网的百度坐标。1.1 准备工作下载QGIS(本文所用版本：QGIS-OSGeo4W-2.18)；下载完成后双击安装。安装完可以设置语言为简体中文Setting→Opt...
中国经纬网格、用于制作全国地图
04-28
中国经纬网格、用于制作全国地图 shp格式 arcgis可用
10.3.2 QGIS线段类型注释(Annotation)的应用与二次开发实现
最新发布
雷动专栏
07-19 571
介绍注释(Annotation)图层在QGis中的使用以及二次开发的实现说明：文章中的示例代码均来自开源项目qgis_cpp_api_apps介绍了线段类型注释(Annotation)的应用与二次开发实现。
如何使用ArcGIS绘制经纬网
09-08 1万+
在地图出图的时候有时需要增加经纬网以方便查询地图上的坐标，ArcGIS作为一款强大的GIS软件，除了数据分析功能之外，在出图方面也是很方便，这里讲解一下ArcGIS如何在出图的时候加上经纬网格。 步骤： 第一步：下载地图 首先打开水经注万能地图下载器，地图选择谷歌地球，在右上角菜单栏上点击“区划”，在下面选择中国，在地图上点击“√”下载地图（图1）。 图1 第二步：绘制经
Qgis添加经纬度
m0_48587622的博客
07-08 3337
Qgis不像Arcgis可以直接点一下就有经纬度了，Qgis需要创建格网，然后添加，里面还有很多参数需要自己调，文字表达不清楚，建议直接看视频。我参考的是下面这个视频。
数据库中的经纬度数据如何在QGIS中显示
qq_44881930的博客
01-22 989
*注意：**如果是新建数据库，一定要执行如下代码，否则后面的函数没法使用，执行上面代码的前提是要按照postgis。
QGIS获取城市路网数据（经纬度）
热门推荐
Vincent2014Linux
04-25 1万+
1 前言 本文介绍如何通过QGIS来获取境内任意城市的路网数据（经纬度坐标），并以上海市为例，一步步演示最终得到全市路网的百度坐标。 1.1 准备工作 下载QGIS（本文所用版本：QGIS-OSGeo4W-2.18）；下载完成后双击安装。安装完可以设置语言为简体中文Setting→Options→Locale→Override system locale→中文。 下载QGIS的坐标转换插件Ge...
QGIS之制作地图
weixin_47062907的博客
03-03 6167
今天，小崇利用QGIS制作了一个简易的美国阿拉斯加州地图。 1.加载矢量数据和背景底图 具体操作：网络(W)——OSM——OSM Standard OSM地图加载出来后，在浏览器面板中打开alaska.shp、lakes.shp、grassland.shp、majriver.shp等文件，并将这些.shp文件拉拽到右侧的地图展示区内。 矢量数据和背景底图加载完毕的画面如下： 2.打开排版视图添加地图 具体操作：工程——新建打印布局——OK(可以先不填写布局名称)——添加项——添加地图。 左击【添加
qgis-crayfish-plugin:在QGIS中绘制和处理网格数据
05-08
小龙虾3 vs小龙虾2 在QGIS 2.x和Crayfish 2.x中，所有功能都是通过QGIS的插件层实现的。 渲染和格式读取使用C ++语言编写，因此Crayfish 2作为C ++库和QGIS python插件提供。 在QGIS 3.4和Crayfish 3.x中，C ++库被...
vs+qgis+qt实现地图上画点
11-07
本文将详细介绍如何使用Visual Studio（VS）、QGIS和Qt在Windows 10环境下实现“在地图上画点”的功能。这一过程涵盖了C++编程语言、GIS（地理信息系统）技术以及图形用户界面的构建。 首先，我们来看标题“vs+qgis...
全国行政区_经纬度_shp
07-19
中国示例数据，并不保证最新。包括省级行政区数据、一级河流及湖泊数据、主要的公路数据、主要的铁路数据。数据格式经纬度shp
AecGis地图，mxd文件，各级地级城市、国界线、经纬网、湖畔、线路等shp集合文件
08-11
AecGis地图，mxd文件，各级地级城市、行政区、国界线、经纬网、湖畔、铁路公路、线路等shp集合文件
全球经纬网shp格式，有打断的，不打断的供你选择
08-03
全球经纬网shp格式，0.5度间隔，可以在arcgis，mapgis后使用，不用自己制作，省力，做全球分析，应用非常方便，是你不二的选择。有打断的，不打断的供你选择。
全国基础地理数据shp格式
07-18
地级行政界线、地市级以上居民地、国界、主要公路、县级居民地、县级行政界线 等等。。 经纬度格式，
arcgis画经纬网
04-19
arcgis画经纬网 公里网，C#代码示例
使用QGIS软件进行GIS地图图纸校正
02-05
这些特征点通常选取那些在地图上分布相对均匀的点位，例如房间的四个墙角。用户可以自由定义坐标原点和坐标系，但必须确保所有特征点相对于这个坐标原点和坐标系的坐标值是精确测量的。 配置完成并获取了实际的坐标...
UOS 系统上QGis 安装方法.txt
02-18
QGIS是一个用户界面友好的桌面地理信息系统，可运行在Linux、Unix、Mac OSX和Windows等平台之上。QGIS是基于Qt,使用C++开发的一个用户界面友好、跨平台的开源版桌面地理信息系统。本人在此QGIS安装过程与大家共享。
qgis+qt串口远程控制程序实现收发数据及在地图画布上显示位置
11-28
资源里面包含实现远程控制的界面，已打包可以...是咱们实验项目的一部分：通过qt+串口远程控制无人机上的相机、雷达、惯导等，并在地图上实时监控无人机的位置，当检测到目标（火）时，会在地图上标注出火点的位置。
qgis经纬网不显示
05-28
QGIS经纬网不显示可能是由以下原因引起的： 1. 经纬网图层未启用或未正确设置 2. 经纬网符号样式设置错误 3. 经纬网范围设置错误 为了解决这个问题，您可以采取以下步骤： 1. 确认经纬网图层已启用并设置正确。在...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wb175208

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值