void CCJKShapeLine::DrawArrow(QPainter *painter, const QLineF &line) { CJK_D(CCJKShapeLine); double angle = ::acos(line.dx() / line.length()); if (line.dy() >= 0) angle = (CJKPi * 2) - angle; if (d->arrowBeginType != ArrowNone) { qreal arrowSize = d->pen.width() + d->arrowBeginSize; QPointF arrowP1; QPointF arrowP2; arrowP1 = line.p1() + QPointF(sin(angle + CJKPi / 3) * arrowSize, cos(angle + CJKPi / 3) * arrowSize); arrowP2 = line.p1() + QPointF(sin(angle + CJKPi - CJKPi / 3) * arrowSize, cos(angle + CJKPi - CJKPi / 3) * arrowSize); DrawArrow(painter, d->arrowBeginType, line.p1(), arrowP1, arrowP2, arrowSize); } if (d->arrowEndType != ArrowNone) { qreal arrowSize = d->pen.width() + d->arrowEndSize; QPointF arrowP1; QPointF arrowP2; arrowP1 = line.p2() - QPointF(sin(angle + CJKPi / 3) * arrowSize, cos(angle + CJKPi / 3) * arrowSize); arrowP2 = line.p2() - QPointF(sin(angle + CJKPi - CJKPi / 3) * arrowSize, cos(angle + CJKPi - CJKPi / 3) * arrowSize); DrawArrow(painter, d->arrowEndType, line.p2(), arrowP1, arrowP2, arrowSize); } }
void GEdge::adjust() { if (!source || !dest) return; QLineF * line = new QLineF (source->x(), source->y(), dest->x(), dest->y()); qreal length = line->length(); prepareGeometryChange(); if (length > qreal(20.)) { QPointF edgeOffset((line->dx() * 10) / length, (line->dy() * 10) / length); if (is_from_dummy_node) sourcePoint = line->p1(); else sourcePoint = line->p1() + edgeOffset; if (is_to_dummy_node) destPoint = line->p2(); else destPoint = line->p2() - edgeOffset; } else { sourcePoint = destPoint = line->p1(); } }
//---------------------------------------------------------------------------------------------- QPainterPath GraphEdgeView::shape() const { QPainterPath path;// = QGraphicsLineItem::shape(); QLineF normal = this->line().unitVector().normalVector(); qreal dx = normal.dx(); qreal dy = normal.dy(); QLineF myLine; myLine = this->line(); myLine.translate(dx * 4, dy * 4); path.lineTo(myLine.p1()); path.lineTo(myLine.p2()); myLine = this->line(); myLine.translate(-dx * 4,-dy * 4); path.lineTo(myLine.p2()); path.lineTo(myLine.p1()); path.closeSubpath(); path.addPolygon(m_arrowHead); return path; }
//TODO find better way calculate point. QPointF VToolShoulderPoint::FindPoint(const QPointF &p1Line, const QPointF &p2Line, const QPointF &pShoulder, const qreal &length) { QLineF line = QLineF(p1Line, p2Line); qreal toolLength = length; qreal dist = line.length(); if (dist>toolLength) { qDebug()<<"Correction of length in shoulder point tool. Parameter length too small."; toolLength = dist; } if (qFuzzyCompare(dist, toolLength)) { return line.p2(); } qreal step = 0.01; while (1) { line.setLength(line.length()+step); QLineF line2 = QLineF(pShoulder, line.p2()); if (line2.length()>=toolLength) { return line.p2(); } } }
void tst_QLine::testAngleTo_data() { QTest::addColumn<qreal>("xa1"); QTest::addColumn<qreal>("ya1"); QTest::addColumn<qreal>("xa2"); QTest::addColumn<qreal>("ya2"); QTest::addColumn<qreal>("xb1"); QTest::addColumn<qreal>("yb1"); QTest::addColumn<qreal>("xb2"); QTest::addColumn<qreal>("yb2"); QTest::addColumn<qreal>("angle"); QTest::newRow("parallel") << qreal(1.0) << qreal(1.0) << qreal(3.0) << qreal(4.0) << qreal(5.0) << qreal(6.0) << qreal(7.0) << qreal(9.0) << qreal(0.0); QTest::newRow("[4,4]-[4,0]") << qreal(1.0) << qreal(1.0) << qreal(5.0) << qreal(5.0) << qreal(0.0) << qreal(4.0) << qreal(3.0) << qreal(4.0) << qreal(45.0); QTest::newRow("[4,4]-[-4,0]") << qreal(1.0) << qreal(1.0) << qreal(5.0) << qreal(5.0) << qreal(3.0) << qreal(4.0) << qreal(0.0) << qreal(4.0) << qreal(225.0); for (int i = 0; i < 360; ++i) { const QLineF l = QLineF::fromPolar(1, i); QTest::newRow(("angle:" + QByteArray::number(i)).constData()) << qreal(0.0) << qreal(0.0) << qreal(1.0) << qreal(0.0) << qreal(0.0) << qreal(0.0) << l.p2().x() << l.p2().y() << qreal(i); } }
static double angle_to(QLineF line1, QLineF line2) { // found on code-guru forum- thread 137249 // calculate the angle between the line from p1 to p2 // and the line from p3 to p4 // // uses the theorem : // // given directional vectors v = ai + bj and w = ci + di // // then cos(angle) = (ac + bd) / ( |v| * |w| ) // double a = (float)line1.p1().x() - line1.p2().x(); double b = (float)line1.p1().y() - line1.p2().y(); double c = (float)line2.p1().x() - line2.p2().x(); double d = (float)line2.p1().y() - line2.p2().y(); double cos_angle, angle; double mag_v1 = sqrt(a * a + b * b); double mag_v2 = sqrt(c * c + d * d); cos_angle = (a * c + b * d) / (mag_v1 * mag_v2); angle = acos(cos_angle); angle = angle * 180.0 / PI; return angle; }
void CanvasMode_EditPolygon::updateFromItem() { if (updateFromItemBlocked()) return; PageItem *currItem = m_doc->m_Selection->itemAt(0); PageItem_RegularPolygon* item = currItem->asRegularPolygon(); centerPoint = QPointF(currItem->width() / 2.0, currItem->height() / 2.0); startPoint = currItem->PoLine.pointQF(0); endPoint = currItem->PoLine.pointQF(2); polyCorners = item->polyCorners; polyUseFactor = item->polyUseFactor; polyFactor = item->polyFactor; polyRotation = item->polyRotation; polyCurvature = item->polyCurvature; polyInnerRot = item->polyInnerRot; polyOuterCurvature = item->polyOuterCurvature; VectorDialog->polyWidget->blockSignals(true); VectorDialog->setValues(polyCorners, polyFactor, polyUseFactor, polyRotation, polyCurvature, polyInnerRot, polyOuterCurvature); VectorDialog->polyWidget->blockSignals(false); uint cx = polyUseFactor ? polyCorners * 2 : polyCorners; double seg = 360.0 / cx; double trueLength = sqrt(pow(sin(seg / 180.0 * M_PI) * (item->width() / 2.0), 2) + pow(cos(seg / 180.0 * M_PI) * (item->height() / 2.0) + (item->height()/2.0) - item->height(), 2)); QLineF innerLine = QLineF(endPoint, centerPoint); innerLine.setAngle(innerLine.angle() + 90); innerLine.setLength(trueLength * polyCurvature); innerCPoint = innerLine.p2(); QLineF outerLine = QLineF(startPoint, currItem->PoLine.pointQF(6)); outerLine.setLength(outerLine.length() * polyOuterCurvature); outerCPoint = outerLine.p2(); m_view->update(); }
void LenJonSim::addline(QLineF l,double dx) { double startx, starty, endx, endy, distance, step,x,y; QPointF *p1 = new QPointF(l.p1().x(),l.p1().y()); qDebug()<<p1->x()<<p1->y(); QPointF *p2 = new QPointF(l.p2().x(),l.p2().y()); startx = p1->x(); starty = p1->y(); endx = p2->x(); endy = p2->y(); distance = sqrt(pow(endx - startx,2)+pow(endy-starty,2)); step = (dx / distance); for(double i = 0; i <= 1; i+=step){ x = startx + (endx - startx) * i; y = starty + (endy - starty) * i; addParticle(x,y); nonMovableParticles++; } }
smReal getRectM(QLineF line) { return ( (line.p2().y() - line.p1().y()) / (line.p2().x() - line.p1().x()) ); }
bool CalculateLaylines::checkIntersection( const QLineF &line1, const QLineF &line2 ) { QString WKTLine1 = buildWKTLine( line1.p1(), line1.p2() ); QString WKTLine2 = buildWKTLine( line2.p1(), line2.p2() ); return checkGeometriesIntersection( WKTLine1, WKTLine2); }
std::vector<QPolygonF> GraphicsArrowItem::compose() { const qreal pi = 3.14; QLineF l = QLineF(line()); double arrowSize = (l.length() < 200.0) ? 10.0 : l.length()/20.0; //double arrowSize = 10.0; int dx = l.p2().x() - l.p1().x(); int dy = l.p2().y() - l.p1().y(); double angle = ::acos(dx/l.length()); if (dx >= 0 && dy > 0) angle = (pi * 2) - angle; else if (dx >= 0 && dy <= 0) { } else if (dx < 0 && dy > 0) angle = (pi * 2) - angle; else if (dx < 0 && dy <= 0) { } QPointF P1 = l.p1() + QPointF(::sin(angle+pi/3.0)*arrowSize, ::cos(angle+pi/3.0)*arrowSize); QPointF P2 = l.p1() + QPointF(::sin(angle+pi-pi/3.0)*arrowSize, ::cos(angle+pi-pi/3.0)*arrowSize); QPointF P3 = l.p2() + QPointF(::sin(angle-pi/3.0)*arrowSize, ::cos(angle-pi/3.0)*arrowSize); QPointF P4 = l.p2() + QPointF(::sin(angle+pi+pi/3.0)*arrowSize, ::cos(angle+pi+pi/3.0)*arrowSize); std::vector<QPolygonF> cont; //double off = 0.5*arrowSize*1.732; //QPointF offset(off, off); if (arrowHead == Start) { QPolygonF polybuilder; polybuilder.push_back(P1); polybuilder.push_back(l.p1()); polybuilder.push_back(P2); polybuilder.push_back(P1); cont.push_back(polybuilder); //QLineF newline(line()); //newline.setP1(newline.p1()-offset); } else if (arrowHead == End) { QPolygonF polybuilder; polybuilder.push_back(P3); polybuilder.push_back(l.p2()); polybuilder.push_back(P4); polybuilder.push_back(P3); cont.push_back(polybuilder); } else if (arrowHead == Both) { QPolygonF polybuilder; polybuilder.push_back(P1); polybuilder.push_back(l.p1()); polybuilder.push_back(P2); polybuilder.push_back(P1); QPolygonF polybuilder2; polybuilder2.push_back(P3); polybuilder2.push_back(l.p2()); polybuilder2.push_back(P4); polybuilder2.push_back(P3); cont.push_back(polybuilder); cont.push_back(polybuilder2); } return cont; }
/** * This method aligns both the \b "start" and \b "end" symbols to * the current angles of the \b "first" and the \b "last" line * segment respectively. */ void AssociationLine::alignSymbols() { const int sz = m_points.size(); if (sz < 2) { // cannot align if there is no line (one line = 2 points) return; } QList<QPolygonF> polygons = path().toSubpathPolygons(); if (m_startSymbol) { QPolygonF firstLine = polygons.first(); QLineF segment(firstLine.at(1), firstLine.at(0)); m_startSymbol->alignTo(segment); } if (m_endSymbol) { QPolygonF lastLine = polygons.last(); int maxIndex = lastLine.size(); QLineF segment(lastLine.at(maxIndex-2), lastLine.at(maxIndex-1)); m_endSymbol->alignTo(segment); } if (m_subsetSymbol) { QPointF p1 = path().pointAtPercent(0.4); QPointF p2 = path().pointAtPercent(0.5); QLineF segment(p1, p2); m_subsetSymbol->alignTo(segment); } if (m_collaborationLineItem) { const qreal distance = 10; const int midSegmentIndex = (sz - 1) / 2; const QPointF a = m_points.at(midSegmentIndex); const QPointF b = m_points.at(midSegmentIndex + 1); if (a == b) return; const QPointF p1 = (a + b) / 2.0; const QPointF p2 = (p1 + b) / 2.0; // Reversed line as we want normal in opposite direction. QLineF segment(p2, p1); QLineF normal = segment.normalVector().unitVector(); normal.setLength(distance); QLineF actualLine; actualLine.setP2(normal.p2()); normal.translate(p1 - p2); actualLine.setP1(normal.p2()); m_collaborationLineItem->setLine(actualLine); m_collaborationLineHead->alignTo(actualLine); } }
void UBEditableGraphicsLineItem::forcePointPosition(const QPointF& pos, PointPosition pointPosition, int amplitude) { QLineF line; int angles[] = {0, 45, 90, 135, 180, 225, 270, 315}; int size = sizeof(angles) / sizeof(int); if(pointPosition == Start) { line.setP1(pos); line.setP2(path().elementAt(1)); } else { line.setP1(path().elementAt(0)); line.setP2(pos); } int angle = line.angle(); const float PI_2 = 4*atan(1.f)*2; //for each angle we compute the left and right angle //then compute the distance between both for(int i = 0; i < size; i++) { //use the modulo operator to force the angle to stay in [0, 360] int leftAmplitude = (angles[i] + amplitude) % 360; int rightAmplitude = (angles[i] - amplitude + 360) % 360; int leftDist = (leftAmplitude - angle + 360) % 360; int rightDist = (angle - rightAmplitude + 360) % 360; if(leftDist <= amplitude || rightDist <= amplitude) { if(pointPosition == End) { line.setAngle(angles[i]); } else { //compute the position of p1 by hand float angleInRadians = angles[i]*PI_2/360; qreal l = line.length(); const qreal dx = -cos(angleInRadians)*l; const qreal dy = sin(angleInRadians)*l; line.setP1(QPointF(dx + line.p2().x(), dy + line.p2().y())); } break; } } QPainterPath p; p.moveTo(line.p1()); p.lineTo(line.p2()); setPath(p); mHandles.at(0)->setPos(line.p1().x(), line.p1().y()); mHandles.at(1)->setPos(line.p2().x(), line.p2().y()); }
bool CalculateLaylines::checkOffset( const QLineF &l1, const QLineF &l2, const float &offset ) { double diff = UwMath::getDistance(l1.p2(), l2.p2()); double scale = ( UwMath::getDistance(l1.p1(), l1.p2()) + UwMath::getDistance(l2.p1(), l2.p2()) ) / 2 ; double criteria = ( abs(scale) == 0 ) ? offset : offset * scale; return diff < criteria; }
QPainterPath GraphicsItemNode::shape() const { //If there is only one segment and it is shorter than half its //width, then the arrow head will not be made with 45 degree //angles, but rather whatever angle is made by going from the //end to the back corners (the final node will be a triangle). if (m_hasArrow && m_linePoints.size() == 2 && distance(getLast(), getSecondLast()) < m_width / 2.0) { QLineF backline = QLineF(getSecondLast(), getLast()).normalVector(); backline.setLength(m_width / 2.0); QPointF backVector = backline.p2() - backline.p1(); QPainterPath trianglePath; trianglePath.moveTo(getLast()); trianglePath.lineTo(getSecondLast() + backVector); trianglePath.lineTo(getSecondLast() - backVector); trianglePath.lineTo(getLast()); return trianglePath; } //Create a path that outlines the main node shape. QPainterPathStroker stroker; stroker.setWidth(m_width); stroker.setCapStyle(Qt::FlatCap); stroker.setJoinStyle(Qt::RoundJoin); QPainterPath mainNodePath = stroker.createStroke(path()); if (!m_hasArrow) return mainNodePath; //If the node has an arrow head, subtract the part of its //final segment to give it a pointy end. //NOTE: THIS APPROACH CAN LEAD TO WEIRD EFFECTS WHEN THE NODE'S //POINTY END OVERLAPS WITH ANOTHER PART OF THE NODE. PERHAPS THERE //IS A BETTER WAY TO MAKE ARROWHEADS? QLineF frontline = QLineF(getLast(), getSecondLast()).normalVector(); frontline.setLength(m_width / 2.0); QPointF frontVector = frontline.p2() - frontline.p1(); QLineF arrowheadLine(getLast(), getSecondLast()); arrowheadLine.setLength(1.42 * (m_width / 2.0)); arrowheadLine.setAngle(arrowheadLine.angle() + 45.0); QPointF arrow1 = arrowheadLine.p2(); arrowheadLine.setAngle(arrowheadLine.angle() - 90.0); QPointF arrow2 = arrowheadLine.p2(); QLineF lastSegmentLine(getSecondLast(), getLast()); lastSegmentLine.setLength(0.01); QPointF additionalForwardBit = lastSegmentLine.p2() - lastSegmentLine.p1(); QPainterPath subtractionPath; subtractionPath.moveTo(getLast()); subtractionPath.lineTo(arrow1); subtractionPath.lineTo(getLast() + frontVector + additionalForwardBit); subtractionPath.lineTo(getLast() - frontVector + additionalForwardBit); subtractionPath.lineTo(arrow2); subtractionPath.lineTo(getLast()); return mainNodePath.subtracted(subtractionPath); }
void QgsAnnotationItem::updateBalloon() { //first test if the point is in the frame. In that case we don't need a balloon. if ( !mMapPositionFixed || ( mOffsetFromReferencePoint.x() < 0 && ( mOffsetFromReferencePoint.x() + mFrameSize.width() ) > 0 && mOffsetFromReferencePoint.y() < 0 && ( mOffsetFromReferencePoint.y() + mFrameSize.height() ) > 0 ) ) { mBalloonSegment = -1; return; } //edge list QList<QLineF> segmentList; segmentList << segment( 0 ); segmentList << segment( 1 ); segmentList << segment( 2 ); segmentList << segment( 3 ); //find closest edge / closest edge point double minEdgeDist = DBL_MAX; int minEdgeIndex = -1; QLineF minEdge; QgsPoint minEdgePoint; QgsPoint origin( 0, 0 ); for ( int i = 0; i < 4; ++i ) { QLineF currentSegment = segmentList.at( i ); QgsPoint currentMinDistPoint; double currentMinDist = origin.sqrDistToSegment( currentSegment.x1(), currentSegment.y1(), currentSegment.x2(), currentSegment.y2(), currentMinDistPoint ); if ( currentMinDist < minEdgeDist ) { minEdgeIndex = i; minEdgePoint = currentMinDistPoint; minEdgeDist = currentMinDist; minEdge = currentSegment; } } if ( minEdgeIndex < 0 ) { return; } //make that configurable for the item double segmentPointWidth = 10; mBalloonSegment = minEdgeIndex; QPointF minEdgeEnd = minEdge.p2(); mBalloonSegmentPoint1 = QPointF( minEdgePoint.x(), minEdgePoint.y() ); if ( sqrt( minEdgePoint.sqrDist( minEdgeEnd.x(), minEdgeEnd.y() ) ) < segmentPointWidth ) { mBalloonSegmentPoint1 = pointOnLineWithDistance( minEdge.p2(), minEdge.p1(), segmentPointWidth ); } mBalloonSegmentPoint2 = pointOnLineWithDistance( mBalloonSegmentPoint1, minEdge.p2(), 10 ); }
QList<QPointF> QLogicCircuitShapeConnector::defaultConnector() const { QList<QPointF> points; QList<QPointF> sections; QLineF line(startPos(), endPos()); QLineF lineEnd; QLineF lineStart; line = QLineF(startPos(), endPos()); lineStart.setP1(startPos()); lineEnd.setP1(endPos()); switch(orientationAtStart()){ case QDiagramToolkit::East: if (line.dx() < 20){ lineStart.setP2(startPos() + QPointF(20, 0)); lineEnd.setP2(lineEnd.p1() - QPointF(20, 0)); sections << QPointF(lineStart.p2().x(), lineStart.p1().y() + line.dy() / 2) << QPointF(lineEnd.p2().x(), lineEnd.p2().y() - line.dy() / 2); } else { lineStart.setP2(lineStart.p1() + QPointF(line.dx() / 2 , 0)); lineEnd.setP2(QPointF(lineStart.p2().x(), lineEnd.p1().y())); } break; case QDiagramToolkit::West: if (line.dx() > -20){ lineStart.setP2(startPos() - QPointF(20, 0)); lineEnd.setP2(lineEnd.p1() + QPointF(20, 0)); sections << QPointF(lineStart.p2().x(), lineStart.p1().y() + line.dy() / 2) << QPointF(lineEnd.p2().x(), lineEnd.p2().y() - line.dy() / 2); } else { lineStart.setP2(lineStart.p1() + QPointF(line.dx() / 2 , 0)); lineEnd.setP2(QPointF(lineStart.p2().x(), lineEnd.p1().y())); } break; default: break; } points.append(lineStart.p1()); points.append(lineStart.p2()); QListIterator<QPointF> it(sections); while(it.hasNext()){ points.append(it.next()); } points.append(lineEnd.p2()); points.append(lineEnd.p1()); return points; }
void LineItem::setLine(const QLineF &line_) { setPos(line_.p1()); setViewRect(QRectF(0.0, 0.0, 0.0, sizeOfGrip().height())); if (!rect().isEmpty()) { rotateTowards(line().p2(), line_.p2()); } QRectF r = rect(); r.setSize(QSizeF(QLineF(line().p1(), line_.p2()).length(), r.height())); setViewRect(r); }
QPainterPath CopyFilterGUIConnectionItem::shape() const { QLineF l = line(); QPainterPath path; path.setFillRule(Qt::WindingFill); double length = line().length(); if (length > 0) { double offset = min(length, maxArrowSize); QLineF unit = l.unitVector(); QLineF normal = l.normalVector().unitVector(); QPointF v(unit.dx(), unit.dy()); QPointF n(normal.dx(), normal.dy()); QPointF p2 = l.p2(); QPointF p3 = p2 - v * offset + 0.5 * n * offset; QPointF p4 = p2 - v * offset - 0.5 * n * offset; QPolygonF polygon; polygon.append(p4); polygon.append(p3); polygon.append(p2); path.addPolygon(polygon); QPolygonF polygon2; QPointF p1 = l.p1(); polygon2.append(p2 + 3 * n); polygon2.append(p2 - 2 * n); polygon2.append(p1 - 2 * n); polygon2.append(p1 + 3 * n); path.addPolygon(polygon2); if (factor != 1.0 || isDecibel) { QFont font; font.setPixelSize(10); QPointF center = (l.p1() + l.p2()) / 2; QString text = QString("%1").arg(factor); if (isDecibel) text += " dB"; QFontMetrics fontMetrics(font); QSizeF size = fontMetrics.size(0, text); size += QSizeF(2, 0); QRectF rect; rect.setSize(size); rect.moveCenter(center); path.addRoundedRect(rect.adjusted(-0.5, 0.5, 0.5, 0.5), 3, 3); } } return path; }
bool Meshing::intersects(QPolygonF poly, QLineF line) { for(int i=0;i<poly.size()-1;i++){ QLineF l(poly.at(i) , poly.at(i+1)); QPointF p; if(l.p1()==line.p1() || l.p1()==line.p2() || l.p2()==line.p1() || l.p2()==line.p2()) continue; if(l.intersect(line,&p)==QLineF::BoundedIntersection){ return true; } } return false; }
bool GraphConnection::isPointing(const QRectF &rect) const { //check individual line segments for (int i = 1; i < _impl->points.size(); i++) { const QLineF line(_impl->points[i-1], _impl->points[i]); QLineF norm = line.normalVector(); norm.setLength(GraphConnectionSelectPad); if (QRectF(line.p2(), norm.p2()).intersects(rect)) return true; } //check arrow head return not _impl->arrowHead.intersected(rect).isEmpty(); }
/** * This method aligns *this* Symbol to the line being * passed. That is, it ensures that the axis of this symbol aligns * exactly with the \a "to" line passed. * * Also this item is moved such that the second end point of the * SymbolEndPoints for the current symbol *collides* with the second end * point of \a "to" line. */ void Symbol::alignTo(const QLineF& to) { QLineF toMapped(mapFromParent(to.p1()), mapFromParent(to.p2())); QLineF origAxis = Symbol::symbolTable[m_symbolType].axisLine; QLineF translatedAxis = origAxis.translated(toMapped.p2() - origAxis.p2()); qreal angle = translatedAxis.angleTo(toMapped); rotate(-angle); QPointF delta = to.p2() - mapToParent(symbolEndPoints().second); moveBy(delta.x(), delta.y()); }
QLineF Projection::project(const QLineF & Map) const { if (p->IsMercator) return QLineF(p->mercatorProject(Map.p1()), p->mercatorProject(Map.p2())); else if (p->IsLatLong) return QLineF(p->latlonProject(Map.p1()), p->latlonProject(Map.p2())); #ifndef _MOBILE else return QLineF(projProject(Map.p1()), projProject(Map.p2())); #endif return QLineF(); }
void CopyFilterGUIConnectionItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) { QLineF l = line(); if (!l.isNull()) { painter->setBrush(Qt::black); if (isSelected()) { painter->setBrush(Qt::blue); painter->setPen(QPen(Qt::blue, 1.5)); } painter->drawLine(line()); double length = line().length(); double offset = min(length, maxArrowSize); QLineF unit = l.unitVector(); QLineF normal = l.normalVector().unitVector(); QPointF v(unit.dx(), unit.dy()); QPointF n(normal.dx(), normal.dy()); QPointF p2 = l.p2(); QPointF p3 = p2 - v * offset + 0.5 * n * offset; QPointF p4 = p2 - v * offset - 0.5 * n * offset; QPolygonF polygon; polygon.append(p2); polygon.append(p3); polygon.append(p4); painter->drawPolygon(polygon); if (factor != 1.0 || isDecibel) { QFont font = painter->font(); font.setPixelSize(10); painter->setFont(font); QPointF center = (l.p1() + l.p2()) / 2; QString text = QString("%1").arg(factor); if (isDecibel) text += " dB"; QSizeF size = painter->fontMetrics().size(0, text); size += QSizeF(2, 0); QRectF rect; rect.setSize(size); rect.moveCenter(center); painter->setBrush(Qt::white); painter->drawRoundedRect(rect.adjusted(-0.5, 0.5, 0.5, 0.5), 3, 3); painter->drawText(rect, Qt::AlignCenter, text); } } }
bool Intersect(QLineF l1, QLineF l2) { //controllo che i punti siano sui semipiani opposti per entrambi i segmenti smReal ml1 = getRectM(l1); smReal ql1 = getRectQ(l1,ml1); if ( ( l2.p1().y() - ml1*l2.p1().x() - ql1 ) * (l2.p2().y() - ml1*l2.p2().x() - ql1) > 0) return false; smReal ml2 = getRectM(l2); smReal ql2 = getRectQ(l2,ml2); if ( ( l1.p1().y() - ml2*l1.p1().x() - ql2 ) * (l1.p2().y() - ml2*l1.p2().x() - ql2) > 0) return false; return true; }
/** * Draws a 2D line in 3D space by painting it with a z-coordinate of props.depth / 2.0 * * @param line The line to draw * @param pen The pen to use to draw the line * @param props The 3D properties to draw the line with * @return The drawn line, but with a width of 2px, as a polygon */ QPolygonF StockDiagram::Private::ThreeDPainter::drawTwoDLine( const QLineF &line, const QPen &pen, const ThreeDProperties &props ) { // Restores the painting properties when destroyed PainterSaver painterSaver( painter ); // The z coordinate to use (i.e., at what depth to draw the line) const qreal z = props.depth / 2.0; // Projec the 2D points of the line in 3D const QPointF deepP1 = projectPoint( line.p1(), z, props.angle ); const QPointF deepP2 = projectPoint( line.p2(), z, props.angle ); // The drawn line with a width of 2px QPolygonF threeDArea; // The offset of the line "borders" from the center to each side const QPointF offset( 0.0, 1.0 ); threeDArea << deepP1 - offset << deepP2 - offset << deepP1 + offset << deepP2 + offset << deepP1 - offset; painter->setPen( pen ); painter->drawLine( QLineF( deepP1, deepP2 ) ); return threeDArea; }
void QgsAnnotationItem::drawFrame( QPainter* p ) { QPen framePen( mFrameColor ); framePen.setWidthF( mFrameBorderWidth ); p->setPen( framePen ); QBrush frameBrush( mFrameBackgroundColor ); p->setBrush( frameBrush ); p->setRenderHint( QPainter::Antialiasing, true ); QPolygonF poly; for ( int i = 0; i < 4; ++i ) { QLineF currentSegment = segment( i ); poly << currentSegment.p1(); if ( i == mBalloonSegment && mMapPositionFixed ) { poly << mBalloonSegmentPoint1; poly << QPointF( 0, 0 ); poly << mBalloonSegmentPoint2; } poly << currentSegment.p2(); } p->drawPolygon( poly ); }
void QgsComposerItem::setItemRotation( double r, bool adjustPosition ) { if ( adjustPosition ) { //adjustPosition set, so shift the position of the item so that rotation occurs around item center //create a line from the centrepoint of the rect() to its origin, in scene coordinates QLineF refLine = QLineF( mapToScene( QPointF( rect().width() / 2.0, rect().height() / 2.0 ) ) , mapToScene( QPointF( 0 , 0 ) ) ); //rotate this line by the current rotation angle refLine.setAngle( refLine.angle() - r + mItemRotation ); //get new end point of line - this is the new item position QPointF rotatedReferencePoint = refLine.p2(); setPos( rotatedReferencePoint ); emit sizeChanged(); } if ( r > 360 ) { mItemRotation = (( int )r ) % 360; } else { mItemRotation = r; } setTransformOriginPoint( 0, 0 ); QGraphicsItem::setRotation( mItemRotation ); emit itemRotationChanged( r ); update(); }
void Projectile::setPath(QPointF source, QPointF target, Unit* enemy) { if (type_ >= PROJ_FIRE && type_ <= PROJ_FIRE_5) { QLineF distance = QLineF(source.x(), source.y(), target.x(), target.y()); switch(type_) { case PROJ_FIRE_2: distance.setLength(distance.length() * 90 / RADIUS_FLAME_2); break; case PROJ_FIRE_3: distance.setLength(distance.length() * 90 / RADIUS_FLAME_3); break; case PROJ_FIRE_4: distance.setLength(distance.length() * 90 / RADIUS_FLAME_4); break; case PROJ_FIRE_5: distance.setLength(distance.length() * 120 / RADIUS_FLAME_5); break; } end_ = new QPointF(distance.p2()); } else { end_ = new QPointF(target); } start_ = new QPointF(source); setEnemy(enemy); }
bool CalculateLaylines::checkIntersection( const QString &layerName, const QLineF &heading ) { QString WKTLine = buildWKTLine( heading.p1(), heading.p2() ); return checkIntersection( layerName, WKTLine); }