FloatQuad TransformationMatrix::mapQuad(const FloatQuad& q) const
{
if (isIdentityOrTranslation()) {
FloatQuad mappedQuad(q);
mappedQuad.move(static_cast<float>(m_matrix[3][0]), static_cast<float>(m_matrix[3][1]));
return mappedQuad;
}
FloatQuad result;
result.setP1(mapPoint(q.p1()));
result.setP2(mapPoint(q.p2()));
result.setP3(mapPoint(q.p3()));
result.setP4(mapPoint(q.p4()));
return result;
}
FloatRect AffineTransform::mapRect(const FloatRect& rect) const
{
if (isIdentityOrTranslation()) {
FloatRect mappedRect(rect);
mappedRect.move(narrowPrecisionToFloat(m_transform[4]), narrowPrecisionToFloat(m_transform[5]));
return mappedRect;
}
FloatQuad result;
result.setP1(mapPoint(rect.location()));
result.setP2(mapPoint(FloatPoint(rect.right(), rect.y())));
result.setP3(mapPoint(FloatPoint(rect.right(), rect.bottom())));
result.setP4(mapPoint(FloatPoint(rect.x(), rect.bottom())));
return result.boundingBox();
}
FloatQuad AffineTransform::mapQuad(const FloatQuad& q) const
{
if (isIdentityOrTranslation()) {
FloatQuad mappedQuad(q);
mappedQuad.move(narrowPrecisionToFloat(m_transform[4]), narrowPrecisionToFloat(m_transform[5]));
return mappedQuad;
}
FloatQuad result;
result.setP1(mapPoint(q.p1()));
result.setP2(mapPoint(q.p2()));
result.setP3(mapPoint(q.p3()));
result.setP4(mapPoint(q.p4()));
return result;
}
void QgsMapToolCircleCenterPoint::cadCanvasReleaseEvent( QgsMapMouseEvent *e )
{
QgsPoint point = mapPoint( *e );
if ( e->button() == Qt::LeftButton )
{
mPoints.append( point );
if ( !mPoints.isEmpty() && !mTempRubberBand )
{
mTempRubberBand = createGeometryRubberBand( mLayerType, true );
mTempRubberBand->show();
}
}
else if ( e->button() == Qt::RightButton )
{
mPoints.append( point );
deactivate();
if ( mParentTool )
{
mParentTool->canvasReleaseEvent( e );
}
}
}
DataSet* Applier::mapDataSet(const DataSet* dataset) const {
MAPDATASET_PREPARE;
MAPDATASET_LOOP_POINT;
Point* newp = mapPoint(p);
MAPDATASET_END_LOOP;
}
void QgsMapToolCircle3Points::cadCanvasMoveEvent( QgsMapMouseEvent *e )
{
QgsPoint point = mapPoint( *e );
if ( mTempRubberBand )
{
switch ( mPoints.size() )
{
case 1:
{
std::unique_ptr<QgsLineString> line( new QgsLineString() );
line->addVertex( mPoints.at( 0 ) );
line->addVertex( point );
mTempRubberBand->setGeometry( line.release() );
}
break;
case 2:
{
mCircle = QgsCircle().from3Points( mPoints.at( 0 ), mPoints.at( 1 ), point );
mTempRubberBand->setGeometry( mCircle.toCircularString( true ) );
}
break;
default:
break;
}
}
}
void QgsMapToolCircularStringRadius::recalculateTempRubberBand( const QgsPointXY &mousePosition )
{
QgsPointSequence rubberBandPoints;
if ( !( mPoints.size() % 2 ) )
{
//recalculate midpoint on circle segment
QgsPoint midPoint;
if ( !QgsGeometryUtils::segmentMidPoint( mPoints.at( mPoints.size() - 2 ), mTemporaryEndPoint, midPoint, mRadius,
QgsPoint( mousePosition ) ) )
{
return;
}
mPoints.replace( mPoints.size() - 1, midPoint );
rubberBandPoints.append( mPoints.at( mPoints.size() - 2 ) );
rubberBandPoints.append( mPoints.last() );
rubberBandPoints.append( mTemporaryEndPoint );
}
else
{
rubberBandPoints.append( mPoints.last() );
rubberBandPoints.append( mapPoint( mousePosition ) );
}
QgsCircularString *cString = new QgsCircularString();
cString->setPoints( rubberBandPoints );
delete mTempRubberBand;
mTempRubberBand = createGeometryRubberBand( mLayerType, true );
mTempRubberBand->setGeometry( cString );
mTempRubberBand->show();
}
void QgsMapToolRegularPolygonCenterCorner::cadCanvasReleaseEvent( QgsMapMouseEvent *e )
{
QgsPoint point = mapPoint( *e );
if ( e->button() == Qt::LeftButton )
{
mPoints.append( point );
if ( !mPoints.isEmpty() )
{
if ( !mTempRubberBand )
{
mTempRubberBand = createGeometryRubberBand( mLayerType, true );
mTempRubberBand->show();
createNumberSidesSpinBox();
}
}
}
else if ( e->button() == Qt::RightButton )
{
mPoints.append( point );
deactivate();
if ( mParentTool )
{
mParentTool->canvasReleaseEvent( e );
}
}
}
void QgsMapToolRegularPolygonCenterCorner::cadCanvasMoveEvent( QgsMapMouseEvent *e )
{
QgsPoint point = mapPoint( *e );
if ( mTempRubberBand )
{
QgsRegularPolygon::ConstructionOption option = QgsRegularPolygon::InscribedCircle;
mRegularPolygon = QgsRegularPolygon( mPoints.at( 0 ), point, mNumberSidesSpinBox->value(), option );
mTempRubberBand->setGeometry( mRegularPolygon.toPolygon() );
}
}
void QgsMapToolCircularStringCurvePoint::cadCanvasMoveEvent( QgsMapMouseEvent *e )
{
QgsPointV2 mapPoint( e->mapPoint() );
QgsVertexId idx( 0, 0, 1 + ( mPoints.size() + 1 ) % 2 );
if ( mTempRubberBand )
{
mTempRubberBand->moveVertex( idx, mapPoint );
updateCenterPointRubberBand( mapPoint );
}
}
void QgsMapToolCircleCenterPoint::cadCanvasMoveEvent( QgsMapMouseEvent *e )
{
QgsPoint point = mapPoint( *e );
mSnapIndicator->setMatch( e->mapPointMatch() );
if ( mTempRubberBand )
{
mCircle = QgsCircle().fromCenterPoint( mPoints.at( 0 ), point );
mTempRubberBand->setGeometry( mCircle.toCircularString( true ) );
}
}
void QgsMapToolCircularStringCurvePoint::cadCanvasReleaseEvent( QgsMapMouseEvent *e )
{
QgsPointV2 mapPoint( e->mapPoint() );
if ( e->button() == Qt::LeftButton )
{
mPoints.append( mapPoint );
if ( !mCenterPointRubberBand && mShowCenterPointRubberBand )
{
createCenterPointRubberBand();
}
if ( !mPoints.isEmpty() )
{
if ( !mTempRubberBand )
{
mTempRubberBand = createGeometryRubberBand( ( mode() == CapturePolygon ) ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry, true );
mTempRubberBand->show();
}
QgsCircularString *c = new QgsCircularString();
QgsPointSequence rubberBandPoints = mPoints.mid( mPoints.size() - 1 - ( mPoints.size() + 1 ) % 2 );
rubberBandPoints.append( mapPoint );
c->setPoints( rubberBandPoints );
mTempRubberBand->setGeometry( c );
}
if ( mPoints.size() > 1 && mPoints.size() % 2 )
{
if ( !mRubberBand )
{
mRubberBand = createGeometryRubberBand( ( mode() == CapturePolygon ) ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry );
mRubberBand->show();
}
QgsCircularString *c = new QgsCircularString();
QgsPointSequence rubberBandPoints = mPoints;
rubberBandPoints.append( mapPoint );
c->setPoints( rubberBandPoints );
mRubberBand->setGeometry( c );
removeCenterPointRubberBand();
}
}
else if ( e->button() == Qt::RightButton )
{
deactivate();
if ( mParentTool )
{
mParentTool->canvasReleaseEvent( e );
}
}
}
void QgsMapToolCircularStringRadius::cadCanvasReleaseEvent( QgsMapMouseEvent* e )
{
QgsPointV2 mapPoint( e->mapPoint() );
if ( e->button() == Qt::LeftButton )
{
if ( mPoints.isEmpty() )
{
mPoints.append( mapPoint );
}
else
{
if ( mPoints.size() % 2 )
{
mTemporaryEndPoint = mapPoint;
//initial radius is distance( tempPoint - mPoints.last ) / 2.0
double minRadius = sqrt( QgsGeometryUtils::sqrDistance2D( mPoints.last(), mTemporaryEndPoint ) ) / 2.0;
mRadius = minRadius + minRadius / 10.0;
QgsPointV2 result;
if ( QgsGeometryUtils::segmentMidPoint( mPoints.last(), mTemporaryEndPoint, result, mRadius, QgsPointV2( mapPoint.x(), mapPoint.y() ) ) )
{
mPoints.append( result );
createRadiusSpinBox();
if ( mRadiusSpinBox )
{
mRadiusSpinBox->setMinimum( minRadius );
}
}
}
else
{
mPoints.append( mTemporaryEndPoint );
deleteRadiusSpinBox();
}
recalculateRubberBand();
recalculateTempRubberBand( e->mapPoint() );
}
}
else if ( e->button() == Qt::RightButton )
{
if ( !( mPoints.size() % 2 ) )
mPoints.removeLast();
deactivate();
if ( mParentTool )
{
mParentTool->canvasReleaseEvent( e );
}
}
}
void QgsMapToolRectangle3Points::cadCanvasMoveEvent( QgsMapMouseEvent *e )
{
QgsPoint point = mapPoint( *e );
if ( mTempRubberBand )
{
switch ( mPoints.size() )
{
case 1:
{
std::unique_ptr<QgsLineString> line( new QgsLineString() );
line->addVertex( mPoints.at( 0 ) );
line->addVertex( point );
mTempRubberBand->setGeometry( line.release() );
setAzimuth( mPoints.at( 0 ).azimuth( point ) );
setDistance1( mPoints.at( 0 ).distance( point ) );
}
break;
case 2:
{
setDistance2( mPoints.at( 1 ).distance( point ) );
int side = QgsGeometryUtils::leftOfLine( point.x(), point.y(),
mPoints.at( 0 ).x(), mPoints.at( 0 ).y(),
mPoints.at( 1 ).x(), mPoints.at( 1 ).y() );
setSide( side < 0 ? -1 : 1 );
const double xMin = mPoints.at( 0 ).x();
const double xMax = mPoints.at( 0 ).x() + distance2( );
const double yMin = mPoints.at( 0 ).y();
const double yMax = mPoints.at( 0 ).y() + distance1();
const double z = mPoints.at( 0 ).z();
mRectangle = QgsBox3d( xMin, yMin, z, xMax, yMax, z );
mTempRubberBand->setGeometry( QgsMapToolAddRectangle::rectangleToPolygon( true ) );
}
break;
default:
break;
}
}
}
bool warpPatchHomography(const cv::Mat_<unsigned char> &im, const Eigen::Matrix<T,3,3> &H, cv::Mat_<unsigned char> &patch)
{
Eigen::Matrix<T,2,1> pt;
for (int v=0; v<patch.rows; v++)
{
for (int u=0; u<patch.cols; u++)
{
mapPoint(Eigen::Matrix<T,2,1>(u,v), H, pt);
if ((int)pt[0] < 0 || (int)pt[1] < 0 || int(pt[0])+1 >= im.cols || int(pt[1])+1 >= im.rows)
return false;
patch(v,u) = getInterpolated(im, pt);
}
}
return true;
}
bool warpPatchHomography(const unsigned char *im, int im_rows, int im_cols, const T H[9], unsigned char *patch, int p_rows, int p_cols)
{
T pt[2];
for (int v=0; v<p_rows; v++)
{
for (int u=0; u<p_cols; u++)
{
mapPoint(u,v, H, pt[0], pt[1]);
if ((int)pt[0]<0 || (int)pt[1]<0 || int(pt[0])+1>=im_cols || int(pt[1])+1>=im_rows)
{
return false;
}
patch[v*p_cols+u] = getInterpolated(im, im_rows, im_cols, pt);
}
}
return true;
}
QgsPoint QgsMapToolCapture::mapPoint( const QgsMapMouseEvent &e ) const
{
QgsPoint newPoint = mapPoint( e.mapPoint() );
// set z value from snapped point if necessary
if ( QgsWkbTypes::hasZ( newPoint.wkbType() ) )
{
// if snapped, z dimension is taken from the corresponding snapped
// point.
if ( e.isSnapped() )
{
const QgsPointLocator::Match match = e.mapPointMatch();
if ( match.layer() && QgsWkbTypes::hasZ( match.layer()->wkbType() ) )
{
const QgsFeature ft = match.layer()->getFeature( match.featureId() );
newPoint.setZ( ft.geometry().vertexAt( match.vertexIndex() ).z() );
}
}
}
return newPoint;
}
void QgsMapToolCircle3Points::cadCanvasReleaseEvent( QgsMapMouseEvent *e )
{
QgsPoint mapPoint( e->mapPoint() );
if ( e->button() == Qt::LeftButton )
{
if ( mPoints.size() < 2 )
mPoints.append( mapPoint );
if ( !mPoints.isEmpty() && !mTempRubberBand )
{
mTempRubberBand = createGeometryRubberBand( ( mode() == CapturePolygon ) ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry, true );
mTempRubberBand->show();
}
}
else if ( e->button() == Qt::RightButton )
{
deactivate();
if ( mParentTool )
{
mParentTool->canvasReleaseEvent( e );
}
}
}
void CGameMap::OnMove(){
//////////地圖動作開始//////////
if(this->isMovingLeft){//往左移動
this->sx-=16;
}
if(this->isMovingRight){//往右移動
this->sx+=16;
}
if(this->isMovingUp){//往上移動
this->sy-=8;
}
if(this->isMovingDown){//往下移動
this->sy+=8;
}
//修正螢幕座標
CPoint mapPoint(CConvert::GetMapPointByScreenPoint(CPoint(400,220)));
mapPoint.x = mapPoint.x<0? 0: mapPoint.x;
mapPoint.x = mapPoint.x>=sizeX*64? sizeX*64-1:mapPoint.x;
mapPoint.y = mapPoint.y<0? 0: mapPoint.y;
mapPoint.y = mapPoint.y>=sizeY*64? sizeY*64-1:mapPoint.y;
CPoint screenPoint(CConvert::GetScreenPointByMapPoint(mapPoint));
sx += screenPoint.x-400;
sy += screenPoint.y-220;
}
CPoint CConvert::GetGridPointByScreenPoint(CPoint sp){//輸入螢幕點得到格子座標**********
CPoint mapPoint(GetMapPointByScreenPoint(sp));//螢幕轉成地圖座標
CPoint gridPoint(GetGridPointByMapPoint(mapPoint));//地圖座標轉成格子座標
return gridPoint;
}
void QgsMapToolCircularStringRadius::cadCanvasReleaseEvent( QgsMapMouseEvent* e )
{
QgsPointV2 mapPoint( e->mapPoint().x(), e->mapPoint().y() );
if ( e->button() == Qt::LeftButton )
{
if ( mPoints.isEmpty() )
{
//get first point from parent tool if there. Todo: move to upper class
const QgsCompoundCurveV2* compoundCurve = mParentTool->captureCurve();
if ( compoundCurve && compoundCurve->nCurves() > 0 )
{
const QgsCurveV2* curve = compoundCurve->curveAt( compoundCurve->nCurves() - 1 );
if ( curve )
{
//mParentTool->captureCurve() is in layer coordinates, but we need map coordinates
QgsPointV2 endPointLayerCoord = curve->endPoint();
QgsPoint mapPoint = toMapCoordinates( mCanvas->currentLayer(), QgsPoint( endPointLayerCoord.x(), endPointLayerCoord.y() ) );
mPoints.append( QgsPointV2( mapPoint.x(), mapPoint.y() ) );
}
}
else
{
mPoints.append( mapPoint );
return;
}
}
if ( mPoints.size() % 2 == 1 )
{
if ( !mRadiusMode )
{
delete mRubberBand; mRubberBand = 0;
mTemporaryEndPointX = mapPoint.x();
mTemporaryEndPointY = mapPoint.y();
mRadiusMode = true;
//initial radius is distance( tempPoint - mPoints.last ) / 2.0
double minRadius = sqrt( QgsGeometryUtils::sqrDistance2D( mPoints.last(), QgsPointV2( mTemporaryEndPointX, mTemporaryEndPointY ) ) ) / 2.0;
mRadius = minRadius + minRadius / 10.0;
recalculateCircularString();
createRadiusSpinBox();
if ( mRadiusSpinBox )
{
mRadiusSpinBox->setMinimum( minRadius );
}
}
else
{
QgsPointV2 result;
if ( QgsGeometryUtils::segmentMidPoint( mPoints.last(), QgsPointV2( mTemporaryEndPointX, mTemporaryEndPointY ), result, mRadius, QgsPointV2( mapPoint.x(), mapPoint.y() ) ) )
{
mPoints.append( result );
mPoints.append( QgsPointV2( mTemporaryEndPointX, mTemporaryEndPointY ) );
}
mRadiusMode = false;
deleteRadiusSpinBox();
}
}
else
{
//can we get there?
}
}
else if ( e->button() == Qt::RightButton )
{
deactivate();
if ( mParentTool )
{
mParentTool->canvasReleaseEvent( e );
}
}
}
CPoint CConvert::GetWorldPointByGridPoint(CPoint gp){
CPoint mapPoint(GetMapPointByGridPoint(gp));
CPoint worldPoint(GetWorldPointByMapPoint(mapPoint));
return worldPoint;
}
mapPoint createMapPoint(unsigned i, unsigned j) {
mapPoint newMapPoint = mapPoint( rand()%10 );
newMapPoint.setCoordynates(i,j);
return newMapPoint;
}
CPoint CConvert::GetScreenPointByGridPoint(CPoint gp){//輸入格子座標得到螢幕座標
CPoint mapPoint(GetMapPointByGridPoint(gp));//格子座標轉成地圖座標
CPoint screenPoint(GetScreenPointByMapPoint(mapPoint));//地圖座標轉成螢幕座標
return screenPoint;
}