void RGraphicsView::setOffset(const RVector& offset, bool regen) { RVector o = offset; if (!o.isSane()) { o = RVector(0,0); } // 20111024: avoid overflows with weird behaviour when using track pad: if (RSettings::getLimitZoomAndScroll()) { if (offset.x < -1.0e8 || offset.x > 1.0e8) { o.x = 0.0; } if (offset.y < -1.0e8 || offset.y > 1.0e8) { o.y = 0.0; } } this->offset = o; // offset in pixels: //RVector ov(RMath::mround(offset.x*factor), RMath::mround(offset.y*factor)); ////ov = RVector(RMath::mround(ov.x), RMath::mround(ov.y)); ////this->offset = mapFromView(ov); //this->offset = RVector(ov.x/factor, ov.y/factor); if (regen) { regenerate(); if (scene!=NULL) { // notify actions about zoom change: scene->getDocumentInterface().zoomChangeEvent(*this); } } //viewportChangeEvent(); }
/** * \return Shape of segment at given position. */ QSharedPointer<RShape> RPolyline::getSegmentAt(int i) const { if (i<0 || i>=vertices.size() || i>=bulges.size()) { qWarning() << "RPolyline::getSegmentAt(" << i << "): i out of range"; return QSharedPointer<RShape>(); } RVector p1 = vertices.at(i); RVector p2 = vertices.at((i+1) % vertices.size()); if (RPolyline::isStraight(bulges.at(i))) { return QSharedPointer<RShape>(new RLine(p1, p2)); } else { double bulge = bulges.at(i); bool reversed = bulge<0.0; double alpha = atan(bulge)*4.0; if (fabs(alpha) > 2*M_PI-RS::AngleTolerance) { return QSharedPointer<RShape>(); } double radius; RVector center; RVector middle; double dist; double angle; middle = (p1+p2)/2.0; dist = p1.getDistanceTo(p2)/2.0; angle = p1.getAngleTo(p2); // alpha can't be 0.0 at this point radius = fabs(dist / sin(alpha/2.0)); double rootTerm = fabs(radius*radius - dist*dist); double h = sqrt(rootTerm); if (bulge>0.0) { angle+=M_PI/2.0; } else { angle-=M_PI/2.0; } if (fabs(alpha)>M_PI) { h*=-1.0; } center.setPolar(h, angle); center+=middle; double a1; double a2; a1 = center.getAngleTo(p1); a2 = center.getAngleTo(p2); return QSharedPointer<RShape>(new RArc(center, radius, a1, a2, reversed)); } }
RCircle RCircle::createFrom3Points(const RVector& p1, const RVector& p2, const RVector& p3) { // intersection of two middle lines // middle points between first two points: RVector mp1 = RVector::getAverage(p1, p2); double a1 = p1.getAngleTo(p2) + M_PI / 2.0; // direction from middle point to center: RVector dir1 = RVector::createPolar(1.0, a1); // middle points between last two points: RVector mp2 = RVector::getAverage(p2, p3); double a2 = p2.getAngleTo(p3) + M_PI / 2.0; // direction from middle point to center: RVector dir2 = RVector::createPolar(1.0, a2); RLine midLine1(mp1, mp1 + dir1); RLine midLine2(mp2, mp2 + dir2); QList<RVector> ips = midLine1.getIntersectionPoints(midLine2, false); if (ips.length()!=1) { return RCircle(); } RVector center = ips[0]; double radius = center.getDistanceTo(p3); // double angle1 = center.getAngleTo(p1); // double angle2 = center.getAngleTo(p3); // bool reversed = RMath::isAngleBetween(center.getAngleTo(p2), // angle1, angle2, true); return RCircle(center, radius); }
bool RPolylineData::moveReferencePoint(const RVector& referencePoint, const RVector& targetPoint) { bool ret = false; QList<RVector>::iterator it; for (it=vertices.begin(); it!=vertices.end(); ++it) { if (referencePoint.equalsFuzzy(*it)) { (*it) = targetPoint; ret = true; } } for (int i=0; i<countSegments(); i++) { if (isArcSegmentAt(i)) { QSharedPointer<RArc> arc = getSegmentAt(i).dynamicCast<RArc>(); if (!arc.isNull()) { if (referencePoint.equalsFuzzy(arc->getMiddlePoint())) { RArc a = RArc::createFrom3Points(arc->getStartPoint(), targetPoint, arc->getEndPoint()); setBulgeAt(i, a.getBulge()); ret = true; } } } } return ret; }
void RDimDiametricData::updateTextData() const { initTextData(); double dimgap = getDimgap(); if (RMath::isNaN(defaultAngle)) { // updates default angle: getShapes(); } // move text to the side if appropriate: if (!hasCustomTextPosition()) { //RBox bbox = textData.getBoundingBox(); if (!RMath::isNaN(dimLineLength) && textData.getWidth()>dimLineLength) { RVector distH; distH.setPolar(textData.getWidth()/2.0 +dimLineLength/2.0+dimgap, defaultAngle); textPositionSide = textPositionCenter; textPositionSide+=distH; } else { textPositionSide = RVector::invalid; } } textData.rotate(defaultAngle, RVector(0,0)); textData.move(getTextPosition()); }
/** * \return Point on this shape that is closest to p. Based on getVectorTo. */ RVector RShape::getClosestPointOnShape(const RVector& p, bool limited) const { RVector dv = getVectorTo(p, limited); if (!dv.isValid()) { return RVector::invalid; } return p - dv; }
QList<RVector> RShape::getIntersectionPointsLT(const RLine& line1, const RTriangle& triangle2, bool limited) { QList<RVector> res; RVector normal = triangle2.getNormal(); if (normal.getMagnitude() < 1.0e-12) { return res; } if (line1.getLength() < 1.0e-12) { return res; } double t = RVector::getDotProduct(normal, triangle2.getCorner(2) - line1.getStartPoint()) / RVector::getDotProduct(normal, (line1.getEndPoint() - line1.getStartPoint())); // check if intersection point is on the line: if (limited && (t < 0.0 || t > 1.0)) { return res; } // intersection point: RVector ip = line1.getStartPoint() + (line1.getEndPoint() - line1.getStartPoint()) * t; // check if intersection point is inside the triangle: if (!limited || triangle2.isPointInTriangle(ip)) { res.push_back(ip); } return res; }
/** * \return Shortest distance from this shape to the given point. * Based on \ref getVectorTo. */ double RShape::getDistanceTo(const RVector& point, bool limited) const { RVector v = getVectorTo(point, limited); if (v.isValid()) { return v.getMagnitude(); } return RNANDOUBLE; }
// previously: getEllipseAngle double REllipse::getParamTo(const RVector& pos) const { RVector m = pos; m.rotate(-majorPoint.getAngle(), center); RVector v = m-center; v.scale(RVector(1.0, 1.0/ratio)); return v.getAngle(); }
RBox REllipse::getBoundingBox() const { double radius1 = getMajorRadius(); double radius2 = getMinorRadius(); double angle = getAngle(); double a1 = ((!isReversed()) ? startParam : endParam); double a2 = ((!isReversed()) ? endParam : startParam); RVector startPoint = getStartPoint(); RVector endPoint = getEndPoint(); double minX = qMin(startPoint.x, endPoint.x); double minY = qMin(startPoint.y, endPoint.y); double maxX = qMax(startPoint.x, endPoint.x); double maxY = qMax(startPoint.y, endPoint.y); // kind of a brute force. TODO: exact calculation RVector vp; double a = a1; do { vp.set(center.x + radius1 * cos(a), center.y + radius2 * sin(a)); vp.rotate(angle, center); minX = qMin(minX, vp.x); minY = qMin(minY, vp.y); maxX = qMax(maxX, vp.x); maxY = qMax(maxY, vp.y); a += 0.03; } while (RMath::isAngleBetween(a, a1, a2, false) && a<4*M_PI); return RBox(RVector(minX,minY), RVector(maxX,maxY)); }
bool RDimensionData::moveReferencePoint(const RVector& referencePoint, const RVector& targetPoint) { if (referencePoint.equalsFuzzy(definitionPoint)) { definitionPoint = targetPoint; autoTextPos = true; update(); return true; } if (textPositionSide.isValid()) { if (referencePoint.equalsFuzzy(textPositionSide)) { textPositionCenter = targetPoint; textPositionSide = RVector::invalid; autoTextPos = false; update(); return true; } } if (referencePoint.equalsFuzzy(textPositionCenter)) { textPositionCenter = targetPoint; autoTextPos = false; update(); return true; } return false; }
void RCPBody::applyImpulse(RVector const & impulse) { if (mBody) { cpBodyApplyImpulseAtWorldPoint(mBody, cpv(impulse.x(), impulse.y()), cpBodyLocalToWorld(mBody, cpBodyGetCenterOfGravity(mBody))); } }
BOOST_FIXTURE_TEST_CASE( ser_vs_unser , F) { assert(count > 0); p->save(filename); RegistryCache* up = new RegistryCache(); up->from_file(filename); BOOST_CHECK_EQUAL(up->size(), count); Registry left = createReg(1); RVector* v = p->get(left.name); BOOST_CHECK_EQUAL(v->size(), 1); Registry right = v->front(); BOOST_CHECK_EQUAL(left.name, right.name); BOOST_CHECK_EQUAL(left.host, right.host); BOOST_CHECK_EQUAL(left.port, right.port); left = createReg(count - 1); BOOST_CHECK_EQUAL(v->size(), 1); right = v->front(); BOOST_CHECK_EQUAL(left.name, right.name); BOOST_CHECK_EQUAL(left.host, right.host); BOOST_CHECK_EQUAL(left.port, right.port); delete up; up = NULL; teardown(); }
RArc RArc::createTangential(const RVector& startPoint, const RVector& pos, double direction, double radius) { RArc arc; arc.radius = radius; // orthogonal to base entity: RVector ortho; ortho.setPolar(radius, direction + M_PI/2.0); // two possible center points for arc: RVector center1 = startPoint + ortho; RVector center2 = startPoint - ortho; if (center1.getDistanceTo(pos) < center2.getDistanceTo(pos)) { arc.center = center1; } else { arc.center = center2; } // angles: arc.startAngle = arc.center.getAngleTo(startPoint); arc.endAngle = arc.center.getAngleTo(pos); // handle arc direction: arc.reversed = false; double diff = RMath::getNormalizedAngle(arc.getDirection1() - direction); if (fabs(diff-M_PI) < 1.0e-1) { arc.reversed = true; } return arc; }
/** * \return List of RLines describing this spline. */ QList<QSharedPointer<RShape> > RSpline::getExploded(int segments) const { if (!exploded.isEmpty() && segments==-1) { return exploded; } //qDebug() << "RSpline::getExploded: segments: " << segments; //RDebug::printBacktrace("getExploded: "); //##boundingBox = RBox(); updateInternal(); exploded.clear(); if (!isValid()) { //qWarning() << "RSpline::getExploded: invalid spline"; return exploded; } if (segments==-1) { segments = 8; } double tMin = getTMin(); double tMax = getTMax(); double step = getTDelta() / (controlPoints.size() * segments); RVector p1; RVector prev = RVector::invalid; for (double t = tMin; t<tMax+(step/2.0); t+=step) { double tc = qMin(t, tMax); p1 = getPointAt(tc); if (RMath::isNaN(p1.x) || RMath::isNaN(p1.y)) { continue; } if (prev.isValid()) { RLine* line = new RLine(prev, p1); exploded.append(QSharedPointer<RShape>(line)); } prev = p1; //##boundingBox.growToInclude(p1); } p1 = getEndPoint(); if (!RMath::isNaN(p1.x) && !RMath::isNaN(p1.y)) { if (prev.isValid()) { RLine* line = new RLine(prev, p1); // prevent zero length line at the end: if (line->getLength()>1.0e-4) { exploded.append(QSharedPointer<RShape>(line)); } } } return exploded; }
QList<RVector> RArc::getPointsWithDistanceToEnd(double distance, RS::From from) const { QList<RVector> ret; if (radius<RS::PointTolerance) { return ret; } double a1; double a2; RVector p; double aDist = distance / radius; if (isReversed()) { a1 = getStartAngle() - aDist; a2 = getEndAngle() + aDist; } else { a1 = getStartAngle() + aDist; a2 = getEndAngle() - aDist; } if (from==RS::FromStart || from==RS::FromAny) { p.setPolar(radius, a1); p += center; ret.append(p); } if (from==RS::FromEnd || from==RS::FromAny) { p.setPolar(radius, a2); p += center; ret.append(p); } return ret; }
bool RCircle::move(const RVector& offset) { if (!offset.isValid() || offset.getMagnitude() < RS::PointTolerance) { return false; } center += offset; return true; }
void RB2DBody::setPosition(RVector const & pos) { mPosition.set(pos.x()/PTM_RATIO, pos.y()/PTM_RATIO, 0); if (mBody) { mBody->SetTransform(b2Vec2(mPosition.x()/PTM_RATIO, mPosition.y()/PTM_RATIO), mBody->GetAngle()); } }
void REllipse::moveEndPoint(const RVector& pos, bool changeAngleOnly) { if (changeAngleOnly) { endParam = getParamTo(pos); } else { RVector sp = getStartPoint(); double distOri = sp.getDistanceTo(getEndPoint()); double angleOri = sp.getAngleTo(getEndPoint()); if (distOri<RS::PointTolerance) { return; } double distNew = sp.getDistanceTo(pos); double angleNew = sp.getAngleTo(pos); double factor = distNew / distOri; if (factor<RS::PointTolerance) { return; } double angleDelta = angleNew - angleOri; center.scale(factor, sp); center.rotate(angleDelta, sp); majorPoint.scale(factor); majorPoint.rotate(angleDelta); } }
/** * Creates an arc from its startpoint, endpoint and bulge (= tan(angle/4)). */ RArc RArc::createFrom2PBulge(const RVector& startPoint, const RVector& endPoint, double bulge) { RArc arc; arc.reversed = (bulge < 0.0); double alpha = atan(bulge) * 4.0; RVector middle = (startPoint + endPoint) / 2.0; double dist = startPoint.getDistanceTo(endPoint) / 2.0; // alpha can't be 0.0 at this point arc.radius = fabs(dist / sin(alpha / 2.0)); double wu = fabs(RMath::pow(arc.radius, 2.0) - RMath::pow(dist, 2.0)); double h = sqrt(wu); double angle = startPoint.getAngleTo(endPoint); if (bulge > 0.0) { angle += M_PI / 2.0; } else { angle -= M_PI / 2.0; } if (fabs(alpha) > M_PI) { h *= -1.0; } arc.center.setPolar(h, angle); arc.center += middle; arc.startAngle = arc.center.getAngleTo(startPoint); arc.endAngle = arc.center.getAngleTo(endPoint); return arc; }
bool REllipse::contains(const RVector& p) const { RVector pt = p; pt.move(-center); pt.rotate(-getAngle()); double rx = getMajorRadius(); double ry = getMinorRadius(); return (pt.x*pt.x) / (rx*rx) + (pt.y*pt.y) / (ry*ry) <= 1.0; }
void HarmonicFunction::setCoefficients( const RVector & coeff ){ nHarmonic_ = coeff.size() / 2; if ( ( (double)coeff.size() / 2.0 - nHarmonic_ ) > TOLERANCE ){ throwError( 1, WHERE_AM_I + " coefficients size is uneven" + str( coeff.size() ) ); } coeff_ = coeff; }
RVector DC1dModelling::pot1d(const RVector & R, const RVector & rho, const RVector & thk) { RVector z0(R.size()); double rabs; for (size_t i = 0; i < R.size(); i++) { rabs = std::fabs(R[i]); z0[i] = sum(myw_ * kern1d(myx_ / rabs, rho, thk) * 2.0) / rabs; } return z0; }
void RSpriteItem::onSingleTap(int x, int y) { RVector worldPoint = RTransUtils::worldSpacePoint(mProjection, mCamera, mTransformation, RVector(x, y)); mIsPressed = false; if (worldPoint.x() > mX && worldPoint.x() < mX + mWidth && worldPoint.y() > mY && worldPoint.y() < mY + mHeight) { onClick(x, y); } }
/** * \return The shortest distance from this entity to the given point. */ double REntityData::getDistanceTo(const RVector& point, bool limited, double range, bool draft) const { Q_UNUSED(range); Q_UNUSED(draft); RVector v = getVectorTo(point, limited); if (v.isValid()) { return v.getMagnitude(); } return RNANDOUBLE; }
RVector RCircle::getVectorTo(const RVector& point, bool /*limited*/) const { RVector v = point - center; // point is at the center of the circle, infinite solutions: if (v.getMagnitude()<RS::PointTolerance) { return RVector::invalid; } return RVector::createPolar(v.getMagnitude() - radius, v.getAngle()); }
RVector RArc::getVectorTo(const RVector& point, bool limited) const { double angle = center.getAngleTo(point); if (limited && !RMath::isAngleBetween(angle, startAngle, endAngle, reversed)) { return RVector::invalid; } RVector v = point - center; return RVector::createPolar(v.getMagnitude() - radius, v.getAngle()); }
BOOST_FIXTURE_TEST_CASE( unserialize , F) { setup(); const string content = "[{\"name\":\"servier0\",\"host\":\"localhost\",\"port\":0,\"weight\":3600 },{\"name\":\"servier1\",\"host\":\"localhost\",\"port\":1,\"weight\":3600 }]"; // vector<Registry> RVector v = Registry::unserialize(content); BOOST_CHECK_EQUAL(v.size(), 2); }
void GaussLegendre(double x1, double x2, uint n, RVector & x, RVector & w){ // taken from matlab-code (Thomas Guenther) // function [x, w] = gauleg(x1, x2, n) // Given the lower and upper limits of integration x1 and x2 and given n, // this routine returns arrays x(1..n) and w(1..n) of length n, // containing the abscissas and weights of the Gauss-Legendre // n-point quadrature formula. // For a description of the following routines see // Numerical Recipes, Press et al. if (x.size() != n) x.resize(n); if (w.size() != n) w.resize(n); double epsilon = 3.0e-6; double m = (n + 1.0) / 2.0 ; double xm = 0.5 * (x2 + x1); double xl = 0.5 * (x2 - x1); double z = 0.0, z1 = 0.0, p1 = 0.0, p2 = 0.0, p3 = 0.0, pp = 0.0; for (int i = 1; i <= m; i ++){ z = std::cos(PI * (i - 0.25) / (n + 0.5)); // Starting with the above approximation to the ith root, we enter // the main loop of refinements by Newton's method z1 = z + 2.0 * epsilon; while (std::fabs(z - z1) > epsilon){ p1 = 1.0; p2 = 0.0; for (size_t j = 1; j <= n; j ++){ p3 = p2; p2 = p1; p1 = ((2.0 * j - 1.0) * z * p2 - (j - 1.0) * p3) / (double)j; } // p1 is now the desired Legendre polynomial. We next compute pp, // its derivative, by a standard relation involving also p2, the // polynomial of one lower order pp = (double)n * (z * p1 - p2) / (z * z - 1.0); z1 = z; z = z1 - p1 / pp; // Newtons method } // Scale the root to the desired interval, and put in its // symmetric counterpart x[ i - 1 ] = xm - xl * z; x[ n - i ] = xm + xl * z; // x[ n +1 - i ] = xm + xl * z; //Compute the weight and ist symmetric counterpart w[ i - 1 ] = 2.0 * xl / ((1.0 -z * z) *pp *pp); w[ n - i ] = w[ i - 1 ]; // w[ n + 1 - i ] = w[ i - 1 ]; } }
RVector response( const RVector & model ) { //! extract slowness from model and call old function RVector slowness( model, 0, model.size() - shots_.size() ); RVector offsets( model, model.size() - shots_.size(), model.size() ); RVector resp = TravelTimeDijkstraModelling::response( slowness ); //! normal response RVector shotpos = dataContainer_->get( "s" ); for ( size_t i = 0; i < resp.size() ; i++ ){ resp[ i ] += offsets[ shotMap_[ shotpos[ i ] ] ]; } return resp; }