bool ContinuousColorRange::contains(const QVariant &v, bool inclusive) const { QColor clr; if( v.type() == QVariant::Double){ clr = ColorRangeBase::toColor(v.toULongLong(),defaultColorModel()); } else clr = v.value<QColor>(); if ( !clr.isValid()) return false; double component1a, component2a, component3a,component4a; double component1b, component2b, component3b,component4b; double component1c, component2c, component3c,component4c; QColor limit1,limit2; switch (defaultColorModel()) { case ColorRangeBase::cmRGBA : case ColorRangeBase::cmGREYSCALE: clr.getRgbF(&component1a, &component2a, &component3a); _limit1.getRgbF(&component1b, &component2b, &component3b); _limit2.getRgbF(&component1c, &component2c, &component3c); break; case ColorRangeBase::cmHSLA : clr.getHslF(&component1a, &component2a, &component3a); _limit1.getHslF(&component1b, &component2b, &component3b); _limit2.getHslF(&component1c, &component2c, &component3c); break; case ColorRangeBase::cmCYMKA: clr.getCmykF(&component1a, &component2a, &component3a,&component4a); limit1 = QColor(_limit1); limit2 = QColor(_limit2); limit1.getCmykF(&component1b, &component2b, &component3b, &component4b); limit2.getCmykF(&component1c, &component2c, &component3c, &component4c); break; default: break; } switch(defaultColorModel()){ case ColorRangeBase::cmGREYSCALE:{ bool isGrey = component1a == component2a && component1a == component3a; if (!isGrey) return false; } case ColorRangeBase::cmRGBA : case ColorRangeBase::cmHSLA : return component1a >= component1b && component1a <= component1c && component2a >= component2b && component2a <= component2c && component3a >= component3b && component3a <= component3c; case ColorRangeBase::cmCYMKA: return component1a >= component1b && component1a <= component1c && component2a >= component2b && component2a <= component2c && component3a >= component3b && component3a <= component3c && component4a >= component4b && component4a <= component4c; default: break; } return false; }
// Performs a linear interpolation between two colors, delta \in [0.0,1.0] QColor Function::interpolateRGB(double delta, QColor const& col1, QColor const& col2) const { if (delta <= 0.0) return col1; if (delta >= 1.0) return col2; double r1, r2, g1, g2, b1, b2; col1.getRgbF(&r1, &g1, &b1); col2.getRgbF(&r2, &g2, &b2); r1 += delta*(r2-r1); g1 += delta*(g2-g1); b1 += delta*(b2-b1); QColor color; color.setRgbF(r1, g1, b1); return color; }
Matrix toRgb (const QColor& c) { Matrix rgb (1, 3); double* rgbData = rgb.fortran_vec (); c.getRgbF (rgbData, rgbData+1, rgbData+2); return rgb; }
void Canvas::setUniformColor(GLuint program, const QColor& color, double opacity) { double r, g, b, a; color.getRgbF(&r, &g, &b, &a); a = opacity; GLuint location = gl()->glGetUniformLocation(program, "color"); checkNotErrorCode(location, static_cast<GLuint>(-1), "glGetUniformLocation() failed."); gl()->glUniform4f(location, r, g, b, a); }
inline floatVariant Convert(const QColor& c) { floatVariant param; double rgba[4]; c.getRgbF(rgba, rgba + 1, rgba + 2, rgba + 3); param.float4[0] = static_cast<float>(rgba[0]); param.float4[1] = static_cast<float>(rgba[1]); param.float4[2] = static_cast<float>(rgba[2]); param.float4[3] = static_cast<float>(rgba[3]); return param; }
void vtkDataMeshInteractor::setColor(QColor color) { if( ! color.isValid()) color.setRgb(0,0,0); double r,g,b; color.getRgbF(&r, &g, &b); d->actorProperty->SetColor(r, g, b); d->render->Render(); }
void manualRegistrationLandmarkController::AddPoint(manualRegistrationLandmark * landmark,unsigned int i) { ClearUselessLandmarks(); int size; QColor colorPoint; qreal r,g,b,a; colorPoint = Colors.takeFirst(); Colors.push_back(colorPoint); colorPoint.getRgbF(&r,&g,&b,&a); if (i) { if (Points_Moving->size()<Points_Fixed->size()) Points_Fixed->at(Points_Moving->size())->GetHandleRepresentation()->GetProperty()->GetColor(r,g,b); size = Points_Moving->size(); } else { if (Points_Fixed->size()<Points_Moving->size()) Points_Moving->at(Points_Fixed->size())->GetHandleRepresentation()->GetProperty()->GetColor(r,g,b); size = Points_Fixed->size(); } if (size>=128) { medMessageController::instance()->showError("You cannot add any more landmarks.",3000); return; } vtkProperty2D * property2D = static_cast<vtkPointHandleRepresentation2D*>(landmark->GetHandleWidget()->GetRepresentation())->GetProperty(); property2D->SetColor(r,g,b); property2D->SetPointSize(0.0); property2D->SetLineWidth(3.0); property2D->SetOpacity(1.0); if (i) Points_Moving->append(landmark); else Points_Fixed->append(landmark); if (!landmark->HasObserver (vtkCommand::DeleteEvent, this->Command) ) landmark->AddObserver(vtkCommand::DeleteEvent, this->Command, 0); Tbx->updateGUI(Points_Fixed->size(),Points_Moving->size()); }
void MyMaterialEditor::selectColor(int id) { colour *c; switch (id) { case 0: c = &m_material.ambient; break; case 1: c = &m_material.diffuse; break; case 2: c = &m_material.specular; break; case 3: c = &m_material.emission; break; } QColor initial = QColor::fromRgbF((*c)[0], (*c)[1], (*c)[2], (*c)[3]); QColor current = QColorDialog::getColor(initial, this, "Select Color", QColorDialog::ShowAlphaChannel); if (current.isValid()) { double r, g, b, a; current.getRgbF(&r, &g, &b, &a); c->set(r, g, b, a); updateButton(id, *c); emit materialChanged(m_material); } }
inline FColor QColor_to_FColor( const QColor& theColor ) { qreal r,g,b,a; theColor.getRgbF( &r, &g, &b, &a ); return FColor(r,g,b,a); }
void tst_QColor::setRgb() { QColor color; for (int A = 0; A <= USHRT_MAX; ++A) { { // 0-255 int a = A >> 8; QRgb rgb = qRgba(0, 0, 0, a); color.setRgb(0, 0, 0, a); QCOMPARE(color.alpha(), a); QCOMPARE(color.rgb(), qRgb(0, 0, 0)); color.setRgb(rgb); QCOMPARE(color.alpha(), 255); QCOMPARE(color.rgb(), qRgb(0, 0, 0)); int r, g, b, a2; color.setRgb(0, 0, 0, a); color.getRgb(&r, &g, &b, &a2); QCOMPARE(a2, a); QColor c(0, 0, 0); c.setAlpha(a); QCOMPARE(c.alpha(), a); } { // 0.0-1.0 qreal a = A / qreal(USHRT_MAX); color.setRgbF(0.0, 0.0, 0.0, a); QCOMPARE(color.alphaF(), a); qreal r, g, b, a2; color.getRgbF(&r, &g, &b, &a2); QCOMPARE(a2, a); QColor c(0, 0, 0); c.setAlphaF(a); QCOMPARE(c.alphaF(), a); } } for (int R = 0; R <= USHRT_MAX; ++R) { { // 0-255 int r = R >> 8; QRgb rgb = qRgb(r, 0, 0); color.setRgb(r, 0, 0); QCOMPARE(color.red(), r); QCOMPARE(color.rgb(), rgb); color.setRgb(rgb); QCOMPARE(color.red(), r); QCOMPARE(color.rgb(), rgb); int r2, g, b, a; color.getRgb(&r2, &g, &b, &a); QCOMPARE(r2, r); } { // 0.0-1.0 qreal r = R / qreal(USHRT_MAX); color.setRgbF(r, 0.0, 0.0); QCOMPARE(color.redF(), r); qreal r2, g, b, a; color.getRgbF(&r2, &g, &b, &a); QCOMPARE(r2, r); } } for (int G = 0; G <= USHRT_MAX; ++G) { { // 0-255 int g = G >> 8; QRgb rgb = qRgb(0, g, 0); color.setRgb(0, g, 0); QCOMPARE(color.green(), g); QCOMPARE(color.rgb(), rgb); color.setRgb(rgb); QCOMPARE(color.green(), g); QCOMPARE(color.rgb(), rgb); int r, g2, b, a; color.getRgb(&r, &g2, &b, &a); QCOMPARE(g2, g); } { // 0.0-1.0 qreal g = G / qreal(USHRT_MAX); color.setRgbF(0.0, g, 0.0); QCOMPARE(color.greenF(), g); qreal r, g2, b, a; color.getRgbF(&r, &g2, &b, &a); QCOMPARE(g2, g); } } for (int B = 0; B <= USHRT_MAX; ++B) { { // 0-255 int b = B >> 8; QRgb rgb = qRgb(0, 0, b); color.setRgb(0, 0, b); QCOMPARE(color.blue(), b); QCOMPARE(color.rgb(), rgb); color.setRgb(rgb); QCOMPARE(color.blue(), b); QCOMPARE(color.rgb(), rgb); int r, g, b2, a; color.getRgb(&r, &g, &b2, &a); QCOMPARE(b2, b); } { // 0.0-1.0 qreal b = B / qreal(USHRT_MAX); color.setRgbF(0.0, 0.0, b); QCOMPARE(color.blueF(), b); qreal r, g, b2, a; color.getRgbF(&r, &g, &b2, &a); QCOMPARE(b2, b); } } }
void ImageRendererThread::run() { std::complex<double> z; double steoreographic_projection_ball_radius = .1; double ray_nums = 12; double log_base = 2; QColor pixelColor; double h, s, v; // hue, sat, val double m; // modulus (Betrag) double lambda, mu, nu, dummy; QRgb *sl; forever { mMutex.lock(); PlotHelp::cs_params param = mCSP; double xmin = mXmin, ymin = mYmin, infT = mP.mInfinityThreshold, rayO = mP.mRayOpacity, cirO = mP.mCircleOpacity, rayT = mP.mRayThickness, cirT = mP.mCircleThickness; int iterations = mP.mIterations; // make a copy of the function object so we won't need thread locking // to slow us down MFC_t nf(*mP.mF); QImage *mImage = mP.mImage; // integer division int ystart = mThreadNumber*(param.winheight+1)/mP.mNThreads, yend = (mThreadNumber+1)*(param.winheight+1)/mP.mNThreads-1; mMutex.unlock(); qDebug() << "Thread " << mThreadNumber << " from " << ystart << " to " << yend; if(nf.parseOk()) { for(int y=ystart; y <= yend; ++y) { mGMutex.lock(); sl = reinterpret_cast<QRgb*>(mImage->scanLine(y)); mGMutex.unlock(); for(int x=0; x <= param.winwidth; ++x) { if(mFinish) return; z.real(xmin + x/param.xstep); z.imag(ymin + (param.winheight-y)/param.ystep); for(int i=0; i<iterations; ++i) z = nf(z); m = std::sqrt(z.real()*z.real()+z.imag()*z.imag()); // log here is really ln, but that's unimportant double l = log(m)/log(log_base); h = std::atan2(z.imag(), z.real()); s = (m>infT) ? 0 : 1; v = M_2_PI*std::atan(m/(2.0*steoreographic_projection_ball_radius)); lambda = exp(-8000/rayT*pow(remainder(h,2*M_PI/ray_nums),2)); h = fmod(h/(2*M_PI)+1,1); pixelColor.setHsvF(h, s, v); mu = fmod(modf(l, &dummy)+1, 1); nu = exp(-10000/cirT*pow(remainder(modf(l, &dummy), 0.5),2)); qreal r[3]; pixelColor.getRgbF(&r[0], &r[1], &r[2]); for(int i=0; i<3; ++i) { r[i] *= (1-0.25*(1-mu*cirO)); r[i] = r[i]*(1-lambda*rayO) + lambda*rayO; if(l>-.25 && l<.25) { r[i] = r[i]*(1-nu*cirO) + nu*cirO*mP.mUnitCircleColor[i]; } else r[i] *= (1-nu*cirO); } /* Note: This is a dangerous play! setPixel is NOT thread-safe, * yet the QImage-instance (mImage) is shared and written to by different * threads which are all computing the image. * * It SEEMS to work --- probably, because each thread writes to DIFFERENT * addresses of the image (i.e. each thread computes unique parts of the image). * However, it is not guaranteed that one day this might somehow change in the * Qt-implementation. * * Unfortunately, locking the resource with a mutex results in a drastic * increase in computation time so we refrain from it at this point. */ // mMutex.lock(); sl[x] = qRgb(r[0]*255, r[1]*255, r[2]*255); // mMutex.unlock(); } } } emit rendered(); mMutex.lock(); qDebug() << "Thread " << mThreadNumber << " about to sleep"; condition.wait(&mMutex); qDebug() << "Thread " << mThreadNumber << " woken, continuing my work"; mMutex.unlock(); } }