QVariant tint(const QVariant &baseVar, const QVariant &tintVar) override
{
QColor tintColor = tintVar.value<QColor>();
int tintAlpha = tintColor.alpha();
if (tintAlpha == 0xFF) {
return tintVar;
} else if (tintAlpha == 0x00) {
return baseVar;
}
// tint the base color and return the final color
QColor baseColor = baseVar.value<QColor>();
qreal a = tintColor.alphaF();
qreal inv_a = 1.0 - a;
qreal r = tintColor.redF() * a + baseColor.redF() * inv_a;
qreal g = tintColor.greenF() * a + baseColor.greenF() * inv_a;
qreal b = tintColor.blueF() * a + baseColor.blueF() * inv_a;
return QVariant::fromValue(QColor::fromRgbF(r, g, b, a + inv_a * baseColor.alphaF()));
}
void setDiffuse(const QColor &diffuse)
{
GLfloat diffuseMaterial[] = { static_cast<GLfloat>(diffuse.redF()),
static_cast<GLfloat>(diffuse.greenF()),
static_cast<GLfloat>(diffuse.blueF()),
1.0f};
setMaterial(NO_MATERIAL,
diffuseMaterial,
NO_MATERIAL,
SHININESS_ZERO,
NO_MATERIAL);
}
// set-up the uniform attributes of the shader programs.
void Scene_item::attrib_buffers(CGAL::Three::Viewer_interface* viewer,
int program_name) const
{
viewer->attrib_buffers(program_name);
QColor c = this->color();
if(program_name == Scene_item::PROGRAM_WITH_TEXTURE)
{
if(is_selected) c = c.lighter(120);
viewer->getShaderProgram(program_name)->setAttributeValue
("color_facets",
c.redF(),
c.greenF(),
c.blueF());
}
else if(program_name == PROGRAM_WITH_TEXTURED_EDGES)
{
if(is_selected) c = c.lighter(50);
viewer->getShaderProgram(program_name)->setUniformValue
("color_lines",
QVector3D(c.redF(), c.greenF(), c.blueF()));
}
}
void OSGTextNode::setColor(const QColor &color)
{
osg::Vec4 osgColor(
color.redF(),
color.greenF(),
color.blueF(),
color.alphaF());
if (h->text->getColor() != osgColor) {
h->text->setColor(osgColor);
emit colorChanged(color);
}
}
void GLWindow::setColour()
{
QColor colour = QColorDialog::getColor();
if( colour.isValid())
{
ngl::ShaderLib *shader=ngl::ShaderLib::instance();
(*shader)["Phong"]->use();
m_colour.m_r=colour.redF();
m_colour.m_g=colour.greenF();
m_colour.m_b=colour.blueF();
updateGL();
}
}
//-----------------------------------------------------------------------------
void ctkVTKColorTransferFunction::setControlPointValue(int index, const QVariant& value)
{
Q_D(ctkVTKColorTransferFunction);
Q_ASSERT(value.value<QColor>().isValid());
QColor rgb = value.value<QColor>();
double values[6];
d->ColorTransferFunction->GetNodeValue(index, values);
values[1] = rgb.redF();
values[2] = rgb.greenF();
values[3] = rgb.blueF();
// setNodeValue should eventually fired the signal changed()
d->ColorTransferFunction->SetNodeValue(index, values);
}
QByteArray BrainSurfaceTreeItem::createCurvatureVertColor(const VectorXf& curvature, const QColor& colSulci, const QColor& colGyri)
{
QByteArray arrayCurvatureColor;
arrayCurvatureColor.resize(curvature.rows() * 3 * (int)sizeof(float));
float *rawColorArray = reinterpret_cast<float *>(arrayCurvatureColor.data());
int idxColor = 0;
for(int i = 0; i<curvature.rows(); i++) {
//Color (this is the default color and will be used until the updateVertColor function was called)
if(curvature[i] >= 0) {
rawColorArray[idxColor++] = colSulci.redF();
rawColorArray[idxColor++] = colSulci.greenF();
rawColorArray[idxColor++] = colSulci.blueF();
} else {
rawColorArray[idxColor++] = colGyri.redF();
rawColorArray[idxColor++] = colGyri.greenF();
rawColorArray[idxColor++] = colGyri.blueF();
}
}
return arrayCurvatureColor;
}
// --------------------------------------------------------------------------
void ctkVTKSurfaceMaterialPropertyWidget::onColorChanged(const QColor& newColor)
{
Q_D(ctkVTKSurfaceMaterialPropertyWidget);
this->Superclass::onColorChanged(newColor);
if (d->Property.GetPointer() != 0)
{
// the value might have changed since we fired the signal, use the current
// up-to-date value then.
const QColor c = this->color();
// Need to work around a VTK bug of SetColor() that fires event
// in an unstable state:
// d->Property->SetColor(c.redF(), c.greenF(), c.blueF());
d->SettingColor = true;
d->Property->SetAmbientColor(c.redF(), c.greenF(), c.blueF());
d->Property->SetDiffuseColor(c.redF(), c.greenF(), c.blueF());
d->Property->SetSpecularColor(c.redF(), c.greenF(), c.blueF());
d->SettingColor = false;
// update just in case something connected to the modified event of the
// vtkProperty modified any attribute
this->updateFromProperty();
}
}
void Viewer::drawVertex(const Point_3& p, const QColor& clr, float r)
{
/* Draw regular points */
if( m_isFlat ) {
// disable lighting
::glDisable( GL_LIGHTING );
::glPointSize(8.0);
qglColor( clr );
::glBegin(GL_POINTS);
::glVertex3f( p.x(), p.y(), p.z() );
::glEnd();
// resume lighting
::glEnable( GL_LIGHTING );
return;
}
/* Draw vertices as 3D balls */
GLboolean lighting, colorMaterial;
::glGetBooleanv( GL_LIGHTING, &lighting );
::glGetBooleanv( GL_COLOR_MATERIAL, &colorMaterial );
::glEnable( GL_LIGHTING );
::glDisable(GL_COLOR_MATERIAL);
float color[4];
color[0] = clr.redF();
color[1] = clr.greenF();
color[2] = clr.blueF();
color[3] = clr.alphaF();
// move to the point
::glPushMatrix();
::glTranslatef( p.x(), p.y(), p.z() );
// draw
GLUquadricObj* quadratic = ::gluNewQuadric(); // Create A Pointer To The Quadric Object
::gluQuadricNormals( quadratic, GLU_SMOOTH ); // Create Smooth Normals
::glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color );
::gluSphere( quadratic, r, 16, 16 );
// move back to origin
::glPopMatrix();
if ( colorMaterial )
::glEnable( GL_COLOR_MATERIAL );
if ( !lighting )
::glDisable( GL_LIGHTING );
}
//-----------------------------------------------------------------------------
int ctkVTKColorTransferFunction::insertControlPoint(const ctkControlPoint& cp)
{
Q_D(ctkVTKColorTransferFunction);
int index = -1;
if (d->ColorTransferFunction.GetPointer() == 0)
{
return index;
}
QColor rgb = cp.value().value<QColor>();
const ctkNonLinearControlPoint* nonLinearCp = dynamic_cast<const ctkNonLinearControlPoint*>(&cp);
if (nonLinearCp)
{
// TODO retrieve midpoint & sharpness
index = d->ColorTransferFunction->AddRGBPoint(
cp.x(), rgb.redF(), rgb.greenF(), rgb.blueF());
}
else
{
index = d->ColorTransferFunction->AddRGBPoint(
cp.x(), rgb.redF(), rgb.greenF(), rgb.blueF());
}
return index;
}
bool Dataset3D::mousePick( int pickId, QVector3D pos, Qt::KeyboardModifiers modifiers, QString target )
{
int paintMode = m_properties["maingl"].get( Fn::Property::D_PAINTMODE ).toInt();
if ( pickId == 0 || paintMode == 0 || !( modifiers & Qt::ControlModifier ) )
{
return false;
}
QColor paintColorC = m_properties["maingl"].get( Fn::Property::D_PAINTCOLOR ).value<QColor>();
QVector3D paintValue;
int type = m_properties["maingl"].get( Fn::Property::D_DATATYPE ).toInt();
if ( type == DT_UNSIGNED_CHAR )
{
paintValue = QVector3D( paintColorC.red(), paintColorC.green(), paintColorC.blue() );
}
else
{
paintValue = QVector3D( paintColorC.redF(), paintColorC.greenF(), paintColorC.blueF() );
}
float dx = m_properties["maingl"].get( Fn::Property::D_DX ).toFloat();
float dy = m_properties["maingl"].get( Fn::Property::D_DY ).toFloat();
float dz = m_properties["maingl"].get( Fn::Property::D_DZ ).toFloat();
m_data[ getIdFromPos( pos.x(), pos.y(), pos.z() ) ] = paintValue;
int brushSize = m_properties["maingl"].get( Fn::Property::D_PAINTSIZE ).toInt();
for ( int i = 0; i < brushSize; ++i )
{
for ( int j = 0; j < brushSize; ++j )
{
for ( int k = 0; k < brushSize; ++k )
{
m_data[ getIdFromPos( pos.x() - i * dx, pos.y() - j * dy, pos.z() - k * dz ) ] = paintValue;
m_data[ getIdFromPos( pos.x() - i * dx, pos.y() - j * dy, pos.z() + k * dz ) ] = paintValue;
m_data[ getIdFromPos( pos.x() - i * dx, pos.y() + j * dy, pos.z() - k * dz ) ] = paintValue;
m_data[ getIdFromPos( pos.x() - i * dx, pos.y() + j * dy, pos.z() + k * dz ) ] = paintValue;
m_data[ getIdFromPos( pos.x() + i * dx, pos.y() - j * dy, pos.z() - k * dz ) ] = paintValue;
m_data[ getIdFromPos( pos.x() + i * dx, pos.y() - j * dy, pos.z() + k * dz ) ] = paintValue;
m_data[ getIdFromPos( pos.x() + i * dx, pos.y() + j * dy, pos.z() - k * dz ) ] = paintValue;
m_data[ getIdFromPos( pos.x() + i * dx, pos.y() + j * dy, pos.z() + k * dz ) ] = paintValue;
}
}
}
glDeleteTextures( 1, &m_textureGLuint );
m_textureGLuint = 0;
return true;
}
void BasicOpenGLView::paintGL()
{
// given our timer, this should be 20
int elapsed = mAnimationTimer.elapsed();
float secondsElapsed = elapsed * 0.001f;
// JB: removed light position/colour change
mLightPos.x = sin(secondsElapsed) * 20.0f;
mLightPos.z = cos(secondsElapsed) * 20.0f;
mLightPos.y = cos(secondsElapsed * 0.5f) * 20.0f;
QColor curColor;
curColor.setHsvF(fabs(cos(secondsElapsed / 20.0f)), 1.0, 1.0);
mLightCol.x = curColor.redF();
mLightCol.y = curColor.greenF();
mLightCol.z = curColor.blueF();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(mRenderOrtho)
{
float mAspectRatio = ((float)this->width()) / this->height();
mProjectionMatrix.ortho(-mDistance,
mDistance,
mDistance * mAspectRatio,
-mDistance * mAspectRatio,
-0.1,
-500.0);
}
std::map<std::string, Geometry *>::iterator it = mGeometries.begin();
while (it != mGeometries.end())
{
it->second->createModelMatrix(mUsePostMultiply);
it->second->draw(mProjectionMatrix,
mViewMatrix,
mUsePostMultiply,
mLightPos,
mLightCol,
mTextureHandle,
mBumpTextureHandle,
mAlphaTextureHandle,
mProgram);
++it;
}
}
void GLC_WorldTo3dxml::writeLineAttributes(const QColor& color)
{
m_pOutStream->writeStartElement("LineAttributes");
m_pOutStream->writeAttribute("lineType", "SOLID");
m_pOutStream->writeAttribute("thickness", "1");
m_pOutStream->writeStartElement("Color");
m_pOutStream->writeAttribute("xsi:type", "RGBAColorType");
m_pOutStream->writeAttribute("red", QString::number(color.redF()));
m_pOutStream->writeAttribute("green", QString::number(color.greenF()));
m_pOutStream->writeAttribute("blue", QString::number(color.blueF()));
m_pOutStream->writeAttribute("alpha", QString::number(color.alphaF()));
m_pOutStream->writeEndElement(); // Color
m_pOutStream->writeEndElement(); // LineAttributes
}
void Checkbox::paintEvent(QPaintEvent *e) {
Painter p(this);
float64 over = a_over.current(), checked = a_checked.current();
bool cnone = (over == 0. && checked == 0.), cover = (over == 1. && checked == 0.), cchecked = (checked == 1.);
bool cbad = !cnone && !cover && !cchecked;
QColor color;
if (cbad) {
float64 onone = (1. - over) * (1. - checked), oover = over * (1. - checked), ochecked = checked;
color.setRedF(_st.checkFg->c.redF() * onone + _st.checkFgOver->c.redF() * oover + _st.checkFgActive->c.redF() * ochecked);
color.setGreenF(_st.checkFg->c.greenF() * onone + _st.checkFgOver->c.greenF() * oover + _st.checkFgActive->c.greenF() * ochecked);
color.setBlueF(_st.checkFg->c.blueF() * onone + _st.checkFgOver->c.blueF() * oover + _st.checkFgActive->c.blueF() * ochecked);
}
QRect r(e->rect());
p.setClipRect(r);
p.fillRect(r, _st.textBg->b);
if (_checkRect.intersects(r)) {
p.setRenderHint(QPainter::HighQualityAntialiasing);
QPen pen;
if (cbad) {
pen = QPen(color);
} else {
pen = (cnone ? _st.checkFg : (cover ? _st.checkFgOver : _st.checkFgActive))->p;
color = (cnone ? _st.checkFg : (cover ? _st.checkFgOver : _st.checkFgActive))->c;
}
pen.setWidth(_st.thickness);
p.setPen(pen);
if (checked > 0) {
color.setRedF(color.redF() * checked + st::white->c.redF() * (1. - checked));
color.setGreenF(color.greenF() * checked + st::white->c.greenF() * (1. - checked));
color.setBlueF(color.blueF() * checked + st::white->c.blueF() * (1. - checked));
p.setBrush(color);
} else {
p.setBrush(st::white);
}
p.drawRoundedRect(QRectF(_checkRect).marginsRemoved(QMarginsF(_st.thickness / 2, _st.thickness / 2, _st.thickness / 2, _st.thickness / 2)), st::msgRadius, st::msgRadius);
p.setRenderHint(QPainter::HighQualityAntialiasing, false);
if (checked > 0) {
p.drawSpriteCenter(_checkRect, _st.checkIcon);
}
}
if (_checkRect.contains(r)) return;
p.setPen(_st.textFg);
p.setFont(_st.font);
p.drawTextLeft(_st.textPosition.x(), _st.textPosition.y(), width(), _text, _textWidth);
}
void RobotStateDisplay::changedAttachedBodyColor()
{
if (robot_)
{
QColor color = attached_body_color_property_->getColor();
std_msgs::ColorRGBA color_msg;
color_msg.r = color.redF();
color_msg.g = color.greenF();
color_msg.b = color.blueF();
color_msg.a = robot_alpha_property_->getFloat();
robot_->setDefaultAttachedObjectColor(color_msg);
update_state_ = true;
}
}
bool
ColorList::findColor(const char *color)
{
QColor col;
col.setAllowX11ColorNames(true);
col.setNamedColor(color);
if (!col.isValid())
return false;
_colors.last()->_list.append(
new SbColor(col.redF(), col.greenF(), col.blueF()));
return true;
}
void tst_QColor::setBlue()
{
QColor c = QColor(Qt::red).toHsv();
c.setBlue(127);
QCOMPARE(c.red(), 255);
QCOMPARE(c.green(), 0);
QCOMPARE(c.blue(), 127);
c = QColor(Qt::red).toHsv();
c.setBlueF(0.5);
QCOMPARE(c.redF(), qreal(1.0));
QCOMPARE(c.greenF(), qreal(0.0));
QVERIFY(veryFuzzyCompare(c.blueF(), 0.5));
}
// return grayscale
float Exercise123::getGrayColor(const QColor &color)
{
float gray = 0.0f;
float wr = 0.299f;
float wg = 0.587f;
float wb = 0.114f;
gray = wr * color.redF()
+ wg * color.greenF()
+ wb * color.blueF();
return gray;
}
QColor QtGradientStopsModel::color(qreal pos) const
{
PositionStopMap gradStops = stops();
if (gradStops.isEmpty())
return QColor::fromRgbF(pos, pos, pos, 1.0);
if (gradStops.contains(pos))
return gradStops[pos]->color();
gradStops[pos] = 0;
PositionStopMap::ConstIterator itStop = gradStops.constFind(pos);
if (itStop == gradStops.constBegin()) {
++itStop;
return itStop.value()->color();
}
if (itStop == --gradStops.constEnd()) {
--itStop;
return itStop.value()->color();
}
PositionStopMap::ConstIterator itPrev = itStop;
PositionStopMap::ConstIterator itNext = itStop;
--itPrev;
++itNext;
double prevX = itPrev.key();
double nextX = itNext.key();
double coefX = (pos - prevX) / (nextX - prevX);
QColor prevCol = itPrev.value()->color();
QColor nextCol = itNext.value()->color();
QColor newColor;
newColor.setRgbF((nextCol.redF() - prevCol.redF() ) * coefX + prevCol.redF(),
(nextCol.greenF() - prevCol.greenF()) * coefX + prevCol.greenF(),
(nextCol.blueF() - prevCol.blueF() ) * coefX + prevCol.blueF(),
(nextCol.alphaF() - prevCol.alphaF()) * coefX + prevCol.alphaF());
return newColor;
}
QColor KarbonGradientHelper::colorAt(qreal position, const QGradientStops &stops)
{
if (! stops.count())
return QColor();
if (stops.count() == 1)
return stops.first().second;
QGradientStop prevStop(-1.0, QColor());
QGradientStop nextStop(2.0, QColor());
// find framing gradient stops
foreach(const QGradientStop & stop, stops) {
if (stop.first > prevStop.first && stop.first < position)
prevStop = stop;
if (stop.first < nextStop.first && stop.first > position)
nextStop = stop;
}
QColor theColor;
if (prevStop.first < 0.0) {
// new stop is before the first stop
theColor = nextStop.second;
} else if (nextStop.first > 1.0) {
// new stop is after the last stop
theColor = prevStop.second;
} else {
// linear interpolate colors between framing stops
QColor prevColor = prevStop.second, nextColor = nextStop.second;
qreal colorScale = (position - prevStop.first) / (nextStop.first - prevStop.first);
theColor.setRedF(prevColor.redF() + colorScale *(nextColor.redF() - prevColor.redF()));
theColor.setGreenF(prevColor.greenF() + colorScale *(nextColor.greenF() - prevColor.greenF()));
theColor.setBlueF(prevColor.blueF() + colorScale *(nextColor.blueF() - prevColor.blueF()));
theColor.setAlphaF(prevColor.alphaF() + colorScale *(nextColor.alphaF() - prevColor.alphaF()));
}
return theColor;
}
void CombinedNavRenderer::draw()
{
QColor color = model()->data( model()->index( (int)Fn::Global::BACKGROUND_COLOR_COMBINED, 0 ) ).value<QColor>();
glClearColor( color.redF(), color.greenF(), color.blueF(), 1.0 );
//qDebug() << "combined draw";
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
setupTextures();
adjustRatios();
GLFunctions::getShader( "slice" )->bind();
// Set modelview-projection matrix
GLFunctions::getShader( "slice" )->setUniformValue( "mvp_matrix", m_mvpMatrix );
GLFunctions::getShader( "slice" )->setUniformValue( "u_renderMode", 0 );
initGeometry();
// Tell OpenGL which VBOs to use
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vboIds[ 0 ] );
glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 1 ] );
setShaderVars();
// Draw cube geometry using indices from VBO 0
glDrawElements( GL_TRIANGLES, 18, GL_UNSIGNED_SHORT, 0 );
bool renderCrosshairs = model()->data( model()->index( (int)Fn::Global::RENDER_CROSSHAIRS, 0 ) ).toBool();
if ( renderCrosshairs )
{
GLFunctions::getShader( "crosshair" )->bind();
GLFunctions::getShader( "crosshair" )->setUniformValue( "mvp_matrix", m_mvpMatrix );
QColor ccolor = model()->data( model()->index( (int)Fn::Global::CROSSHAIR_COLOR, 0 ) ).value<QColor>();
GLFunctions::getShader( "crosshair" )->setUniformValue( "u_color", ccolor.redF(), ccolor.greenF(), ccolor.blueF(), 1.0 );
// Tell OpenGL which VBOs to use
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, vboIds[ 2 ] );
glBindBuffer( GL_ARRAY_BUFFER, vboIds[ 3 ] );
// Tell OpenGL programmable pipeline how to locate vertex position data
int vertexLocation = GLFunctions::getShader( "crosshair" )->attributeLocation( "a_position" );
GLFunctions::getShader( "crosshair" )->enableAttributeArray( vertexLocation );
glVertexAttribPointer( vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof( VertexData ), 0 );
glDrawElements( GL_LINES, 12, GL_UNSIGNED_SHORT, 0 );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
}
}
void LineShader::renderPoints(QVector<QVector3D>& points, QColor color)
{
_program->setUniformValue(_uniforms["sourceColor"],
color.redF(),
color.greenF(),
color.blueF(),
1.0f);
GLuint posAttr = _attributes["posAttr"];
_program->setAttributeArray(posAttr, points.constData());
_program->enableAttributeArray(posAttr);
glDrawArrays(GL_POINTS, 0, points.size());
_program->disableAttributeArray(posAttr);
}
QByteArray BrainSourceSpaceTreeItem::createVertColor(const MatrixXf& vertices, const QColor& color) const
{
QByteArray arrayCurvatureColor;
arrayCurvatureColor.resize(vertices.rows() * 3 * (int)sizeof(float));
float *rawColorArray = reinterpret_cast<float *>(arrayCurvatureColor.data());
int idxColor = 0;
for(int i = 0; i<vertices.rows(); i++) {
rawColorArray[idxColor++] = color.redF();
rawColorArray[idxColor++] = color.greenF();
rawColorArray[idxColor++] = color.blueF();
}
return arrayCurvatureColor;
}
static void setMaterial(int face, const Material *parameters)
{
GLfloat params[17];
QColor mcolor = parameters->ambientColor();
params[0] = mcolor.redF();
params[1] = mcolor.greenF();
params[2] = mcolor.blueF();
params[3] = mcolor.alphaF();
mcolor = parameters->diffuseColor();
params[4] = mcolor.redF();
params[5] = mcolor.greenF();
params[6] = mcolor.blueF();
params[7] = mcolor.alphaF();
mcolor = parameters->specularColor();
params[8] = mcolor.redF();
params[9] = mcolor.greenF();
params[10] = mcolor.blueF();
params[11] = mcolor.alphaF();
mcolor = parameters->emittedLight();
params[12] = mcolor.redF();
params[13] = mcolor.greenF();
params[14] = mcolor.blueF();
params[15] = mcolor.alphaF();
params[16] = parameters->shininess();
glMaterialfv(face, GL_AMBIENT, params);
glMaterialfv(face, GL_DIFFUSE, params + 4);
glMaterialfv(face, GL_SPECULAR, params + 8);
glMaterialfv(face, GL_EMISSION, params + 12);
glMaterialfv(face, GL_SHININESS, params + 16);
}
QColor Canvas::modifySelectionColor(const QColor& color)
{
double colorComponents[3] = {color.redF(), color.greenF(), color.blueF()};
for (int i = 0; i < 3; ++i)
{
colorComponents[i] += colorComponents[i] > 0.5 ? -0.45 : 0.45;
}
QColor newColor(color);
newColor.setRedF(colorComponents[0]);
newColor.setGreenF(colorComponents[1]);
newColor.setBlueF(colorComponents[2]);
return newColor;
}
void LineShader::renderLines(QVector<QVector3D>& vertices, QColor lineColor)
{
_program->setUniformValue(_uniforms["sourceColor"],
lineColor.redF(),
lineColor.greenF(),
lineColor.blueF(),
1.0f);
GLuint posAttr = _attributes["posAttr"];
_program->setAttributeArray(posAttr, vertices.constData());
_program->enableAttributeArray(posAttr);
glDrawArrays(GL_LINES, 0, vertices.size());
_program->disableAttributeArray(posAttr);
}
void ColorUpdater::colorMapChange(pqPipelineRepresentation *repr,
const pqColorMapModel *model)
{
pqScalarsToColors *lut = repr->getLookupTable();
// Need the scalar bounds to calculate the color point settings
QPair<double, double> bounds = lut->getScalarRange();
vtkSMProxy *lutProxy = lut->getProxy();
// Set the ColorSpace
pqSMAdaptor::setElementProperty(lutProxy->GetProperty("ColorSpace"),
model->getColorSpace());
// Set the NaN color
QList<QVariant> values;
QColor nanColor;
model->getNanColor(nanColor);
values << nanColor.redF() << nanColor.greenF() << nanColor.blueF();
pqSMAdaptor::setMultipleElementProperty(lutProxy->GetProperty("NanColor"),
values);
// Set the RGB points
QList<QVariant> rgbPoints;
for(int i = 0; i < model->getNumberOfPoints(); i++)
{
QColor rgbPoint;
pqChartValue fraction;
model->getPointColor(i, rgbPoint);
model->getPointValue(i, fraction);
rgbPoints << fraction.getDoubleValue() * bounds.second << rgbPoint.redF()
<< rgbPoint.greenF() << rgbPoint.blueF();
}
pqSMAdaptor::setMultipleElementProperty(lutProxy->GetProperty("RGBPoints"),
rgbPoints);
lutProxy->UpdateVTKObjects();
}
bool
ColorList::findColor(const char *color, float &red, float &green, float &blue)
{
QColor col;
col.setAllowX11ColorNames(true);
col.setNamedColor(color);
if (!col.isValid())
return false;
red = col.redF();
green = col.greenF();
blue = col.blueF();
return true;
}
// Connected to colorChange on the colorWheel_
void TransferFunctionPropertyDialog::setPointColor(QColor color) {
QList<QGraphicsItem*> selection = tfEditor_->selectedItems();
vec3 newRgb = vec3(color.redF(), color.greenF(), color.blueF());
// update Color dialog to reflect the color changes
setColorDialogColor(color);
for (auto& elem : selection) {
TransferFunctionEditorControlPoint* tfcp =
qgraphicsitem_cast<TransferFunctionEditorControlPoint*>(elem);
if (tfcp) {
tfcp->getPoint()->setRGB(newRgb);
}
}
}
void tst_QColor::setGreen()
{
DEPENDS_ON(setRgb());
QColor c = QColor(Qt::blue).toHsv();
c.setGreen(127);
QCOMPARE(c.red(), 0);
QCOMPARE(c.green(), 127);
QCOMPARE(c.blue(), 255);
c = QColor(Qt::blue).toHsv();
c.setGreenF(0.5);
QCOMPARE(c.redF(), qreal(0.0));
QVERIFY(veryFuzzyCompare(c.greenF(), 0.5));
QCOMPARE(c.blueF(), qreal(1.0));
}