void PointRender<Scalar, Dim>::render()
{
if(this->points_==NULL)
{
std::cerr<<"Warning: No Point is binded to the PointRender!\n";
return;
}
//Draw points;
glDisable(GL_LIGHTING);
for (unsigned int i=0; i<this->point_num_; i++)
{
if(render_mode_ & point_mode_)
{
glPointSize(pointSize(i));
glBegin(GL_POINTS);
openGLColor3(pointColor<Scalar>(i));
openGLVertex(points_[i]);
glEnd();
}
else if(render_mode_ & sphere_mode_)
{
openGLColor3(pointColor<Scalar>(i));
openGLTranslate(points_[i]);
glutSolidSphere(pointSize(i),20,20);
openGLTranslate(-points_[i]);
}
}
}
void QEditor::setText( const QString& text )
{
// setTextFormat( Q3TextEdit::PlainText );
Q3TextEdit::setText(text);
// hack to maintain font point size
zoomTo(pointSize()-1);
zoomTo(pointSize()+1);
refresh();
}
QString ViFont::styleSheet()
{
QString result = "";
result += "color: " + mColor.name() + ";";
result += "font-size: " + QString::number(pointSize()) + "px;";
result += "font-family: " + family() + ";";
if(bold())
{
result += "font-weight: bold;";
}
return result;
}
void PhaseItem::setPhase(const QJsonObject& phase)
{
mData = phase;
setSelected(mData[STATE_IS_SELECTED].toBool());
setPos(mData[STATE_ITEM_X].toDouble(),
mData[STATE_ITEM_Y].toDouble());
// ----------------------------------------------------
// Calculate item size
// ----------------------------------------------------
qreal w = 150;
qreal h = mTitleHeight + 2*mBorderWidth + 2*mEltsMargin;
QJsonArray events = getEvents();
if(events.size() > 0)
h += events.size() * (mEltsHeight + mEltsMargin) - mEltsMargin;
QString tauStr = getTauString();
if(!tauStr.isEmpty())
h += mEltsMargin + mEltsHeight;
QFont font = qApp->font();
QString name = mData[STATE_NAME].toString();
QFontMetrics metrics(font);
int nw = metrics.width(name) + 2*mBorderWidth + 4*mEltsMargin + 2*mTitleHeight;
w = (nw > w) ? nw : w;
font.setPointSizeF(pointSize(11.f));
metrics = QFontMetrics(font);
nw = metrics.width(tauStr) + 2*mBorderWidth + 4*mEltsMargin;
w = (nw > w) ? nw : w;
for(int i=0; i<events.size(); ++i)
{
QJsonObject event = events[i].toObject();
name = event[STATE_NAME].toString();
nw = metrics.width(name) + 2*mBorderWidth + 4*mEltsMargin;
w = (nw > w) ? nw : w;
}
mSize = QSize(w, h);
update();
}
bool NuiKinfuXYZRGB::incrementPoints(NuiKinfuVertexCache* pVertexCache)
{
if (!pVertexCache)
return false;
const int inputSize = pVertexCache->pointSize();
if (0 == inputSize)
return false;
const SgVec4f* inputColors = pVertexCache->getColors();
const SgVec3f* inputVertices = pVertexCache->getVertices();
if (!inputVertices)
return false;
const int nSize = pointSize() + inputSize;
resizePoints(nSize);
int i = 0;
writeLock();
pVertexCache->readLock();
#ifdef WITH_OPENMP
#pragma omp parallel for
#endif
for (auto iter = m_pointCloud.begin(); iter != m_pointCloud.end(); iter ++, i ++)
{
iter->x = inputVertices[i][0];
iter->y = inputVertices[i][1];
iter->z = inputVertices[i][2];
if (inputColors)
{
iter->b = (unsigned char)(inputColors[i][0] * 255);
iter->g = (unsigned char)(inputColors[i][1] * 255);
iter->r = (unsigned char)(inputColors[i][2] * 255);
iter->a = 255;
}
else
{
iter->rgba = 0;
}
}
pVertexCache->readUnlock();
writeUnlock();
return true;
}
QPixmap BrushStyle::getSample(qreal scale, qreal alpha, bool selected, const QColor &color, bool emptyBackground)
{
QPixmap backgroundPixmap( (selected) ? BRUSH_SAMPLE_SELECTED_BG : BRUSH_SAMPLE_BACKGROUND);
if (emptyBackground)
backgroundPixmap.fill(Qt::transparent);
// Scale the sample
QSizeF pointSize(BRUSH_SAMPLE_SIDE, BRUSH_SAMPLE_SIDE);
if (scale != 1.0)
{
pointSize.setWidth(pointSize.width() * scale);
pointSize.setHeight(pointSize.height() * scale);
}
// Apply color and alpha
QColor alphaColor(Qt::black);
if (color.isValid())
alphaColor = color;
if (alpha != 1.0)
alphaColor.setAlphaF(alpha);
// Draw sample in the middle of background
QPainter painter(&backgroundPixmap);
painter.setRenderHint(QPainter::Antialiasing);
QRectF pointRect(QPointF(0, 0), pointSize);
pointRect.moveTo(backgroundPixmap.width() / 2 - pointSize.width() / 2, backgroundPixmap.height() / 2 - pointSize.height() / 2);
if (color.isValid() && color.value() > 210 && color.saturation() < 50)
painter.setPen("#d0d0d0");
else
painter.setPen(Qt::NoPen);
painter.setBrush(alphaColor);
painter.drawEllipse(pointRect);
painter.end();
return backgroundPixmap;
}
QFont FontPanel::selectedFont() const
{
QFont rc = m_familyComboBox->currentFont();
const QString family = rc.family();
rc.setPointSize(pointSize());
const QString styleDescription = styleString();
if (styleDescription.contains(QLatin1String("Italic")))
rc.setStyle(QFont::StyleItalic);
else if (styleDescription.contains(QLatin1String("Oblique")))
rc.setStyle(QFont::StyleOblique);
else
rc.setStyle(QFont::StyleNormal);
rc.setBold(m_fontDatabase.bold(family, styleDescription));
// Weight < 0 asserts...
const int weight = m_fontDatabase.weight(family, styleDescription);
if (weight >= 0)
rc.setWeight(weight);
return rc;
}
void HelpWidget::construct()
{
mFont = font();
mFont.setPointSize(pointSize(11));
mHyperLink = new QLabel(this);
mHyperLink->setTextFormat(Qt::RichText);
mHyperLink->setFont(mFont);
mHyperLink->setAlignment(Qt::AlignVCenter | Qt::AlignRight);
mHyperLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
mHyperLink->setOpenExternalLinks(true);
// Not yet supported with retina display in Qt 5.3
#ifndef Q_OS_MAC
QGraphicsDropShadowEffect* shadow = new QGraphicsDropShadowEffect();
shadow->setColor(Qt::black);
shadow->setBlurRadius(4);
shadow->setOffset(1, 1);
setGraphicsEffect(shadow);
#endif
}
void FontPanel::updatePointSizes(const QString &family, const QString &styleString)
{
const int oldPointSize = pointSize();
QList<int> pointSizes = m_fontDatabase.pointSizes(family, styleString);
if (pointSizes.empty())
pointSizes = QFontDatabase::standardSizes();
const bool hasSizes = !pointSizes.empty();
m_pointSizeComboBox->clear();
m_pointSizeComboBox->setEnabled(hasSizes);
m_pointSizeComboBox->setCurrentIndex(-1);
// try to maintain selection or select closest.
if (hasSizes) {
QString n;
foreach (int pointSize, pointSizes)
m_pointSizeComboBox->addItem(n.setNum(pointSize), QVariant(pointSize));
const int closestIndex = closestPointSizeIndex(oldPointSize);
if (closestIndex != -1)
m_pointSizeComboBox->setCurrentIndex(closestIndex);
}
}
void DateItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
painter->setRenderHint(QPainter::Antialiasing);
QRectF r = boundingRect();
painter->fillRect(r, mColor);
r.adjust(2, 2, -2, -2);
painter->fillRect(r, Qt::white);
QFont font = qApp->font();
font.setPointSizeF(pointSize(11));
painter->setFont(font);
painter->setPen(Qt::black);
painter->drawText(r.adjusted(0, 0, 0, -r.height()/2), Qt::AlignCenter, mDate[STATE_NAME].toString());
if(!mCalibThumb.isNull()){
painter->drawPixmap(r.adjusted(0, r.height()/2, 0, 0),
mCalibThumb,
mCalibThumb.rect());
}else{
painter->setPen(Qt::red);
painter->drawText(r.adjusted(0, r.height()/2, 0, 0), Qt::AlignCenter, tr("Not in study period"));
}
/*if(mGreyedOut)
{
painter->setPen(Painting::greyedOut);
painter->setBrush(Painting::greyedOut);
painter->drawRect(boundingRect());
}*/
}
void EventKnownItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
painter->setRenderHint(QPainter::Antialiasing);
QRectF rect = boundingRect();
QColor eventColor = QColor(mData[STATE_COLOR_RED].toInt(),
mData[STATE_COLOR_GREEN].toInt(),
mData[STATE_COLOR_BLUE].toInt());
painter->setPen(Qt::NoPen);
painter->setBrush(eventColor);
painter->drawEllipse(rect);
if(isSelected())
{
painter->setPen(QPen(Painting::mainColorDark, 3.f));
painter->setBrush(Qt::NoBrush);
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
}
double side = 40.f;
double top = 25.f;
QRectF nameRect(rect.x() + side, rect.y() + top, rect.width() - 2*side, mTitleHeight);
QRectF thumbRect(rect.x() + side, rect.y() + top + mEltsMargin + mTitleHeight, rect.width() - 2*side, mThumbH);
QRectF phasesRect(rect.x() + side, rect.y() + top + 2*mEltsMargin + mTitleHeight + mThumbH, rect.width() - 2*side, mPhasesHeight);
phasesRect.adjust(1, 1, -1, -1);
// Name
QFont font = qApp->font();
painter->setFont(font);
QFontMetrics metrics(font);
QString name = mData[STATE_NAME].toString();
name = metrics.elidedText(name, Qt::ElideRight, nameRect.width());
QColor frontColor = getContrastedColor(eventColor);
painter->setPen(frontColor);
painter->drawText(nameRect, Qt::AlignCenter, name);
// Thumb
painter->drawPixmap(thumbRect, mThumb, mThumb.rect());
// Phases
QJsonArray phases = getPhases();
int numPhases = (int)phases.size();
double w = phasesRect.width()/numPhases;
for(int i=0; i<numPhases; ++i)
{
QJsonObject phase = phases[i].toObject();
QColor c(phase[STATE_COLOR_RED].toInt(),
phase[STATE_COLOR_GREEN].toInt(),
phase[STATE_COLOR_BLUE].toInt());
painter->setPen(c);
painter->setBrush(c);
painter->drawRect(phasesRect.x() + i*w, phasesRect.y(), w, phasesRect.height());
}
if(numPhases == 0)
{
QFont font = qApp->font();
font.setPointSizeF(pointSize(11));
painter->setFont(font);
painter->fillRect(phasesRect, QColor(0, 0, 0, 180));
painter->setPen(QColor(200, 200, 200));
painter->drawText(phasesRect, Qt::AlignCenter, tr("No Phase"));
}
painter->setPen(QColor(0, 0, 0));
painter->setBrush(Qt::NoBrush);
painter->drawRect(phasesRect);
/*if(mGreyedOut)
{
painter->setPen(Painting::greyedOut);
painter->setBrush(Painting::greyedOut);
painter->drawEllipse(boundingRect());
}*/
// Border
painter->setBrush(Qt::NoBrush);
if(mMergeable)
{
painter->setPen(QPen(Qt::white, 5.f));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
painter->setPen(QPen(Painting::mainColorLight, 3.f, Qt::DashLine));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
}
else if(isSelected())
{
painter->setPen(QPen(Qt::white, 5.f));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
painter->setPen(QPen(Qt::red, 3.f));
painter->drawEllipse(rect.adjusted(1, 1, -1, -1));
}
}
void PhasesSceneArrowItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
painter->setRenderHint(QPainter::Antialiasing);
QRectF rect = boundingRect();
//painter->fillRect(rect, QColor(0, 255, 0, 30));
int penWidth = 1;
QColor color = mEditing ? QColor(77, 180, 62) : QColor(0, 0, 0);
//if(isUnderMouse())
// color = QColor(30, 50, 150);
painter->setPen(QPen(color, penWidth, mEditing ? Qt::DashLine : Qt::SolidLine));
painter->drawLine(mXStart, mYStart, mXEnd, mYEnd);
// arrows
float angle_rad = atanf(rect.width() / rect.height());
float angle_deg = angle_rad * 180. / M_PI;
QPainterPath path;
int arrow_w = 10;
int arrow_l = 15;
path.moveTo(-arrow_w/2, arrow_l/2);
path.lineTo(arrow_w/2, arrow_l/2);
path.lineTo(0, -arrow_l/2);
path.closeSubpath();
float posX = rect.width()/2;
float posY = rect.height()/2;
float posX1 = rect.width()/3;
float posX2 = 2*rect.width()/3;
float posY1 = rect.height()/3;
float posY2 = 2*rect.height()/3;
if(mXStart < mXEnd && mYStart > mYEnd)
{
if(mConstraint->mGammaType == PhaseConstraint::eGammaUnknown)
{
painter->save();
painter->translate(rect.x() + posX, rect.y() + posY);
painter->rotate(angle_deg);
painter->fillPath(path, color);
painter->restore();
}
else
{
painter->save();
painter->translate(rect.x() + posX1, rect.y() + posY2);
painter->rotate(angle_deg);
painter->fillPath(path, color);
painter->restore();
painter->save();
painter->translate(rect.x() + posX2, rect.y() + posY1);
painter->rotate(angle_deg);
painter->fillPath(path, color);
painter->restore();
}
}
else if(mXStart < mXEnd && mYStart < mYEnd)
{
if(mConstraint->mGammaType == PhaseConstraint::eGammaUnknown)
{
painter->save();
painter->translate(rect.x() + posX, rect.y() + posY);
painter->rotate(180 - angle_deg);
painter->fillPath(path, color);
painter->restore();
}
else
{
painter->save();
painter->translate(rect.x() + posX1, rect.y() + posY1);
painter->rotate(180 - angle_deg);
painter->fillPath(path, color);
painter->restore();
painter->save();
painter->translate(rect.x() + posX2, rect.y() + posY2);
painter->rotate(180 - angle_deg);
painter->fillPath(path, color);
painter->restore();
}
}
else if(mXStart > mXEnd && mYStart < mYEnd)
{
if(mConstraint->mGammaType == PhaseConstraint::eGammaUnknown)
{
painter->save();
painter->translate(rect.x() + posX, rect.y() + posY);
painter->rotate(180 + angle_deg);
painter->fillPath(path, color);
painter->restore();
}
else
{
painter->save();
painter->translate(rect.x() + posX2, rect.y() + posY1);
painter->rotate(180 + angle_deg);
painter->fillPath(path, color);
painter->restore();
painter->save();
painter->translate(rect.x() + posX1, rect.y() + posY2);
painter->rotate(180 + angle_deg);
painter->fillPath(path, color);
painter->restore();
}
}
else if(mXStart > mXEnd && mYStart > mYEnd)
{
if(mConstraint->mGammaType == PhaseConstraint::eGammaUnknown)
{
painter->save();
painter->translate(rect.x() + rect.width()/2, rect.y() + rect.height()/2);
painter->rotate(-angle_deg);
painter->fillPath(path, color);
painter->restore();
}
else
{
painter->save();
painter->translate(rect.x() + 2*rect.width()/3, rect.y() + 2*rect.height()/3);
painter->rotate(-angle_deg);
painter->fillPath(path, color);
painter->restore();
painter->save();
painter->translate(rect.x() + rect.width()/3, rect.y() + rect.height()/3);
painter->rotate(-angle_deg);
painter->fillPath(path, color);
painter->restore();
}
}
// Bubble
switch(mConstraint->mGammaType)
{
case PhaseConstraint::eGammaUnknown:
{
break;
}
case PhaseConstraint::eGammaFixed:
{
break;
}
case PhaseConstraint::eGammaRange:
{
QFont font = painter->font();
font.setPointSizeF(pointSize(11));
painter->setFont(font);
QRectF r = getBubbleRect();
painter->setPen(color);
painter->setBrush(Qt::white);
painter->drawRoundedRect(r, 5, 5);
//painter->setPen(QColor(120, 120, 120));
painter->drawText(r.adjusted(0, 0, 0, -r.height()/2), Qt::AlignCenter, QString::number(mConstraint->mGammaMin));
painter->drawText(r.adjusted(0, r.height()/2, 0, 0), Qt::AlignCenter, QString::number(mConstraint->mGammaMax));
painter->drawLine(r.x() + 4, r.y() + r.height()/2, r.x() + r.width() - 4, r.y() + r.height()/2);
break;
}
default:
break;
}
}
bool QgsSymbol::writeXML( QDomNode & item, QDomDocument & document, const QgsVectorLayer *vl ) const
{
bool returnval = false;
returnval = true; // no error checking yet
QDomElement symbol = document.createElement( "symbol" );
item.appendChild( symbol );
appendText( symbol, document, "lowervalue", mLowerValue );
appendText( symbol, document, "uppervalue", mUpperValue );
appendText( symbol, document, "label", mLabel );
QString name = pointSymbolName();
if ( name.startsWith( "svg:" ) )
{
name = name.mid( 4 );
QFileInfo fi( name );
if ( fi.exists() )
{
name = fi.canonicalFilePath();
QStringList svgPaths = QgsApplication::svgPaths();
for ( int i = 0; i < svgPaths.size(); i++ )
{
QString dir = QFileInfo( svgPaths[i] ).canonicalFilePath();
if ( !dir.isEmpty() && name.startsWith( dir ) )
{
name = name.mid( dir.size() );
break;
}
}
}
name = "svg:" + name;
}
appendText( symbol, document, "pointsymbol", name );
appendText( symbol, document, "pointsize", QString::number( pointSize() ) );
appendText( symbol, document, "pointsizeunits", pointSizeUnits() ? "mapunits" : "pixels" );
if ( vl )
{
appendField( symbol, document, *vl, "rotationclassificationfieldname", mRotationClassificationField );
appendField( symbol, document, *vl, "scaleclassificationfieldname", mScaleClassificationField );
appendField( symbol, document, *vl, "symbolfieldname", mSymbolField );
}
QDomElement outlinecolor = document.createElement( "outlinecolor" );
outlinecolor.setAttribute( "red", QString::number( mPen.color().red() ) );
outlinecolor.setAttribute( "green", QString::number( mPen.color().green() ) );
outlinecolor.setAttribute( "blue", QString::number( mPen.color().blue() ) );
symbol.appendChild( outlinecolor );
appendText( symbol, document, "outlinestyle", QgsSymbologyUtils::penStyle2QString( mPen.style() ) );
appendText( symbol, document, "outlinewidth", QString::number( mPen.widthF() ) );
QDomElement fillcolor = document.createElement( "fillcolor" );
fillcolor.setAttribute( "red", QString::number( mBrush.color().red() ) );
fillcolor.setAttribute( "green", QString::number( mBrush.color().green() ) );
fillcolor.setAttribute( "blue", QString::number( mBrush.color().blue() ) );
symbol.appendChild( fillcolor );
appendText( symbol, document, "fillpattern", QgsSymbologyUtils::brushStyle2QString( mBrush.style() ) );
appendText( symbol, document, "texturepath", QgsProject::instance()->writePath( mTextureFilePath ) );
return returnval;
}
void PhaseItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
painter->setRenderHint(QPainter::Antialiasing);
QRectF rect = boundingRect();
int rounded = 15;
QColor phaseColor = QColor(mData[STATE_COLOR_RED].toInt(),
mData[STATE_COLOR_GREEN].toInt(),
mData[STATE_COLOR_BLUE].toInt());
QColor fontColor = getContrastedColor(phaseColor);
painter->setPen(Qt::NoPen);
painter->setBrush(phaseColor);
painter->drawRoundedRect(rect, rounded, rounded);
if(mControlsVisible)
{
// Checked
QRectF cRect = checkRect();
drawCheckBoxBox(*painter, cRect, mState, Qt::white, QColor(150, 150, 150));
// Eye
QRectF eRect = eyeRect();
painter->setBrush(Qt::white);
painter->setPen(Qt::black);
painter->drawRoundedRect(eRect, 10, 10);
if(mEyeActivated)
{
QPixmap eye(":eye.png");
painter->drawPixmap(eRect, eye, eye.rect());
}
}
// Name
QRectF tr(rect.x() + mBorderWidth + 2*mEltsMargin + mTitleHeight,
rect.y() + mBorderWidth + mEltsMargin,
rect.width() - 2*mBorderWidth - 2*(mTitleHeight + 2*mEltsMargin),
mTitleHeight);
QFont font = qApp->font();
painter->setFont(font);
QFontMetrics metrics(font);
QString name = mData[STATE_NAME].toString();
name = metrics.elidedText(name, Qt::ElideRight, tr.width());
painter->setPen(fontColor);
painter->drawText(tr, Qt::AlignCenter, name);
// Change font
font.setPointSizeF(pointSize(11.f));
painter->setFont(font);
// Type (duration tau)
QString tauStr = getTauString();
if(!tauStr.isEmpty())
{
QRectF tpr(rect.x() + mBorderWidth + mEltsMargin,
rect.y() + rect.height() - mBorderWidth - mEltsMargin - mEltsHeight,
rect.width() - 2*mBorderWidth - 2*mEltsMargin,
mEltsHeight);
painter->setPen(Qt::black);
painter->setBrush(Qt::white);
painter->drawRect(tpr);
painter->drawText(tpr, Qt::AlignCenter, tauStr);
}
// Events
QRectF r(rect.x() + mBorderWidth + mEltsMargin,
rect.y() + mBorderWidth + mEltsMargin + mTitleHeight + mEltsMargin,
rect.width() - 2 * (mEltsMargin + mBorderWidth),
mEltsHeight);
QJsonArray events = getEvents();
double dy = mEltsMargin + mEltsHeight;
for(int i=0; i<events.size(); ++i)
{
QJsonObject event = events[i].toObject();
QColor eventColor(event[STATE_COLOR_RED].toInt(),
event[STATE_COLOR_GREEN].toInt(),
event[STATE_COLOR_BLUE].toInt());
if(i > 0)
r.adjust(0, dy, 0, dy);
painter->fillRect(r, eventColor);
painter->setPen(getContrastedColor(eventColor));
painter->drawText(r, Qt::AlignCenter, event[STATE_NAME].toString());
}
// Border
painter->setBrush(Qt::NoBrush);
if(isSelected())
{
painter->setPen(QPen(Qt::white, 5.f));
painter->drawRoundedRect(rect.adjusted(1, 1, -1, -1), rounded, rounded);
painter->setPen(QPen(Qt::red, 3.f));
painter->drawRoundedRect(rect.adjusted(1, 1, -1, -1), rounded, rounded);
}
}
