void BlurPicker::setIndex(qreal index) { m_index = index; qreal baseline = 0; for (int i = 0; i < m_icons.count(); ++i) { ImageItem *icon = m_icons[i]; qreal a = ((i + m_index) * 2 * M_PI) / m_icons.count(); qreal xs = 380 * qSin(a); qreal ys = 230 * qCos(a); QPointF pos(xs, ys); // pos = QTransform::scale(0,0.2).map(pos); // pos = QTransform().rotate(-20).map(pos); pos = QTransform().rotate(-5).map(pos); pos -= QPointF(40, 40); // pos -= QPoint(10,10); icon->setPos(pos); baseline = qMax(baseline, ys); static_cast<BlurEffect *>(icon->graphicsEffect())->setBaseLine(baseline); } scene()->update(); }
static void qwtDrawStyle1Needle( QPainter *painter, const QPalette &palette, QPalette::ColorGroup colorGroup, double length ) { const double r[] = { 0.4, 0.3, 1, 0.8, 1, 0.3, 0.4 }; const double a[] = { -45, -20, -15, 0, 15, 20, 45 }; QPainterPath path; for ( int i = 0; i < 7; i++ ) { const double angle = a[i] / 180.0 * M_PI; const double radius = r[i] * length; const double x = radius * qCos( angle ); const double y = radius * qSin( angle ); path.lineTo( x, -y ); } painter->setPen( Qt::NoPen ); painter->setBrush( palette.brush( colorGroup, QPalette::Light ) ); painter->drawPath( path ); }
QMatrix &QMatrix::rotate(qreal a) { qreal sina = 0; qreal cosa = 0; if (a == 90. || a == -270.) sina = 1.; else if (a == 270. || a == -90.) sina = -1.; else if (a == 180.) cosa = -1.; else{ qreal b = deg2rad*a; // convert to radians sina = qSin(b); // fast and convenient cosa = qCos(b); } qreal tm11 = cosa*_m11 + sina*_m21; qreal tm12 = cosa*_m12 + sina*_m22; qreal tm21 = -sina*_m11 + cosa*_m21; qreal tm22 = -sina*_m12 + cosa*_m22; _m11 = tm11; _m12 = tm12; _m21 = tm21; _m22 = tm22; return *this; }
static QPointF calcRadialPos ( const QStyleOptionSlider *dial, qreal offset ) { const int width = dial->rect.width(); const int height = dial->rect.height(); const int r = qMin(width, height) / 2; const int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition); qreal a = 0; if (dial->maximum == dial->minimum) a = Q_PI / 2; else if (dial->dialWrapping) a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI / (dial->maximum - dial->minimum); else a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI / (dial->maximum - dial->minimum)) / 6; qreal xc = width / 2.0; qreal yc = height / 2.0; qreal len = r - calcBigLineSize(r) - 3; qreal back = offset * len; QPointF pos(QPointF(xc + back * qCos(a), yc - back * qSin(a))); return pos; }
QPainterPath GraphicsEdgeItem::shape() const { QPainterPath path; QPointF source = mEdgeData->sourceNode()->sceneCoor(); QPointF dest = mEdgeData->destNode()->sceneCoor(); QLineF line(source, dest); qreal angle = line.angle(); if(angle>=180) angle -= 180; qreal dx = mWidth/2.0*qSin(angle); qreal dy = mWidth/2.0*qCos(angle); QPointF p1(source.x()-dx,source.y()+dy); QPointF p2(source.x()+dx,source.y()-dy); QPointF p3(dest.x()+dx,dest.y()-dy); QPointF p4(dest.x()-dx,dest.y()+dy); path.moveTo(p1); path.lineTo(p2); path.lineTo(p3); path.lineTo(p4); path.lineTo(p1); return path; }
Point Toolbox::arcCenter(const Point& p1, const Point& p2, const Angle& a) noexcept { if (a == 0) { // there is no arc center...just return the middle of start- and endpoint return (p1 + p2) / 2; } else { // http://math.stackexchange.com/questions/27535/how-to-find-center-of-an-arc-given-start-point-end-point-radius-and-arc-direc qreal x0 = p1.getX().toMm(); qreal y0 = p1.getY().toMm(); qreal x1 = p2.getX().toMm(); qreal y1 = p2.getY().toMm(); qreal angle = a.mappedTo180deg().toRad(); qreal angleSgn = (angle >= 0) ? 1 : -1; qreal d = qSqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)); qreal r = d / (2 * qSin(angle / 2)); qreal h = qSqrt(r * r - d * d / 4); qreal u = (x1 - x0) / d; qreal v = (y1 - y0) / d; qreal a = ((x0 + x1) / 2) - h * v * angleSgn; qreal b = ((y0 + y1) / 2) + h * u * angleSgn; return Point::fromMm(a, b); } }
void DistortionFXFilter::multipleCornersMultithreaded(const Args& prm) { int Width = prm.orgImage->width(); int Height = prm.orgImage->height(); uchar* data = prm.orgImage->bits(); bool sixteenBit = prm.orgImage->sixteenBit(); int bytesDepth = prm.orgImage->bytesDepth(); uchar* pResBits = prm.destImage->bits(); double nh, nw; int nHalfW = Width / 2; int nHalfH = Height / 2; double lfRadMax = qSqrt(Height * Height + Width * Width) / 2.0; double lfAngle, lfNewRadius, lfCurrentRadius; for (int w = prm.start; runningFlag() && (w < prm.stop); ++w) { // we find the distance from the center nh = nHalfH - prm.h; nw = nHalfW - w; // now, we get the distance lfCurrentRadius = qSqrt(nh * nh + nw * nw); // we find the angle from the center lfAngle = qAtan2(nh, nw) * (double)prm.Factor; // ok, we sum angle with accumuled to find a new angle lfNewRadius = lfCurrentRadius * lfCurrentRadius / lfRadMax; // now we find the exact position's x and y nw = (double)nHalfW - (qCos(lfAngle) * lfNewRadius); nh = (double)nHalfH - (qSin(lfAngle) * lfNewRadius); setPixelFromOther(Width, Height, sixteenBit, bytesDepth, data, pResBits, w, prm.h, nw, nh, prm.AntiAlias); } }
void draw( QPainter &painter, const Slice &slice, const uiCoord2D &pithCoord, const int &intensityThreshold, const TKD::ProjectionType &view ) { painter.save(); painter.setPen(QColor(255,255,255,127)); const uint width = painter.window().width(); const uint height = painter.window().height(); const qreal angularIncrement = TWO_PI/(qreal)(width); uint i, j, x, y; if ( view == TKD::Z_PROJECTION ) { for ( j=0 ; j<height ; ++j ) { for ( i=0 ; i<width ; ++i ) { if ( slice.at(j,i) > intensityThreshold ) painter.drawPoint(i,j); } } } else if ( view == TKD::CARTESIAN_PROJECTION ) { for ( j=0 ; j<height ; ++j ) { for ( i=0 ; i<width ; ++i ) { x = pithCoord.x + j * qCos(i*angularIncrement); y = pithCoord.y + j * qSin(i*angularIncrement); if ( slice.at(y,x) > intensityThreshold ) painter.drawPoint(i,j); } } } painter.restore(); }
void SpaceObjectShip :: update(qint64 time) { if (mTargetX != -1 && mTargetY != -1) { double tAngle = angle(mCoordX, mCoordY, mTargetX, mTargetY); double dist = distance(mCoordX, mCoordY, mTargetX, mTargetY) / 4; double diff = angleDiff(mRotation, tAngle); mDirection = turnDirection(mRotation, tAngle); if (diff > -dist && diff < dist) mTrust = true; else mTrust = false; if (dist < 2) { mTargetX = -1; mTargetY = -1; mTrust = false; mDirection = 0; } } /* normal calculation of rotation / thrust */ mRotation += mDirection * (time / 1000.0) * ROT_PER_SEC; if (mRotation < 0) mRotation += 360; if (mRotation >= 360) mRotation -= 360; if (mTrust) { mCoordX += qCos( DEG2RAD(mRotation) ) * (time / 1000.0) * SPEED_PER_SEC; mCoordY += qSin( DEG2RAD(mRotation) ) * (time / 1000.0) * SPEED_PER_SEC; } }
void NMPT_simulator::buildModel(int iterations_number) { stone_trajectory.resize(iterations_number); duck_trajectory.resize(iterations_number); max_iter_achieved = iterations_number; stone_trajectory[0].x = 0; stone_trajectory[0].y=0; stone_trajectory[0].Vx = qCos(qDegreesToRadians(alpha))*V; stone_trajectory[0].Vy = qSin(qDegreesToRadians(alpha))*V; duck_trajectory[0].x = dX0; duck_trajectory[0].Vx = U; closest_encounter.first = dX0; closest_encounter.second = 0; for(int i=1; i<iterations_number; i++) { moveDuck(i); moveStone(i); if(stone_trajectory[i].y < 0) { max_iter_achieved = i; resize_trajectory(i); break; } if(abs(stone_trajectory[i].x - duck_trajectory[i].x) < closest_encounter.first) { closest_encounter.first = abs(stone_trajectory[i].x - duck_trajectory[i].x); closest_encounter.second = i; } } }
qreal ImageProcessor::vectorSum(QImage input, QPoint start, int fakeangle) { bool goOn = true; QPoint currentPoint; qreal returnMe =0.0; int length=1; qreal angle = (fakeangle/180.0) * M_PI; while(goOn) { int newX = (int)(start.x() + (length * qCos(angle) )); int newY = (int)(start.y() + (length * qSin(angle) )); currentPoint = QPoint(newX,newY); if(input.valid(currentPoint)) { //qreal value = regionAvg(currentPoint.x(),currentPoint.y(),1,1,input); qreal value = qRed(input.pixel(currentPoint)); //qDebug()<<"Adding " <<(value/length); returnMe += (value/sqrt(length)); //qDebug()<<"Return me is now " <<returnMe; length++; } else { goOn = false; } } return returnMe; }
void NotificationSound::playSound() { //QSound::play(":/sound/notification_sound.wav"); //return; qreal frequency = ((sFrequency <= 0)?2000:sFrequency); qreal mseconds = ((sDuration <= 0)?1000:sDuration); quint8 volume = ((sVolume <= 0)?1:sVolume); qreal sampleRate = 2.0 * M_PI / (192000./frequency); QByteArray bytebuf; bytebuf.resize(mseconds * 192); for (int i=0; i < bytebuf.size(); i++) { bytebuf[i] = (quint8)(qreal(255) * qSin(qreal(i) * sampleRate)); } QDataStream stream(&bytebuf, QIODevice::ReadWrite); QAudioFormat format; format.setSampleRate(192000); format.setChannelCount(1); format.setSampleSize(8); format.setCodec("audio/pcm"); format.setByteOrder(QAudioFormat::LittleEndian); format.setSampleType(QAudioFormat::UnSignedInt); QAudioOutput * audio = new QAudioOutput(format, this); audio->setVolume(1.0 * (qreal(volume + 1)/4)); audio->setBufferSize(bytebuf.size()); audio->start(stream.device()); QEventLoop loop; QTimer::singleShot(mseconds*2, &loop, SLOT(quit())); loop.exec(); }
/*! \fn QTransform & QTransform::rotateRadians(qreal angle, Qt::Axis axis) Rotates the coordinate system counterclockwise by the given \a angle about the specified \a axis and returns a reference to the matrix. Note that if you apply a QTransform to a point defined in widget coordinates, the direction of the rotation will be clockwise because the y-axis points downwards. The angle is specified in radians. \sa setMatrix() */ QTransform & QTransform::rotateRadians(qreal a, Qt::Axis axis) { qreal sina = qSin(a); qreal cosa = qCos(a); if (axis == Qt::ZAxis) { if (type() != TxProject) { qreal tm11 = cosa*affine._m11 + sina*affine._m21; qreal tm12 = cosa*affine._m12 + sina*affine._m22; qreal tm21 = -sina*affine._m11 + cosa*affine._m21; qreal tm22 = -sina*affine._m12 + cosa*affine._m22; affine._m11 = tm11; affine._m12 = tm12; affine._m21 = tm21; affine._m22 = tm22; } else { QTransform result; result.affine._m11 = cosa; result.affine._m12 = sina; result.affine._m22 = cosa; result.affine._m21 = -sina; *this = result * *this; } m_dirty |= TxRotate; } else { QTransform result; if (axis == Qt::YAxis) { result.affine._m11 = cosa; result.m_13 = -sina * inv_dist_to_plane; } else { result.affine._m22 = cosa; result.m_23 = -sina * inv_dist_to_plane; } m_dirty = TxProject; *this = result * *this; } return *this; }
void Widget::drawObj()//draw obj { // glLoadIdentity(); // drawTriangle(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(radius*qCos(AngToRad*xRot), yRot, radius*qSin(AngToRad*xRot), 0, 0, 0, 0, 1, 0); // glTranslatef(0.0, 0.0, -50.0+zTra); // glRotatef(xRot, 1.0, 0.0, 0.0); // glRotatef(yRot, 0.0, qCos(yRot*AngToRad), -qSin(yRot*AngToRad)); // glRotatef(xRot, 0.0,1.0,0.0); // glRotatef(zRot, 0.0, 0.0, 1.0); glBegin(GL_TRIANGLES); qglColor(Qt::green); for(int i=0;i<ObjFace.length();i++){ glVertex3f(ObjFace[i].a.x,ObjFace[i].a.y,ObjFace[i].a.z); glVertex3f(ObjFace[i].b.x,ObjFace[i].b.y,ObjFace[i].b.z); glVertex3f(ObjFace[i].c.x,ObjFace[i].c.y,ObjFace[i].c.z); } // QMessageBox::information(NULL, "Title", ObjFace[ObjFace.length()-1].toQString(), QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes); glFlush(); glEnd(); }
void Bullet::move(){ int STEP_SIZE = 5; double theta = rotation(); //degrees double dy = STEP_SIZE * qSin(qDegreesToRadians(theta)); double dx = STEP_SIZE * qCos(qDegreesToRadians(theta)); setPos(x()+dx, y()+dy); // get a list of all the items currently colliding with this bullet QList<QGraphicsItem *> colliding_items = collidingItems(); if((x()>720)||(x()<-5)||(y()>720)||(y()<-5)){ scene()->removeItem(this); delete this; } // if one of the colliding items is an Enemy, destroy both the bullet and the enemy for (int i = 0, n = colliding_items.size(); i < n; ++i){ if (typeid(*(colliding_items[i])) == typeid(Enemy)){ //remove them from the scene (still on the heap) scene()->removeItem(colliding_items[i]); scene()->removeItem(this); // delete them from the heap to save memory delete colliding_items[i]; delete this; // return (all code below refers to a non existent bullet) return; } } }
virtual double y ( double x ) const { return qSin( x ); }
//--------------------------------------------------------------- d2aCallback extern "C" int d2aCallback(const void *inputBuffer, void *outputBuffer, unsigned long framesToProcess, const PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags statusFlags, void *userData ) { paUserData *udata=(paUserData*)userData; short *wptr = (short*)outputBuffer; unsigned int i; static int n; static int ic=0; static bool btxok0=false; static bool bTune0=false; static int nStart=0; static double phi=0.; double tsec,tstart,dphi; int nsec; int nTRperiod=udata->nTRperiod; // Get System time qint64 ms = QDateTime::currentMSecsSinceEpoch() % 86400000; tsec = 0.001*ms; nsec = ms/1000; qreal dPhase=iqPhase/5729.57795131; qreal amp=1.0 + 0.0001*iqAmp; qreal xAmp=txPower*295.00*qSqrt(2.0 - amp*amp); qreal yAmp=txPower*295.00*amp; static int nsec0=0; if(bTune) { ic=0; dphi=6.28318530718*1270.46/11025.0; } if(bTune0 and !bTune) btxok=false; bTune0=bTune; if(nsec!=nsec0) { // qDebug() << txPower << iqAmp << iqPhase << amp << xAmp << yAmp << dPhase << bTune; // qDebug() << "A" << nsec%60 << bTune << btxok; // ic=0; nsec0=nsec; } if(btxok and !btxok0) { //Start (or re-start) a transmission n=nsec/nTRperiod; tstart=tsec - n*nTRperiod - 1.0; if(tstart<1.0) { ic=0; //Start of Tx cycle, set starting index to 0 nStart=n; } else { if(n != nStart) { //Late start in new Tx cycle: compute starting index ic=(int)(tstart*11025.0); ic=2*ic; nStart=n; } } } btxok0=btxok; if(btxok) { for(i=0 ; i<framesToProcess; i++ ) { short int i2a=iwave[ic++]; short int i2b=iwave[ic++]; if(ic > nwave) {i2a=0; i2b=0;} // i2 = 500.0*(i2/32767.0 + 5.0*gran()); //Add noise (tests only!) // if(bIQxt) { if(1) { if(bTune) { phi += dphi; } else { phi=qAtan2(qreal(i2a),qreal(i2b)); } i2a=xAmp*qCos(phi); i2b=yAmp*qSin(phi + dPhase); // qDebug() << xAmp << yAmp << phi << i2a << i2b; } // i2a=0.01*txPower*i2a; // i2b=0.01*txPower*i2b; *wptr++ = i2a; //left *wptr++ = i2b; //right } } else { for(i=0 ; i<framesToProcess; i++ ) { *wptr++ = 0; *wptr++ = 0; ic++; ic++; } } if(ic > nwave) { btxok=0; ic=0; } return 0; }
/*! \since 4.4 Returns a QLineF with the given \a length and \a angle. The first point of the line will be on the origin. Positive values for the angles mean counter-clockwise while negative values mean the clockwise direction. Zero degrees is at the 3 o'clock position. */ QLineF QLineF::fromPolar(qreal length, qreal angle) { const qreal angleR = angle * M_2PI / 360.0; return QLineF(0, 0, qCos(angleR) * length, -qSin(angleR) * length); }
void MathPlot::setupScatterStyleDemo(QCustomPlot *customPlot) { customPlot->legend->setVisible(true); customPlot->legend->setFont(QFont("Helvetica", 9)); customPlot->legend->setRowSpacing(-3); QVector<QCPScatterStyle::ScatterShape> shapes; shapes << QCPScatterStyle::ssCross; shapes << QCPScatterStyle::ssPlus; shapes << QCPScatterStyle::ssCircle; shapes << QCPScatterStyle::ssDisc; shapes << QCPScatterStyle::ssSquare; shapes << QCPScatterStyle::ssDiamond; shapes << QCPScatterStyle::ssStar; shapes << QCPScatterStyle::ssTriangle; shapes << QCPScatterStyle::ssTriangleInverted; shapes << QCPScatterStyle::ssCrossSquare; shapes << QCPScatterStyle::ssPlusSquare; shapes << QCPScatterStyle::ssCrossCircle; shapes << QCPScatterStyle::ssPlusCircle; shapes << QCPScatterStyle::ssPeace; shapes << QCPScatterStyle::ssCustom; QPen pen; // add graphs with different scatter styles: for (int i=0; i<shapes.size(); ++i) { customPlot->addGraph(); pen.setColor(QColor(sin(i*0.3)*100+100, sin(i*0.6+0.7)*100+100, sin(i*0.4+0.6)*100+100)); // generate data: QVector<double> x(10), y(10); for (int k=0; k<10; ++k) { x[k] = k/10.0 * 4*3.14 + 0.01; y[k] = 7*sin(x[k])/x[k] + (shapes.size()-i)*5; } customPlot->graph()->setData(x, y); customPlot->graph()->rescaleAxes(true); customPlot->graph()->setPen(pen); #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) customPlot->graph()->setName(QCPScatterStyle::staticMetaObject.enumerator(QCPScatterStyle::staticMetaObject.indexOfEnumerator("ScatterShape")).valueToKey(shapes.at(i))); #endif customPlot->graph()->setLineStyle(QCPGraph::lsLine); // set scatter style: if (shapes.at(i) != QCPScatterStyle::ssCustom) { customPlot->graph()->setScatterStyle(QCPScatterStyle(shapes.at(i), 10)); } else { QPainterPath customScatterPath; for (int i=0; i<3; ++i) customScatterPath.cubicTo(qCos(2*M_PI*i/3.0)*9, qSin(2*M_PI*i/3.0)*9, qCos(2*M_PI*(i+0.9)/3.0)*9, qSin(2*M_PI*(i+0.9)/3.0)*9, 0, 0); customPlot->graph()->setScatterStyle(QCPScatterStyle(customScatterPath, QPen(), QColor(40, 70, 255, 50), 10)); } } // set blank axis lines: customPlot->rescaleAxes(); customPlot->xAxis->setTicks(false); customPlot->yAxis->setTicks(false); customPlot->xAxis->setTickLabels(false); customPlot->yAxis->setTickLabels(false); // make top right axes clones of bottom left axes: customPlot->axisRect()->setupFullAxesBox(); }
void Meteor::init(const float& radiantAlpha, const float& radiantDelta, const float& speed, const QList<ColorPair> colors) { // meteor velocity in km/s m_speed = speed; // find the radiant in horizontal coordinates Vec3d radiantAltAz; StelUtils::spheToRect(radiantAlpha, radiantDelta, radiantAltAz); radiantAltAz = m_core->j2000ToAltAz(radiantAltAz); float radiantAlt, radiantAz; // S is zero, E is 90 degrees (SDSS) StelUtils::rectToSphe(&radiantAz, &radiantAlt, radiantAltAz); // meteors won't be visible if radiant is below 0degrees if (radiantAlt < 0.f) { return; } // define the radiant coordinate system // rotation matrix to align z axis with radiant m_matAltAzToRadiant = Mat4d::zrotation(radiantAz) * Mat4d::yrotation(M_PI_2 - radiantAlt); // select a random initial meteor altitude in the horizontal system [MIN_ALTITUDE, MAX_ALTITUDE] float initialAlt = MIN_ALTITUDE + (MAX_ALTITUDE - MIN_ALTITUDE) * ((float) qrand() / ((float) RAND_MAX + 1)); // calculates the max z-coordinate for the currrent radiant float maxZ = meteorZ(M_PI_2 - radiantAlt, initialAlt); // meteor trajectory // select a random xy position in polar coordinates (radiant system) float xyDist = maxZ * ((double) qrand() / ((double) RAND_MAX + 1)); // [0, maxZ] float theta = 2 * M_PI * ((double) qrand() / ((double) RAND_MAX + 1)); // [0, 2pi] // initial meteor coordinates (radiant system) m_position[0] = xyDist * qCos(theta); m_position[1] = xyDist * qSin(theta); m_position[2] = maxZ; m_posTrain = m_position; // store the initial z-component (radiant system) m_initialZ = m_position[2]; // find the initial meteor coordinates in the horizontal system Vec3d positionAltAz = m_position; positionAltAz.transfo4d(m_matAltAzToRadiant); // find the angle from horizon to meteor float meteorAlt = qAsin(positionAltAz[2] / positionAltAz.length()); // this meteor should not be visible if it is above the maximum altitude // or if it's below the horizon! if (positionAltAz[2] > MAX_ALTITUDE || meteorAlt <= 0.f) { return; } // determine the final z-component and the min distance between meteor and observer if (radiantAlt < 0.0262f) // (<1.5 degrees) earth grazing meteor ? { // earth-grazers are rare! // introduce a probabilistic factor just to make them a bit harder to occur float prob = ((float) qrand() / ((float) RAND_MAX + 1)); if (prob > 0.3f) { return; } // limit lifetime to 12sec m_finalZ = -m_position[2]; m_finalZ = qMax(m_position[2] - m_speed * 12.f, (double) m_finalZ); m_minDist = xyDist; } else { // limit lifetime to 12sec m_finalZ = meteorZ(M_PI_2 - meteorAlt, MIN_ALTITUDE); m_finalZ = qMax(m_position[2] - m_speed * 12.f, (double) m_finalZ); m_minDist = qSqrt(m_finalZ * m_finalZ + xyDist * xyDist); } // a meteor cannot hit the observer! if (m_minDist < MIN_ALTITUDE) { return; } // select random magnitude [-3; 4.5] float Mag = (float) qrand() / ((float) RAND_MAX + 1) * 7.5f - 3.f; // compute RMag and CMag RCMag rcMag; m_core->getSkyDrawer()->computeRCMag(Mag, &rcMag); m_absMag = rcMag.radius <= 1.2f ? 0.f : rcMag.luminance; if (m_absMag == 0.f) { return; } // most visible meteors are under about 184km distant // scale max mag down if outside this range float scale = qPow(184.0 / m_minDist, 2); m_absMag *= qMin(scale, 1.0f); // build the color vector buildColorVectors(colors); m_alive = true; }
void dtkComposerNodeNumberOperatorUnarySin::run(void) { double *value = d->receiver.data<double>(); *value = qSin(*value); d->emitter.setData<double>(value); }
/** * Easing function where the value grows sinusoidally. Note that the calculated end value will be 0 rather than 1. */ static qreal easeSineCurve(qreal t) { return (qSin(((t * M_PI * 2)) - M_PI_2) + 1) / 2; }
static inline qreal qt_sinProgress(qreal value) { return qSin((value * M_PI) - M_PI_2) / 2 + qreal(0.5); }
void ClassicStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex *opt, QPainter *p, const QWidget *widget) const { if (cc != QStyle::CC_Dial) { QCommonStyle::drawComplexControl(cc, opt, p, widget); return; } const QStyleOptionSlider *dial = qstyleoption_cast<const QStyleOptionSlider *>(opt); if (dial == NULL) return; float angle = DIAL_MIN + (DIAL_RANGE * (float(dial->sliderValue - dial->minimum) / (float(dial->maximum - dial->minimum)))); int degrees = int(angle * 180.0 / M_PI); int ns = dial->tickInterval; int numTicks = 1 + (dial->maximum + ns - dial->minimum) / ns; int size = dial->rect.width() < dial->rect.height() ? dial->rect.width() : dial->rect.height(); int scale = 1; int width = size * scale; int indent = (int)(width * 0.15 + 1); QPalette pal = opt->palette; QColor knobColor = pal.mid().color(); //pal.background().color(); QColor meterColor = (dial->state & State_Enabled) ? pal.highlight().color() : pal.mid().color(); QPen pen; QColor c; p->save(); p->setRenderHint(QPainter::Antialiasing, true); p->translate(1+(dial->rect.width()-size)/2, 1+(dial->rect.height()-size)/2); // Knob body and face... pen.setColor(knobColor); pen.setWidth(scale * 2); pen.setCapStyle(Qt::FlatCap); p->setPen(pen); QRadialGradient gradient(size/2, size/2, size-indent, size/2-indent, size/2-indent); gradient.setColorAt(0, knobColor.light()); gradient.setColorAt(1, knobColor.dark()); p->setBrush(gradient); p->drawEllipse(indent, indent, width-2*indent, width-2*indent); // The bright metering bit... c = meterColor; pen.setColor(c); pen.setWidth(indent); p->setPen(pen); int arcLen = -(degrees - 45) * 16; if (arcLen == 0) arcLen = -16; p->drawArc(indent/2, indent/2, width-indent, width-indent, (180 + 45) * 16, arcLen); p->setBrush(Qt::NoBrush); // Tick notches... if (dial->subControls & QStyle::SC_DialTickmarks) { // std::cerr << "Notches visible" << std::endl; pen.setColor(pal.dark().color()); pen.setWidth(scale); p->setPen(pen); for (int i = 0; i < numTicks; ++i) { int div = numTicks; if (div > 1) --div; drawTick(p, DIAL_MIN + (DIAL_MAX - DIAL_MIN) * i / div, width, true); } } // Shadowing... pen.setWidth(scale); p->setPen(pen); // Knob shadow... int shadowAngle = -720; c = knobColor.dark(); for (int arc = 120; arc < 2880; arc += 240) { pen.setColor(c); p->setPen(pen); p->drawArc(indent, indent, width-2*indent, width-2*indent, shadowAngle + arc, 240); p->drawArc(indent, indent, width-2*indent, width-2*indent, shadowAngle - arc, 240); c = c.light(110); } // Scale shadow... shadowAngle = 2160; c = pal.dark().color(); for (int arc = 120; arc < 2880; arc += 240) { pen.setColor(c); p->setPen(pen); p->drawArc(scale/2, scale/2, width-scale, width-scale, shadowAngle + arc, 240); p->drawArc(scale/2, scale/2, width-scale, width-scale, shadowAngle - arc, 240); c = c.light(108); } // Undraw the bottom part... pen.setColor(pal.background().color()); pen.setWidth(scale * 4); p->setPen(pen); p->drawArc(scale/2, scale/2, width-scale, width-scale, -45 * 16, -90 * 16); // Pointer notch... float hyp = float(width) / 2.0; float len = hyp - indent; --len; float x0 = hyp; float y0 = hyp; float x = hyp - len * qSin(angle); float y = hyp + len * qCos(angle); c = pal.dark().color(); pen.setColor((dial->state & State_Enabled) ? c.dark(130) : c); pen.setWidth(scale * 2); p->setPen(pen); p->drawLine(int(x0), int(y0), int(x), int(y)); // done p->restore(); }
QRect QAccessibleDial::rect(int child) const { QRect rect; if (!dial()->isVisible()) return rect; switch (child) { case Self: return QAccessibleWidgetEx::rect(child); case SpeedoMeter: { // Mixture from qcommonstyle.cpp (focus rect). int width = dial()->width(); int height = dial()->height(); qreal radius = qMin(width, height) / 2.0; qreal delta = radius / 6.0; qreal dx = delta + (width - 2 * radius) / 2.0; qreal dy = delta + (height - 2 * radius) / 2.0; rect = QRect(int(dx), int(dy), int(radius * 2 - 2 * delta), int(radius * 2 - 2 * delta)); if (dial()->notchesVisible()) { rect.translate(int(-radius / 6), int(-radius / 6)); rect.setWidth(rect.width() + int(radius / 3)); rect.setHeight(rect.height() + int(radius / 3)); } break; } case SliderHandle: { // Mixture from qcommonstyle.cpp and qdial.cpp. int sliderValue = !dial()->invertedAppearance() ? dial()->value() : (dial()->maximum() - dial()->value()); qreal angle = 0; if (dial()->maximum() == dial()->minimum()) { angle = Q_PI / 2; } else if (dial()->wrapping()) { angle = Q_PI * 3 / 2 - (sliderValue - dial()->minimum()) * 2 * Q_PI / (dial()->maximum() - dial()->minimum()); } else { angle = (Q_PI * 8 - (sliderValue - dial()->minimum()) * 10 * Q_PI / (dial()->maximum() - dial()->minimum())) / 6; } int width = dial()->rect().width(); int height = dial()->rect().height(); int radius = qMin(width, height) / 2; int xc = width / 2; int yc = height / 2; int bigLineSize = radius / 6; if (bigLineSize < 4) bigLineSize = 4; if (bigLineSize > radius / 2) bigLineSize = radius / 2; int len = radius - bigLineSize - 5; if (len < 5) len = 5; int back = len / 2; QPolygonF arrow(3); arrow[0] = QPointF(0.5 + xc + len * qCos(angle), 0.5 + yc - len * qSin(angle)); arrow[1] = QPointF(0.5 + xc + back * qCos(angle + Q_PI * 5 / 6), 0.5 + yc - back * qSin(angle + Q_PI * 5 / 6)); arrow[2] = QPointF(0.5 + xc + back * qCos(angle - Q_PI * 5 / 6), 0.5 + yc - back * qSin(angle - Q_PI * 5 / 6)); rect = arrow.boundingRect().toRect(); break; } default: return QRect(); } QPoint globalPos = dial()->mapToGlobal(QPoint(0,0)); return QRect(globalPos.x() + rect.x(), globalPos.y() + rect.y(), rect.width(), rect.height()); }
QMap<int, double> TutorialUnit::moveHaptic(QMap<int, double> axes) { QMap<int, double> force; if(axes.empty()){ stop(); return force; } if(mHapticStartAxes.empty()){ mHapticStartAxes = axes; mStartPosition = QPointF(getPosition().x, getPosition().y); } qDebug() << "========================="; qDebug() << "Start: " << mHapticStartAxes[Tc::Haptic::AxisX] << "," << mHapticStartAxes[Tc::Haptic::AxisX]; qDebug() << "Current: " << axes[Tc::Haptic::AxisX] << "," << axes[Tc::Haptic::AxisX]; axes[Tc::Haptic::AxisX] -= mHapticStartAxes[Tc::Haptic::AxisX]; axes[Tc::Haptic::AxisY] -= mHapticStartAxes[Tc::Haptic::AxisY]; axes[Tc::Haptic::AxisZ] -= mHapticStartAxes[Tc::Haptic::AxisZ]; QPointF p(axes[Tc::Haptic::AxisX], axes[Tc::Haptic::AxisY]); qDebug() << "Delta: " << axes[Tc::Haptic::AxisX] << "," << axes[Tc::Haptic::AxisX]; // 1. Converte p to the rotated coordinate system // Rotation around "z"-axis, all values in radian // => R = [[cos(yaw),-sin(yaw)][sin(yaw), cos(yaw)]] // => x' = p.x() * cos(yaw) - p.y() * sin(yaw) // y' = p.x() * sin(yaw) + p.y() * cos(yaw) double yawRad = qDegreesToRadians(mHapticStartAxes[Tc::Haptic::AxisYaw]); QPointF pNew(p.x() * qCos(yawRad) + p.y() * qSin(yawRad), p.x() * -qSin(yawRad) + p.y() * qCos(yawRad)); double targetX = qBound<double>(0.0, mStartPosition.x() + pNew.x() * IMAGE_WIDTH, IMAGE_WIDTH); double targetY = qBound<double>(0.0, mStartPosition.y() + pNew.y() * IMAGE_HEIGHT, IMAGE_HEIGHT); QPointF targetPosition(targetX, targetY); qDebug() << "New: " << pNew.x() << "," << pNew.y() << " (" << mHapticStartAxes[Tc::Haptic::AxisYaw] << ")"; qDebug() << "Target: " << targetX << "," << targetY; //qDebug() << p << ";" << targetPosition; //setPosition(targetPosition); return force; // Create return value // Check if robot is in "bounds" /*QPointF currentPosition = QPointF(getPosition().x, getPosition().y); QRect workspace = QRect(50,50,500,300); if(currentPosition.x() < workspace.left()){ // Robot left workspace on left hand side force[Tc::Haptic::AxisX] = abs(currentPosition.x()-workspace.left())*10.0; } else if(workspace.right() < currentPosition.x()){ // Robot left workspace on right hand side force[Tc::Haptic::AxisX] = abs(currentPosition.x()-workspace.right())*-10.0; } if(currentPosition.y() < workspace.top()){ // Robot left workspace on the top force[Tc::Haptic::AxisY] = abs(currentPosition.y()-workspace.top())*-10.0; } else if(workspace.bottom() < currentPosition.y()){ // Robot left workspace on the bottom force[Tc::Haptic::AxisY] = abs(currentPosition.y()-workspace.bottom())*10.0; }*/ }
void Enemy::move_forward() { QLineF ln(pos(),dest); if(ln.length() < 5){ if(point_index<points.size()-1){ point_index++; dest = points[point_index]; rotateToPoint(dest);} } int STEP_SIZE = 5; double theta = rotation(); // degrees double dy = STEP_SIZE * qSin(qDegreesToRadians(theta)); double dx = STEP_SIZE * qCos(qDegreesToRadians(theta)); QList<QGraphicsItem *> colliding_items = collidingItems(); for (int i = 0, n = colliding_items.size(); i < n; ++i){ if (typeid(*(colliding_items[i])) == typeid(Bullet)){ scene()->removeItem(colliding_items[i]); delete colliding_items[i]; this->set_Health(game->getShootdmg()); if(this->Health <= 0){ scene()->removeItem(this); delete this; game->score->increase(); game->hscore->increase(); } return; } if (typeid(*(colliding_items[i])) == typeid(slowdart)){ scene()->removeItem(colliding_items[i]); this->timer->start(60*game->getSlowtime()); delete colliding_items[i]; return; } if (typeid(*(colliding_items[i])) == typeid(Home)){ if(game->health->getHealth()!=10){ scene()->removeItem(this); delete this; game->health->decrease(10);} else{ scene()->removeItem(this); delete this; game->health->decrease(10); delete (game); go = new gameover; go->show(); } return; } if (typeid(*(colliding_items[i])) == typeid(triplearrow)){ scene()->removeItem(colliding_items[i]); delete colliding_items[i]; this->set_Health(game->getBluedmg()); if(this->Health <= 0){ scene()->removeItem(this); delete this; game->score->increase(); game->hscore->increase(); } return; } } setPos(x()+dx, y()+dy); }
//void robotField::moveRobot(int x, int y) //{ // robot->moveBy(x,y); // // ѕеремещаем робота обновл¤ем координаты // calculateCenter(); // // robot->setTransformOriginPoint(*robotCenter); // qDebug()<<robot->x()<<" "<<robot->y()<<"\n"; // //qDebug()<<robotCenter->x()<<" "<<robotCenter->y()<<"\n"; //} void robotField::moveRobot(int distance) { robot->moveBy(qCos(degrees(robot->rotation()))*distance,qSin(degrees(robot->rotation())*distance)); qDebug()<<robot->x()<<" "<<robot->y()<<"\n"; }
qreal soundFunc(qreal val) { return 1.0 / (2.3) * (qSin(val) + qSin(2.0 * val) + 0.3*qCos(1.312*val)); }
void QQuickSvgParser::pathArc(QPainterPath &path, qreal rx, qreal ry, qreal x_axis_rotation, int large_arc_flag, int sweep_flag, qreal x, qreal y, qreal curx, qreal cury) { qreal sin_th, cos_th; qreal a00, a01, a10, a11; qreal x0, y0, x1, y1, xc, yc; qreal d, sfactor, sfactor_sq; qreal th0, th1, th_arc; int i, n_segs; qreal dx, dy, dx1, dy1, Pr1, Pr2, Px, Py, check; rx = qAbs(rx); ry = qAbs(ry); sin_th = qSin(x_axis_rotation * (Q_PI / 180.0)); cos_th = qCos(x_axis_rotation * (Q_PI / 180.0)); dx = (curx - x) / 2.0; dy = (cury - y) / 2.0; dx1 = cos_th * dx + sin_th * dy; dy1 = -sin_th * dx + cos_th * dy; Pr1 = rx * rx; Pr2 = ry * ry; Px = dx1 * dx1; Py = dy1 * dy1; /* Spec : check if radii are large enough */ check = Px / Pr1 + Py / Pr2; if (check > 1) { rx = rx * qSqrt(check); ry = ry * qSqrt(check); } a00 = cos_th / rx; a01 = sin_th / rx; a10 = -sin_th / ry; a11 = cos_th / ry; x0 = a00 * curx + a01 * cury; y0 = a10 * curx + a11 * cury; x1 = a00 * x + a01 * y; y1 = a10 * x + a11 * y; /* (x0, y0) is current point in transformed coordinate space. (x1, y1) is new point in transformed coordinate space. The arc fits a unit-radius circle in this space. */ d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0); sfactor_sq = 1.0 / d - 0.25; if (sfactor_sq < 0) sfactor_sq = 0; sfactor = qSqrt(sfactor_sq); if (sweep_flag == large_arc_flag) sfactor = -sfactor; xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0); yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0); /* (xc, yc) is center of the circle. */ th0 = qAtan2(y0 - yc, x0 - xc); th1 = qAtan2(y1 - yc, x1 - xc); th_arc = th1 - th0; if (th_arc < 0 && sweep_flag) th_arc += 2 * Q_PI; else if (th_arc > 0 && !sweep_flag) th_arc -= 2 * Q_PI; n_segs = qCeil(qAbs(th_arc / (Q_PI * 0.5 + 0.001))); for (i = 0; i < n_segs; i++) { pathArcSegment(path, xc, yc, th0 + i * th_arc / n_segs, th0 + (i + 1) * th_arc / n_segs, rx, ry, x_axis_rotation); } }