bool QtestGetYaw(){ //global yaw Quaternion a(Vec3(0,0,1), .155);//a(1,-2,3,-2); a.normalize(); Vec3 b(0,1,0); b.rotateBy(a); return fuzzyCompare(a.getYaw(), atan2(b[0], b[1])); }
void GameScreen::Private::detectScreenType() { //カタログ画面か if (fuzzyCompare(color(QRect(0, 0, 5, 5)), qRgb(45, 43, 43))) { setScreenType(CatalogScreen); return; } }
inline Point3D & Point3D::operator/= ( double divisor ) { assert(!fuzzyCompare(divisor, 0.0)); m_x /= divisor; m_y /= divisor; m_z /= divisor; return *this; }
void tst_QRay3D::projection() { QFETCH(QVector3D, point); QFETCH(QVector3D, direction); QFETCH(QVector3D, vector); QFETCH(QVector3D, expected); Qt3DRender::RayCasting::QRay3D line(point, direction); QVector3D result = line.project(vector); QVERIFY(fuzzyCompare(result, expected)); }
int fuzzyPointCompare(double leftx, double lefty, double rightx, double righty, int corner) { int result = 0; switch (corner) { case kMoreTopLeft: case kMoreTopRight: result = fuzzyCompare(righty, lefty); break; case kMoreBottomLeft: case kMoreBottomRight: result = fuzzyCompare(lefty, righty); break; case kMoreLeftBottom: case kMoreLeftTop: result = fuzzyCompare(leftx, rightx); break; case kMoreRightBottom: case kMoreRightTop: result = fuzzyCompare(rightx, rightx); break; } if (result == 0) { switch (corner) { case kMoreTopLeft: case kMoreTopRight: result = fuzzyCompare(leftx, rightx); break; case kMoreBottomLeft: case kMoreBottomRight: result = fuzzyCompare(rightx, leftx); break; case kMoreLeftBottom: case kMoreRightBottom: result = fuzzyCompare(lefty, righty); break; case kMoreLeftTop: case kMoreRightTop: result = fuzzyCompare(righty, lefty); break; } } return result; }
void PageViewportController::updateMinimumScaleToFit() { float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize)); if (!fuzzyCompare(minimumScale, m_minimumScaleToFit, 0.001)) { m_minimumScaleToFit = minimumScale; if (!m_hadUserInteraction && !hasSuspendedContent()) m_client->setContentsScale(toViewportScale(minimumScale), true /* isInitialScale */); m_client->didChangeViewportAttributes(); } }
void tst_QRay3D::transform() { QFETCH(QVector3D, point); QFETCH(QVector3D, direction); QMatrix4x4 m; m.translate(-1.0f, 2.5f, 5.0f); m.rotate(45.0f, 1.0f, 1.0f, 1.0f); m.scale(23.5f); Qt3DRender::RayCasting::QRay3D ray1(point, direction); Qt3DRender::RayCasting::QRay3D ray2(ray1); Qt3DRender::RayCasting::QRay3D ray3; ray1.transform(m); ray3 = ray2.transformed(m); QVERIFY(fuzzyCompare(ray1.origin(), ray3.origin())); QVERIFY(fuzzyCompare(ray1.direction(), ray3.direction())); QVERIFY(fuzzyCompare(ray1.origin(), m * point)); QVERIFY(fuzzyCompare(ray1.direction(), m.mapVector(direction))); }
bool FuzzyCompareTestHelper::fuzzyCompare(const QVector<double> &v1, const QVector<double> &v2, const double &epsilon) { if (v1.size() != v2.size()) { return false; } int i = 0; bool equal = true; while (i < v1.size() && equal) { equal = fuzzyCompare(v1.at(i), v2.at(i), epsilon); ++i; } return equal; }
bool PageViewportController::updateMinimumScaleToFit() { if (m_viewportSize.isEmpty() || m_contentsSize.isEmpty()) return false; float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize), devicePixelRatio()); if (minimumScale <= 0) return false; if (!fuzzyCompare(minimumScale, m_minimumScaleToFit, 0.001)) { m_minimumScaleToFit = minimumScale; if (!m_hadUserInteraction && !hasSuspendedContent()) applyScaleAfterRenderingContents(toViewportScale(minimumScale)); return true; } return false; }
int SplineTester::verifyNodesM( const QPolygonF &points, const QVector<double> &m ) const { const int n = points.size(); int numErrors = 0; double dx1 = points[1].x() - points[0].x(); QwtSplinePolynomial polynomial1 = QwtSplinePolynomial::fromSlopes( dx1, points[1].y() - points[0].y(), m[0], m[1] ); for ( int i = 1; i < n - 1; i++ ) { const double dx2 = points[i+1].x() - points[i].x(); const double dy2 = points[i+1].y() - points[i].y(); const QwtSplinePolynomial polynomial2 = QwtSplinePolynomial::fromSlopes( dx2, dy2, m[i], m[i+1] ); const double cv1 = polynomial1.curvatureAt( dx1 ); const double cv2 = polynomial2.curvatureAt( 0.0 ); if ( !fuzzyCompare( cv1, cv2 ) ) { #if DEBUG_ERRORS > 1 qDebug() << "invalid node condition (m)" << i << cv1 << cv1 << cv2 - cv1; #endif numErrors++; } dx1 = dx2; polynomial1 = polynomial2; } return numErrors; }
void PageViewportControllerClientQt::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea) { // This can only happen as a result of a user interaction. ASSERT(m_controller->hadUserInteraction()); if (!targetArea.isValid()) return; if (m_scrollChange.inProgress() || m_scaleChange.inProgress()) return; const float margin = 10; // We want at least a little bit of margin. QRectF endArea = targetArea.adjusted(-margin, -margin, margin, margin); const QRectF viewportRect = m_viewportItem->boundingRect(); qreal minViewportScale = qreal(2.5); qreal targetScale = viewportRect.size().width() / endArea.size().width(); targetScale = m_controller->innerBoundedViewportScale(qMin(minViewportScale, targetScale)); qreal currentScale = m_pageItem->contentsScale(); // We want to end up with the target area filling the whole width of the viewport (if possible), // and centralized vertically where the user requested zoom. Thus our hotspot is the center of // the targetArea x-wise and the requested zoom position, y-wise. const QPointF hotspot = QPointF(endArea.center().x(), touchPoint.y()); const QPointF viewportHotspot = viewportRect.center(); QPointF endPosition = hotspot - viewportHotspot / targetScale; endPosition = m_controller->clampViewportToContents(endPosition, targetScale); QRectF endVisibleContentRect(endPosition, viewportRect.size() / targetScale); enum { ZoomIn, ZoomBack, ZoomOut, NoZoom } zoomAction = ZoomIn; // Zoom back out if attempting to scale to the same current scale, or // attempting to continue scaling out from the inner most level. // Use fuzzy compare with a fixed error to be able to deal with largish differences due to pixel rounding. if (!m_scaleStack.isEmpty() && fuzzyCompare(targetScale, currentScale, 0.01)) { // If moving the viewport would expose more of the targetRect and move at least 40 pixels, update position but do not scale out. QRectF currentContentRect(m_viewportItem->mapRectToWebContent(viewportRect)); QRectF targetIntersection = endVisibleContentRect.intersected(targetArea); if (!currentContentRect.contains(targetIntersection) && (qAbs(endVisibleContentRect.top() - currentContentRect.top()) >= 40 || qAbs(endVisibleContentRect.left() - currentContentRect.left()) >= 40)) zoomAction = NoZoom; else zoomAction = ZoomBack; } else if (fuzzyCompare(targetScale, m_zoomOutScale, 0.01)) zoomAction = ZoomBack; else if (targetScale < currentScale) zoomAction = ZoomOut; switch (zoomAction) { case ZoomIn: m_scaleStack.append(ScaleStackItem(currentScale, m_viewportItem->contentPos().x() / currentScale)); m_zoomOutScale = targetScale; break; case ZoomBack: { if (m_scaleStack.isEmpty()) { targetScale = m_controller->minimumContentsScale(); endPosition.setY(hotspot.y() - viewportHotspot.y() / targetScale); endPosition.setX(0); m_zoomOutScale = 0; } else { ScaleStackItem lastScale = m_scaleStack.takeLast(); targetScale = lastScale.scale; // Recalculate endPosition and clamp it according to the new scale. endPosition.setY(hotspot.y() - viewportHotspot.y() / targetScale); endPosition.setX(lastScale.xPosition); } endPosition = m_controller->clampViewportToContents(endPosition, targetScale); endVisibleContentRect = QRectF(endPosition, viewportRect.size() / targetScale); break; } case ZoomOut: // Unstack all scale-levels deeper than the new level, so a zoom-back won't end up zooming in. while (!m_scaleStack.isEmpty() && m_scaleStack.last().scale >= targetScale) m_scaleStack.removeLast(); m_zoomOutScale = targetScale; break; case NoZoom: break; } animateContentRectVisible(endVisibleContentRect); }
bool QtestLength(){ Quaternion a; Quaternion b(1,2,3,4); return fuzzyCompare(a.length(), 1) && fuzzyCompare(b.length(), 5.477225); }
bool fuzzyQCompare(Quaternion a, Quaternion b, float diff = 0.0000005){ return fuzzyCompare(a[0], b[0], diff) && fuzzyCompare(a[1], b[1], diff) && fuzzyCompare(a[2], b[2], diff) && fuzzyCompare(a[3], b[3], diff) ; }
bool QtestDot(){ Quaternion a( 1, 0, 1, 2); Quaternion b(-1, 0, 2, 0); return fuzzyCompare(a.dot(b), 1); }
bool QtestNormalize(){ Quaternion a(1, 0, 1, 2); a.normalize(); return fuzzyCompare(a.length(), 1); }
bool FuzzyCompareTestHelper::fuzzyCompare(const Vector3 &v1, const Vector3 &v2, const double &epsilon) { return fuzzyCompare(v1.x, v2.x, epsilon) && fuzzyCompare(v1.y, v2.y, epsilon) && fuzzyCompare(v1.z, v2.z, epsilon); }
bool GameScreen::Private::isVisible(PartType partType) const { bool ret = false; switch (partType) { case HeaderPart: ret = fuzzyCompare(color(QRect(300, 3, 490, 4)), qRgb(42, 150, 163)); break; case Ship1Part: ret = fuzzyCompare(color(DETAIL_RECT_SHIP1_1), DETAIL_CHECK_COLOR1) && fuzzyCompare(color(DETAIL_RECT_SHIP1_2), DETAIL_CHECK_COLOR2); break; case Ship2Part: ret = fuzzyCompare(color(DETAIL_RECT_SHIP2_1), DETAIL_CHECK_COLOR1) && fuzzyCompare(color(DETAIL_RECT_SHIP2_2), DETAIL_CHECK_COLOR2); break; case Ship3Part: ret = fuzzyCompare(color(DETAIL_RECT_SHIP3_1), DETAIL_CHECK_COLOR1) && fuzzyCompare(color(DETAIL_RECT_SHIP3_2), DETAIL_CHECK_COLOR2); break; case Ship4Part: ret = fuzzyCompare(color(DETAIL_RECT_SHIP4_1), DETAIL_CHECK_COLOR1) && fuzzyCompare(color(DETAIL_RECT_SHIP4_2), DETAIL_CHECK_COLOR2); break; case Ship5Part: ret = fuzzyCompare(color(DETAIL_RECT_SHIP5_1), DETAIL_CHECK_COLOR1) && fuzzyCompare(color(DETAIL_RECT_SHIP5_2), DETAIL_CHECK_COLOR2); break; case Ship6Part: ret = fuzzyCompare(color(DETAIL_RECT_SHIP6_1), DETAIL_CHECK_COLOR1) && fuzzyCompare(color(DETAIL_RECT_SHIP6_2), DETAIL_CHECK_COLOR2); break; } return ret; }
bool SplineTester::verifyBoundary( const QwtSpline *spline, QwtSpline::BoundaryPosition pos, const QPolygonF &points, const QVector<double> &m ) const { const bool isC2 = dynamic_cast<const QwtSplineC2 *>( spline ); const int n = points.size(); const QwtSplinePolynomial polynomBegin = polynomialAt( 0, points, m ); const QwtSplinePolynomial polynomEnd = polynomialAt( n - 2, points, m ); bool ok = false; if ( spline->boundaryType() != QwtSpline::ConditionalBoundaries ) { // periodic or closed const double dx = points[n-1].x() - points[n-2].x(); ok = fuzzyCompare( polynomEnd.slopeAt( dx ), polynomBegin.slopeAt( 0.0 ) ); if ( ok && isC2 ) { ok = fuzzyCompare( polynomEnd.curvatureAt( dx ), polynomBegin.curvatureAt( 0.0 ) ); } return ok; } switch( spline->boundaryCondition( pos ) ) { case QwtSpline::Clamped1: { const double mt = ( pos == QwtSpline::AtBeginning ) ? m.first() : m.last(); ok = fuzzyCompare( mt, spline->boundaryValue( pos ) ); break; } case QwtSpline::Clamped2: { double cv; if ( pos == QwtSpline::AtBeginning ) { cv = polynomBegin.curvatureAt( 0.0 ); } else { const double dx = points[n-1].x() - points[n-2].x(); cv = polynomEnd.curvatureAt( dx ); } ok = fuzzyCompare( cv, spline->boundaryValue( pos ) ); break; } case QwtSpline::Clamped3: { double c3; if ( pos == QwtSpline::AtBeginning ) c3 = polynomBegin.c3; else c3 = polynomEnd.c3; ok = fuzzyCompare( 6.0 * c3, spline->boundaryValue( pos ) ); break; } case QwtSpline::LinearRunout: { const double ratio = spline->boundaryValue( pos ); if ( pos == QwtSpline::AtBeginning ) { const double s = ( points[1].y() - points[0].y() ) / ( points[1].x() - points[0].x() ); ok = fuzzyCompare( m[0], s - ratio * ( s - m[1] ) ); } else { const double s = ( points[n-1].y() - points[n-2].y() ) / ( points[n-1].x() - points[n-2].x() ); ok = fuzzyCompare( m[n-1], s - ratio * ( s - m[n-2] ) ); } break; } case QwtSplineC2::CubicRunout: { if ( pos == QwtSpline::AtBeginning ) { const QwtSplinePolynomial polynomBegin2 = polynomialAt( 1, points, m ); const double cv0 = polynomBegin.curvatureAt( 0.0 ); const double cv1 = polynomBegin2.curvatureAt( 0.0 ); const double cv2 = polynomBegin2.curvatureAt( points[2].x() - points[1].x() ); ok = fuzzyCompare( cv0, 2 * cv1 - cv2 ); } else { const QwtSplinePolynomial polynomEnd2 = polynomialAt( n - 3, points, m ); const double cv0 = polynomEnd.curvatureAt( points[n-1].x() - points[n-2].x() ); const double cv1 = polynomEnd.curvatureAt( 0.0 ); const double cv2 = polynomEnd2.curvatureAt( 0.0 ); ok = fuzzyCompare( cv0, 2 * cv1 - cv2 ); } break; } case QwtSplineC2::NotAKnot: { if ( pos == QwtSpline::AtBeginning ) { const QwtSplinePolynomial polynomBegin2 = polynomialAt( 1, points, m ); ok = fuzzyCompare( polynomBegin.c3, polynomBegin2.c3 ); } else { const QwtSplinePolynomial polynomEnd2 = polynomialAt( n - 3, points, m ); ok = fuzzyCompare( polynomEnd.c3, polynomEnd2.c3 ); } break; } } return ok; }
void QtViewportHandler::zoomToAreaGestureEnded(const QPointF& touchPoint, const QRectF& targetArea) { // This can only happen as a result of a user interaction. ASSERT(m_hadUserInteraction); if (!targetArea.isValid()) return; if (m_suspendCount) return; const int margin = 10; // We want at least a little bit of margin. QRectF endArea = itemRectFromCSS(targetArea.adjusted(-margin, -margin, margin, margin)); const QRectF viewportRect = m_viewportItem->boundingRect(); qreal targetCSSScale = viewportRect.size().width() / endArea.size().width(); qreal endCSSScale = innerBoundedCSSScale(qMin(targetCSSScale, qreal(2.5))); qreal endItemScale = itemScaleFromCSS(endCSSScale); qreal currentScale = m_pageItem->contentsScale(); // We want to end up with the target area filling the whole width of the viewport (if possible), // and centralized vertically where the user requested zoom. Thus our hotspot is the center of // the targetArea x-wise and the requested zoom position, y-wise. const QPointF hotspot = QPointF(endArea.center().x(), itemCoordFromCSS(touchPoint.y())); const QPointF viewportHotspot = viewportRect.center(); QPointF endPosition = hotspot * endCSSScale - viewportHotspot; QRectF endPosRange = computePosRangeForPageItemAtScale(endItemScale); endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight()); QRectF endVisibleContentRect(endPosition / endItemScale, viewportRect.size() / endItemScale); enum { ZoomIn, ZoomBack, ZoomOut, NoZoom } zoomAction = ZoomIn; if (!m_scaleStack.isEmpty()) { // Zoom back out if attempting to scale to the same current scale, or // attempting to continue scaling out from the inner most level. // Use fuzzy compare with a fixed error to be able to deal with largish differences due to pixel rounding. if (fuzzyCompare(endItemScale, currentScale, 0.01)) { // If moving the viewport would expose more of the targetRect and move at least 40 pixels, update position but do not scale out. QRectF currentContentRect(m_viewportItem->contentPos() / currentScale, viewportRect.size() / currentScale); QRectF targetIntersection = endVisibleContentRect.intersected(targetArea); if (!currentContentRect.contains(targetIntersection) && (qAbs(endVisibleContentRect.top() - currentContentRect.top()) >= 40 || qAbs(endVisibleContentRect.left() - currentContentRect.left()) >= 40)) zoomAction = NoZoom; else zoomAction = ZoomBack; } else if (fuzzyCompare(endItemScale, m_zoomOutScale, 0.01)) zoomAction = ZoomBack; else if (endItemScale < currentScale) zoomAction = ZoomOut; } switch (zoomAction) { case ZoomIn: m_scaleStack.append(ScaleStackItem(currentScale, m_viewportItem->contentPos().x())); m_zoomOutScale = endItemScale; break; case ZoomBack: { ScaleStackItem lastScale = m_scaleStack.takeLast(); endItemScale = lastScale.scale; endCSSScale = cssScaleFromItem(lastScale.scale); // Recalculate endPosition and bound it according to new scale. endPosition.setY(hotspot.y() * endCSSScale - viewportHotspot.y()); endPosition.setX(lastScale.xPosition); endPosRange = computePosRangeForPageItemAtScale(endItemScale); endPosition = boundPosition(endPosRange.topLeft(), endPosition, endPosRange.bottomRight()); endVisibleContentRect = QRectF(endPosition / endItemScale, viewportRect.size() / endItemScale); break; } case ZoomOut: // Unstack all scale-levels deeper than the new level, so a zoom-back won't end up zooming in. while (!m_scaleStack.isEmpty() && m_scaleStack.last().scale >= endItemScale) m_scaleStack.removeLast(); m_zoomOutScale = endItemScale; break; case NoZoom: break; } animatePageItemRectVisible(endVisibleContentRect); }
bool vec3cmp(Vec3& a, Vec3& b){ return fuzzyCompare(a[0],b[0]) && fuzzyCompare(a[1],b[1]) && fuzzyCompare(a[2],b[2]) ; }
inline const Point3D operator/(const Point3D &p, double divisor) { assert(fuzzyCompare(divisor, 0.0) == false); return Point3D(p.m_x / divisor, p.m_y / divisor, p.m_z / divisor); }
float voltageToDegrees(float value) { // convert volt to degree (change directionWind) // Note: The original documentation for the wind vane says 16 positions. Typically only recieve 8 positions. And 315 degrees was wrong. // For 5V, use 1.0. For 3.3V use 0.66 #define ADJUST3OR5 1.0 if (fuzzyCompare(3.84 * ADJUST3OR5 , value)) directionWind = 0.0; if (fuzzyCompare(1.98 * ADJUST3OR5, value)) directionWind = 22.5; if (fuzzyCompare(2.25 * ADJUST3OR5, value)) directionWind = 45; if (fuzzyCompare(0.41 * ADJUST3OR5, value)) directionWind = 67.5; if (fuzzyCompare(0.45 * ADJUST3OR5, value)) directionWind = 90.0; if (fuzzyCompare(0.32 * ADJUST3OR5, value)) directionWind = 112.5; if (fuzzyCompare(0.90 * ADJUST3OR5, value)) directionWind = 135.0; if (fuzzyCompare(0.62 * ADJUST3OR5, value)) directionWind = 157.5; if (fuzzyCompare(1.40 * ADJUST3OR5, value)) directionWind = 180; if (fuzzyCompare(1.19 * ADJUST3OR5, value)) directionWind = 202.5; if (fuzzyCompare(3.08 * ADJUST3OR5, value)) directionWind = 225; if (fuzzyCompare(2.93 * ADJUST3OR5, value)) directionWind = 247.5; if (fuzzyCompare(4.62 * ADJUST3OR5, value)) directionWind = 270.0; if (fuzzyCompare(4.04 * ADJUST3OR5, value)) directionWind = 292.5; if (fuzzyCompare(4.34 * ADJUST3OR5, value)) // chart in documentation wrong directionWind = 315.0; if (fuzzyCompare(3.43 * ADJUST3OR5, value)) directionWind = 337.5; }
float voltageToDegrees(float value, float defaultWindDirection) { // Note: The documenation for the wind vane says 16 positions. Only recieve 8 positions. And 370 degrees is wrong. if (fuzzyCompare(3.84, value)) return 0.0; if (fuzzyCompare(1.98, value)) return 22.5; if (fuzzyCompare(2.25, value)) return 45; if (fuzzyCompare(0.41, value)) return 67.5; if (fuzzyCompare(0.45, value)) return 90.0; if (fuzzyCompare(0.32, value)) return 112.5; if (fuzzyCompare(0.90, value)) return 135.0; if (fuzzyCompare(0.62, value)) return 157.5; if (fuzzyCompare(1.40, value)) return 180; if (fuzzyCompare(1.19, value)) return 202.5; if (fuzzyCompare(3.08, value)) return 225; if (fuzzyCompare(2.93, value)) return 247.5; if (fuzzyCompare(4.62, value)) return 270.0; if (fuzzyCompare(4.04, value)) return 292.5; if (fuzzyCompare(4.34, value)) // chart in documentation wrong return 315.0; if (fuzzyCompare(3.43, value)) return 337.5; Serial.print(" FAIL WIND DIRECTION"); return defaultWindDirection; // return previous value if not found }
void tst_QVectorArray::transform() { QMatrix4x4 m; m.translate(-1.0f, 2.5f, 5.0f); m.rotate(45.0f, 1.0f, 1.0f, 1.0f); m.scale(23.5f); QVector2DArray v2array; QVector3DArray v3array; QVector4DArray v4array; QVector2DArray v2arrayb; QVector3DArray v3arrayb; QVector4DArray v4arrayb; for (int index = 0; index < 64; ++index) { v2array.append(index * 4, index * 4 + 1); v3array.append(index * 4, index * 4 + 1, index * 4 + 2); v4array.append(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3); v2arrayb.append(index * 4, index * 4 + 1); v3arrayb.append(index * 4, index * 4 + 1, index * 4 + 2); v4arrayb.append(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3); } // Perform a simple in-place transform. v2array.transform(m); v3array.transform(m); v4array.transform(m); QCOMPARE(v2array.size(), 64); QCOMPARE(v3array.size(), 64); QCOMPARE(v4array.size(), 64); for (int index = 0; index < 64; ++index) { QVector2D v2(index * 4, index * 4 + 1); QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2); QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3); QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D())); QVERIFY(fuzzyCompare(v3array[index], m * v3)); QVERIFY(fuzzyCompare(v4array[index], m * v4)); } // Increase ref-count on an array and check that detach occurs. v2array = v2arrayb; v3array = v3arrayb; v4array = v4arrayb; QVERIFY(v2array.constData() == v2arrayb.constData()); QVERIFY(v3array.constData() == v3arrayb.constData()); QVERIFY(v4array.constData() == v4arrayb.constData()); v2array.transform(m); v3array.transform(m); v4array.transform(m); QVERIFY(v2array.constData() != v2arrayb.constData()); QVERIFY(v3array.constData() != v3arrayb.constData()); QVERIFY(v4array.constData() != v4arrayb.constData()); QCOMPARE(v2array.size(), 64); QCOMPARE(v3array.size(), 64); QCOMPARE(v4array.size(), 64); for (int index = 0; index < 64; ++index) { QVector2D v2(index * 4, index * 4 + 1); QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2); QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3); QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D())); QVERIFY(fuzzyCompare(v3array[index], m * v3)); QVERIFY(fuzzyCompare(v4array[index], m * v4)); QVERIFY(fuzzyCompare(v2arrayb[index], v2)); QVERIFY(fuzzyCompare(v3arrayb[index], v3)); QVERIFY(fuzzyCompare(v4arrayb[index], v4)); } // Perform the test again, with translated() this time. v2array = v2arrayb.transformed(m); v3array = v3arrayb.transformed(m); v4array = v4arrayb.transformed(m); QCOMPARE(v2array.size(), 64); QCOMPARE(v3array.size(), 64); QCOMPARE(v4array.size(), 64); for (int index = 0; index < 64; ++index) { QVector2D v2(index * 4, index * 4 + 1); QVector3D v3(index * 4, index * 4 + 1, index * 4 + 2); QVector4D v4(index * 4, index * 4 + 1, index * 4 + 2, index * 4 + 3); QVERIFY(fuzzyCompare(v2array[index], (m * QVector3D(v2)).toVector2D())); QVERIFY(fuzzyCompare(v3array[index], m * v3)); QVERIFY(fuzzyCompare(v4array[index], m * v4)); QVERIFY(fuzzyCompare(v2arrayb[index], v2)); QVERIFY(fuzzyCompare(v3arrayb[index], v3)); QVERIFY(fuzzyCompare(v4arrayb[index], v4)); } }
bool FuzzyCompareTestHelper::fuzzyCompare(const QVector3D &v1, const QVector3D &v2, const double &epsilon) { return fuzzyCompare(v1.x(), v2.x(), epsilon) && fuzzyCompare(v1.y(), v2.y(), epsilon) && fuzzyCompare(v1.z(), v2.z(), epsilon); }