QGraphicsItem *addSmiley() {
QPen thickPen(Qt::black);
thickPen.setWidth(2);
// add face
QGraphicsEllipseItem *face = new QGraphicsEllipseItem(QRect(-50, -50, 100, 100));
face->setPen(Qt::NoPen);
face->setBrush(Qt::yellow);
// add eyes
QGraphicsEllipseItem *leftEye = new QGraphicsEllipseItem(QRectF(-6, -12, 12, 24), face);
leftEye->setPen(thickPen);
leftEye->setBrush(Qt::white);
leftEye->setPos(-15, -25);
QGraphicsEllipseItem *rightEye = new QGraphicsEllipseItem(QRectF(-6, -12, 12, 24), face);
rightEye->setPen(thickPen);
rightEye->setBrush(Qt::white);
rightEye->setPos(15, -25);
// add smile
QPainterPath smileArc;
QRect rect(-33, -15, 66, 50);
smileArc.arcMoveTo(rect, 0);
smileArc.arcTo(rect, 0, -180);
QGraphicsPathItem *smile = new QGraphicsPathItem(smileArc, face);
smile->setPen(thickPen);
return face;
}
Knob::Knob()
: QGraphicsEllipseItem(-50, -50, 100, 100)
{
setAcceptTouchEvents(true);
setBrush(Qt::lightGray);
QGraphicsEllipseItem *leftItem = new QGraphicsEllipseItem(0, 0, 20, 20, this);
leftItem->setPos(-40, -10);
leftItem->setBrush(Qt::darkGreen);
QGraphicsEllipseItem *rightItem = new QGraphicsEllipseItem(0, 0, 20, 20, this);
rightItem->setPos(20, -10);
rightItem->setBrush(Qt::darkRed);
}
void GraphicsBoard::setHighlights(const QList<Chess::Square>& squares)
{
clearHighlights();
if (squares.isEmpty())
return;
TargetHighlights* targets = new TargetHighlights(this);
QRectF rect;
rect.setSize(QSizeF(m_squareSize / 3, m_squareSize / 3));
rect.moveCenter(QPointF(0, 0));
QPen pen(Qt::white, m_squareSize / 20);
QBrush brush(Qt::black);
for (const auto& sq : squares)
{
QGraphicsEllipseItem* dot = new QGraphicsEllipseItem(rect, targets);
dot->setCacheMode(DeviceCoordinateCache);
dot->setPen(pen);
dot->setBrush(brush);
dot->setPos(squarePos(sq));
}
m_highlightAnim = new QPropertyAnimation(targets, "opacity");
targets->setParent(m_highlightAnim);
m_highlightAnim->setStartValue(0.0);
m_highlightAnim->setEndValue(1.0);
m_highlightAnim->setDuration(500);
m_highlightAnim->setEasingCurve(QEasingCurve::InOutQuad);
m_highlightAnim->start(QAbstractAnimation::KeepWhenStopped);
}
void LVL_ModeCircle::mouseMove(QGraphicsSceneMouseEvent *mouseEvent)
{
if(!scene) return;
LvlScene *s = dynamic_cast<LvlScene *>(scene);
if(!LvlPlacingItems::layer.isEmpty() && LvlPlacingItems::layer!="Default")
s->setLabelBoxItem(true, mouseEvent->scenePos(), LvlPlacingItems::layer + ", " +
QString::number( mouseEvent->scenePos().toPoint().x() ) + "x" +
QString::number( mouseEvent->scenePos().toPoint().y() )
);
else
s->setLabelBoxItem(false);
if(s->m_cursorItemImg && s->m_cursorItemImg->isVisible())
{
QGraphicsEllipseItem * cur = dynamic_cast<QGraphicsEllipseItem *>(s->m_cursorItemImg);
QPoint hw = s->applyGrid( mouseEvent->scenePos().toPoint(),
LvlPlacingItems::gridSz,
LvlPlacingItems::gridOffset);
QSize hs = QSize( (long)fabs(drawStartPos.x() - hw.x()), (long)fabs( drawStartPos.y() - hw.y() ) );
cur->setRect(0,0, hs.width(), hs.height());
cur->setPos(((hw.x() < drawStartPos.x() )? hw.x() : drawStartPos.x()),
((hw.y() < drawStartPos.y() )? hw.y() : drawStartPos.y()));
}
}
/// @brief constructor
///
/// @param parent parent widget
ScrollScene::ScrollScene (QWidget * parent, ResultsTab *resultsTab)
: QGraphicsScene (parent)
, resultsTab (resultsTab)
, testing (false)
, text1 (new QGraphicsTextItem ("Scroll until the red circle is centered. Press SPACE to begin."))
, text2 (new QGraphicsTextItem ("Scroll until the red circle is centered. Press SPACE to begin."))
{
// set the text font
text1->setFont (QFont ("Arial", 18, QFont::Bold));
text2->setFont (QFont ("Arial", 18, QFont::Bold));
QRectF r = text1->boundingRect ();
const size_t NCIRCLES = 100;
text1->setPos (-r.width () / 2, -4 * RADIUS);
text2->setPos (-r.width () / 2, NCIRCLES * RADIUS * 2);
// add it
addItem (text1);
addItem (text2);
// set background of client area
setBackgroundBrush (Qt::white);
circles.resize (NCIRCLES);
for (size_t i = 0; i < circles.size (); ++i)
{
QGraphicsEllipseItem *c = new QGraphicsEllipseItem (0);
c->setRect (-RADIUS, -RADIUS, RADIUS, RADIUS);
int y = i * RADIUS * 2;
c->setPos (0, y);
addItem (c);
circles[i] = c;
}
}
void MainWindow::slotAddEllipseItem() //在场景中加入一个椭圆形图元
{
QGraphicsEllipseItem *item = new QGraphicsEllipseItem(QRectF(0,0,80, 60));
item->setPen(Qt::NoPen);
item->setBrush(QColor(qrand()%256,qrand()%256,qrand()%256));
item->setFlag(QGraphicsItem::ItemIsMovable);
scene->addItem(item);
item->setPos((qrand()%int(scene->sceneRect().width()))-200,(qrand()%int(scene->sceneRect().height()))-200);
}
SEXP
scene_addPoints(SEXP scene, SEXP x, SEXP y, SEXP radius)
{
QGraphicsScene* s = unwrapQObject(scene, QGraphicsScene);
int i, n = length(x);
for (i = 0; i < n; i++) {
// QGraphicsEllipseItem *item = s->addEllipse(REAL(x)[i], REAL(y)[i], REAL(radius)[0], REAL(radius)[0]);
QGraphicsEllipseItem *item = s->addEllipse(0.0, 0.0, REAL(radius)[0], REAL(radius)[0]);
item->setPos(REAL(x)[i], REAL(y)[i]);
item->setFlags(QGraphicsItem::ItemIsSelectable |
QGraphicsItem::ItemIgnoresTransformations);
}
return R_NilValue;
}
void StitcherView::drawConstraintFit(geometrically_constrained_system *gc){
for(int i = 0;i<gc->n_constraints;i++){
GeometryConstraintType type = gc->constraints[i].type;
double fit = gc->constraints[i].best_fit;
if(type == RadialLineConstraint){
qreal x1,x2,y1,y2;
qreal scale = 10000;
x1 = cos(fit)*scale;
y1 = sin(fit)*scale;
x2 = -x1;
y2 = -y1;
QGraphicsLineItem * item = new QGraphicsLineItem(x1,y1,x2,y2);
QPen p = item->pen();
p.setStyle(Qt::DashLine);
QVector<qreal> dashes;
dashes << 25 << 15;
p.setDashPattern(dashes);
p.setColor(Qt::white);
item->setPen(p);
item->setZValue(10000);
scene()->addItem(item);
constraintFit.append(item);
}else if(type == CircleConstraint){
double radius = fit;
QGraphicsEllipseItem * item = new QGraphicsEllipseItem(-radius,-radius,2*radius,2*radius);
QPen p = item->pen();
p.setStyle(Qt::DashLine);
QVector<qreal> dashes;
dashes << 25 << 15;
p.setDashPattern(dashes);
p.setColor(Qt::white);
item->setPen(p);
item->setZValue(10000);
scene()->addItem(item);
constraintFit.append(item);
}
sp_vector ** cp_g = control_point_list_to_global(gc->constraints[i].points,gc->constraints[i].n_points);
QColor color = QColor::fromHsvF(1.0/3+(double)i/gc->n_constraints,1,1,1);
for(int j = 0;j<gc->constraints[i].n_points;j++){
QGraphicsEllipseItem * point = new QGraphicsEllipseItem(-4,-4,8,8);
point->setZValue(10001);
point->setPos(sp_vector_get(cp_g[j],0),sp_vector_get(cp_g[j],1));
point->setPen(QPen(color, 2));
point->setFlags(point->flags() | QGraphicsItem::ItemIgnoresTransformations);
scene()->addItem(point);
constraintFit.append(point);
}
}
}
void CircleWidget::updateScene()
{
const qreal PI = qAtan(1.0)*4;
int count=_list.size();
qreal pitch = (2*PI) / count;
_scene->clear();
QRect r = ui->graphicsView->geometry();
QBrush b = QBrush(QColor(Qt::black));
QPen p = QPen(b, 4.0);
qreal topleftX = r.width()/8;
qreal topleftY = r.height()/8;
qreal radiusX = 3*topleftX;
qreal radiusY = 3*topleftY;
QGraphicsEllipseItem* ellipse = _scene->addEllipse(0, 0, radiusX*2, radiusY*2, p);
ellipse->setPos(topleftX, topleftY);
qreal sizeX = topleftX*2;
qreal sizeY = topleftY*2;
int curs = 0;
typedef QMap<std::string, IdentityWidget*>::const_iterator itList;
for (itList it=_list.constBegin(); it!=_list.constEnd(); ++it){
QPixmap pix = it.value()->getImage();
pix = pix.scaled(sizeX, sizeY);
QGraphicsPixmapItem* item = _scene->addPixmap(pix);
qreal x = (qCos(curs*pitch)*radiusX)-(sizeX/2)+topleftX+radiusX;
qreal y = (qSin(curs*pitch)*radiusY)-(sizeY/2)+topleftY+radiusY;
item->setPos(QPointF(x, y));
QString name = it.value()->getName();
QString idKey = it.value()->keyId();
QString gxsId = it.value()->gxsId();
if (idKey == gxsId) gxsId.clear();
item->setToolTip(name.append("\n")
.append(idKey).append(gxsId.isEmpty()?"":"\n")
.append(gxsId));
++curs;
}//for (itList it=_list.constBegin(); it!=_list.constEnd(); ++it)
emit imageUpdated();
}
MyScene::MyScene(qreal x,qreal y,qreal width,qreal height,QObject *parent):QGraphicsScene(x,y,width,height,parent) {
// 預計加一個圓形,然後,執徑逐漸變大
QGraphicsEllipseItem *ball = new QGraphicsEllipseItem(-15,-15,30,30);
ball->setPen(QPen(QColor(125,125,125,125),3));
addItem(ball);
ball->setPos(this->width()/2,this->height()/2); // setPos(x,y):設定此小座標的原點在此(x,y)
timeLine = new QTimeLine;
QGraphicsItemAnimation *headAnimation = new QGraphicsItemAnimation;
headAnimation->setItem(ball);
headAnimation->setTimeLine(timeLine);
headAnimation->setScaleAt(1,10,10);
timeLine->setUpdateInterval(1000 / 25);
timeLine->setCurveShape(QTimeLine::SineCurve);
timeLine->setLoopCount(0);
timeLine->setDuration(2000);
timeLine->start();
}
void B2WorldView::createWorldItems()
{
qDebug() << "~ " << __PRETTY_FUNCTION__;
if(_world && _scene) {
// create world ground
QGraphicsRectItem *groundItem = _scene->addRect(-100, -0.5, 200, 1);
groundItem->setBrush(Qt::gray);
groundItem->setPos(0, -0.5);
// ground body define
b2BodyDef groundBD;
groundBD.type = b2_staticBody;
groundBD.position.Set(0.0f, 0.5f);
// ground shape define
b2PolygonShape groundSD;
groundSD.SetAsBox(100.0f, 0.5f, b2Vec2(0.0f, 0.0f), 0);
// ground fixture define
b2FixtureDef groundFD;
groundFD.shape = &groundSD;
groundFD.density = 0.1f;
groundFD.friction = 5.0f;
b2Body* groundBody = _world->CreateBody(&groundBD);
groundBody->CreateFixture(&groundFD);
groundItem = _scene->addRect(-1.0, -2.0, 2.0, 4.0);
groundItem->setBrush(Qt::blue);
groundItem->setPos(-100.0, -1.0);
groundSD.SetAsBox(1.0f, 2.0f, b2Vec2(-100.0f, 0.5f), 0);
groundBody->CreateFixture(&groundFD);
groundItem = _scene->addRect(-1.0, -2.0, 2.0, 4.0);
groundItem->setBrush(Qt::blue);
groundItem->setPos(100.0, -0.5);
groundSD.SetAsBox(1.0f, 2.0f, b2Vec2(100.0f, 1.0f), 0);
groundBody->CreateFixture(&groundFD);
groundItem = _scene->addRect(-3.0, -0.5, 6.0, 1.0);
groundItem->setBrush(Qt::blue);
groundItem->setPos(5, -2.0);
groundItem->setRotation(-(PI / 4.0 * 360.0) / (2 * PI));
groundSD.SetAsBox(3.0f, 0.5f, b2Vec2(5.0f, 1.5f), PI/4.0);
groundBody->CreateFixture(&groundFD);
groundItem = _scene->addRect(-3.0, -0.5, 6.0, 1.0);
groundItem->setBrush(Qt::blue);
groundItem->setPos(3.5, -1.5);
groundItem->setRotation(-(PI / 8.0 * 360.0) / (2 * PI));
groundSD.SetAsBox(3.0f, 0.5f, b2Vec2(3.5f, 1.0f), PI/8.0);
groundBody->CreateFixture(&groundFD);
groundItem = _scene->addRect(-3.0, -0.5, 6, 1.0);
groundItem->setBrush(Qt::blue);
groundItem->setPos(9, -2.0);
groundItem->setRotation(-(-PI / 4.0 * 360.0) / (2 * PI));
groundSD.SetAsBox(3.0f, 0.5f, b2Vec2(9.0f, 1.5f), -PI/4.0);
groundBody->CreateFixture(&groundFD);
groundItem = _scene->addRect(-3, -0.5, 6, 1.0);
groundItem->setBrush(Qt::blue);
groundItem->setPos(10.5, -1.5);
groundItem->setRotation(-(-PI / 8.0 * 360.0) / (2 * PI));
groundSD.SetAsBox(3.0f, 0.5f, b2Vec2(10.5f, 1.0f), -PI/8.0);
groundBody->CreateFixture(&groundFD);
// add random shit //
b2CircleShape circleShape;
b2FixtureDef circleFixture;
circleFixture.shape = &circleShape;
circleFixture.density = 0.01;
circleFixture.friction = 0.1;
circleFixture.restitution = 0.5;
for (int i = 0; i < 30; i++) {
qreal radius = qrand()%20*0.01+0.02;
QGraphicsEllipseItem* circle = _scene->addEllipse(-radius, -radius, radius*2, radius*2);
circle->setBrush(Qt::green);
circle->setPos(qrand()%35+15.0, -1.5);
_circles << circle;
circleShape.m_radius = radius;
b2BodyDef circleBD;
circleBD.type = b2_dynamicBody;
circleBD.position.Set(circle->pos().x(), -circle->pos().y());
circleBD.allowSleep = true;
circleBD.linearDamping = 0.1;
circleBD.angularDamping = 0.1;
b2Body* circleBody = _world->CreateBody(&circleBD);
circleBody->CreateFixture(&circleFixture);
_circleBodies << circleBody;
}
// create kart
_kart = new B2Kart(_world, _scene);
}
}
QGraphicsEllipseItem *GraphRenderer::addNode(repo::core::model::RepoNode *node, float row, float column)
{
float spacing = nodeDiameter / 4.0f;
QPen pen;
pen.setWidthF(penWidth);
QBrush brush(Qt::SolidPattern);
QColor dark;
QColor light;
switch (node->getTypeAsEnum())
{
case repo::core::model::NodeType::CAMERA :
dark = Qt::darkMagenta;
light = Qt::magenta;
break;
case repo::core::model::NodeType::MATERIAL :
dark = Qt::darkRed;
light = Qt::red;
break;
case repo::core::model::NodeType::MESH :
dark = Qt::darkBlue;
light = Qt::blue;
break;
case repo::core::model::NodeType::METADATA :
dark = Qt::darkCyan;
light = Qt::cyan;
break;
case repo::core::model::NodeType::REFERENCE :
dark = repo::gui::primitive::RepoColor::fromHex("#6e8b3d"); // DarkOliveGreen4
light = repo::gui::primitive::RepoColor::fromHex("#caff70"); // DarkOliveGreen1
break;
case repo::core::model::NodeType::REVISION :
dark = repo::gui::primitive::RepoColor::fromHex("#68228b"); // DarkOrchid4
light = repo::gui::primitive::RepoColor::fromHex("#bf3eff"); // DarkOrchid1
break;
case repo::core::model::NodeType::TEXTURE :
dark = Qt::darkYellow;
light = Qt::yellow;
break;
case repo::core::model::NodeType::TRANSFORMATION :
dark = Qt::darkGreen;
light = Qt::green;
break;
case repo::core::model::NodeType::UNKNOWN :
default :
dark = Qt::darkGray;
light = Qt::gray;
}
pen.setColor(dark);
brush.setColor(light);
qreal x = column * (nodeDiameter + spacing);
qreal y = row * (nodeDiameter + spacing) * 4;
QGraphicsEllipseItem *ellipse = addEllipse(
0, 0, nodeDiameter, nodeDiameter, pen, brush);
ellipse->setPos(x, y);
ellipse->setZValue(1.0f);
//--------------------------------------------------------------------------
QString toolTip;
toolTip += tr("_id") + "\t: '" + uuidToQString(node->getUniqueID()) + "',\n";
toolTip += tr("sid") + "\t: '" + uuidToQString(node->getSharedID()) + "',\n";
if (!node->getName().empty())
toolTip += tr("name") + "\t: '" + QString::fromStdString(node->getName()) + "',\n";
toolTip += tr("type") + "\t: '" + QString::fromStdString(node->getType()) + "'";
ellipse->setToolTip(toolTip);
//--------------------------------------------------------------------------
QVariant var;
var.setValue(node);
ellipse->setData(0, var);
//--------------------------------------------------------------------------
return ellipse;
}
void RayDisplayScene::initLeds()
{
QList<int> sizes;
//sizes << 64 << 40 << 64 << 40;
sizes << 48 << 32 << 48 << 32;
Q_ASSERT(4 == sizes.size());
QVector<QVector<QPointF>> sidedReceiversPos;
QVector<QVector<QPointF>> sidedSendersPos;
sidedReceiversPos.resize(sizes.size());
mSidedReceivers.resize(sizes.size());
sidedSendersPos.resize(sizes.size());
int allReceivers = 0;
for (int i = 0; i < sizes.size(); i++) {
Q_ASSERT(sizes.at(i) % 8 == 0);
sidedReceiversPos[i].reserve(sizes.at(i));
mSidedReceivers[i].reserve(sizes.at(i));
sidedSendersPos[i].reserve(sizes.at(i) / 8);
allReceivers += sizes.at(i) / 8;
}
mReceivers.reserve(allReceivers * 8);
mSenders.reserve(allReceivers);
// top left-to-right
for (int i = 0; i < sizes.at(0); i++) {
QGraphicsEllipseItem *r;
const int x = i * 10;
const int y = 0;
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::black), 2));
const int sideId = 0;
const QPointF p(x, y);
sidedReceiversPos[sideId] << p;
r->setPos(p);
mReceivers.append(r);
mSidedReceivers[sideId] << r;
}
// right top-to-bottom
for (int i = 0; i < sizes.at(1); i++) {
QGraphicsEllipseItem *r;
const int x = sizes.at(0) * 10;
const int y = i * 10 - (0 - 5);
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::black), 2));
const int sideId = 1;
const QPointF p(x, y);
sidedReceiversPos[sideId] << p;
r->setPos(p);
mReceivers.append(r);
mSidedReceivers[sideId] << r;
}
// bottom right-to-left
for (int i = 0; i < sizes.at(2); i++) {
QGraphicsEllipseItem *r;
const int x = i * -10 + sizes.at(0) * 10 - 10;
const int y = sizes.at(1) * 10;
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::black), 2));
const int sideId = 2;
const QPointF p(x, y);
sidedReceiversPos[sideId] << p;
r->setPos(p);
mReceivers.append(r);
mSidedReceivers[sideId] << r;
}
// left bottom-to-top
for (int i = 0; i < sizes.at(3); i++) {
QGraphicsEllipseItem *r;
const int x = -5;
const int y = i * -10 + ((sizes.at(1)) * 10 - 5);
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::black), 2));
const int sideId = 3;
const QPointF p(x, y);
sidedReceiversPos[sideId] << p;
r->setPos(p);
mReceivers.append(r);
mSidedReceivers[sideId] << r;
}
// top left-to-right
for (int i = 0; i < (sizes.at(0) / 8); i++) {
QGraphicsEllipseItem *r;
const int x = i * 80 + 35;
const int y = 0;
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::red), 2));
const int sideId = 0;
const QPointF p(x, y);
sidedSendersPos[sideId] << p;
r->setPos(p);
mSenders.append(Sender{r, 270, sideId});
}
// right top-to-bottom
for (int i = 0; i < (sizes.at(1) / 8); i++) {
QGraphicsEllipseItem *r;
const int x = sizes.at(0) * 10;
const int y = i * 80 - (0 - 40);
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::red), 2));
const int sideId = 1;
const QPointF p(x, y);
sidedSendersPos[sideId] << p;
r->setPos(p);
mSenders.append(Sender{r, 180, sideId});
}
// bottom right-to-left
for (int i = 0; i < (sizes.at(2) / 8); i++) {
QGraphicsEllipseItem *r;
const int x = i * -80 + (sizes.at(0) * 10 - 40 - 5);
const int y = sizes.at(1) * 10;
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::red), 2));
const int sideId = 2;
const QPointF p(x, y);
sidedSendersPos[sideId] << p;
r->setPos(p);
mSenders.append(Sender{r, 90, sideId});
}
// left bottom-to-top
for (int i = 0; i < (sizes.at(3) / 8); i++) {
QGraphicsEllipseItem *r;
const int x = -5;
const int y = i * -80 + ((sizes.at(1) * 10) - 40);
r = addEllipse(0, 0, 5, 5, QPen(QBrush(Qt::red), 2));
const int sideId = 3;
const QPointF p(x, y);
sidedSendersPos[sideId] << p;
r->setPos(p);
mSenders.append(Sender{r, 0, sideId});
}
// mTI = new CvTracker(sidedReceiversPos, sidedSendersPos, this);
emit publishSizes(sidedReceiversPos, sidedSendersPos);
mCollidedRays.clear();
mCollidedRays.resize(mSenders.size());
mCollidedRaysGraphics.clear();
mCollidedRaysGraphics.resize(mSenders.size());
mTriangles.clear();
mTriangles.resize(mSenders.size());
/*QVector<cv::Point> points;
points << cv::Point2i(0, 0);
points << cv::Point2i(0, 100);
points << cv::Point2i(100, 0);
const cv::Point *pointsPtr[1] = {points.data()};
int size = points.size();
cv::Scalar color = cv::Scalar(127);
cv::Mat m = mMats[0];
cv::line(m, cv::Point2i(0, 0), cv::Point2i(100, 100), color, 22);
cv::imshow("plepleple", m);
cv::fillConvexPoly(m, points.data(), size, color);
qDebug() << "before";
T::sleep(4);
qDebug() << "after";
cv::imshow("plepleple", m);*/
}
