// That function sets some rendering parameters on the graph to visualize
void setGraphRenderingParameters(GlGraphComposite *glGraphComposite) {
GlGraphRenderingParameters *renderingParameters =
glGraphComposite->getRenderingParametersPointer();
// Activate the display of edge extremities (arrows by default)
renderingParameters->setViewArrow(true);
// No color interpolation for the edges
renderingParameters->setEdgeColorInterpolate(false);
// Size interpolation for the edges
renderingParameters->setEdgeSizeInterpolate(true);
// Scale labels to node sizes
renderingParameters->setLabelScaled(true);
}
//===================================================================
void GlGraphComposite::setRenderingParameters(const GlGraphRenderingParameters ¶meter) {
if (parameters.isElementOrdered() != parameter.isElementOrdered()) {
parameters = parameter;
graphRenderer->setGraphModified(true);
} else {
parameters = parameter;
}
}
QPixmap EdgeExtremityGlyphRenderer::render(unsigned int pluginId) {
if(_previews.find(pluginId) == _previews.end()) {
_graph->getProperty<IntegerProperty>("viewTgtAnchorShape")->setEdgeValue(_edge,pluginId);
GlOffscreenRenderer *renderer = GlOffscreenRenderer::getInstance();
renderer->setViewPortSize(16,16);
renderer->clearScene();
renderer->addGraphToScene(_graph);
GlGraphRenderingParameters renderingParamerters = renderer->getScene()->getGlGraphComposite()->getRenderingParameters();
renderingParamerters.setEdgeColorInterpolate(false);
renderingParamerters.setEdgeSizeInterpolate(false);
renderingParamerters.setViewArrow(true);
renderer->getScene()->getGlGraphComposite()->setRenderingParameters(renderingParamerters);
renderer->renderScene(true);
QImage preview = renderer->getImage();
_previews[pluginId] = QPixmap::fromImage(preview);
}
return _previews[pluginId];
}
void GlOverviewGraphicsItem::draw(bool generatePixmap) {
if(baseScene.getLayersList().empty())
return;
if (_frameWidth%2==1) {
++_frameWidth;
}
// Initialize the context avoid segfault when trying to render graph without any initialised gl context.
QGLWidget *firstWidget = GlMainWidget::getFirstQGLWidget();
firstWidget->makeCurrent();
if(!overviewBorder.parentItem()) {
//This flag is needed to don't display overview rectangle outside overview
setFlag(QGraphicsItem::ItemClipsChildrenToShape);
overview.setFlag(QGraphicsItem::ItemClipsChildrenToShape);
overview.setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
setBrush(QBrush(QColor(255,255,255,255)));
QPainterPath path;
path.addRect(_frameWidth/2, _frameWidth/2, width-_frameWidth, height-_frameWidth);
overviewBorder.setPath(path);
overviewBorder.setParentItem(this);
overview.setParentItem(&overviewBorder);
//Init lines and polygons item
for(unsigned int i=0; i<8; ++i) {
line[i].setParentItem(&overview);
if (i < 4) {
poly[i].setParentItem(&overview);
poly[i].setBrush(QBrush(QColor(0,0,0,64)));
poly[i].setPen(Qt::NoPen);
}
}
}
Color backgroundColor = baseScene.getBackgroundColor();
int bgV = backgroundColor.getV();
for(unsigned int i=0; i<8; ++i) {
if (bgV < 128) {
line[i].setPen(QColor(255, 255, 255));
}
else {
line[i].setPen(QColor(0, 0, 0));
}
if (i < 4) {
if (bgV < 128) {
poly[i].setBrush(QBrush(QColor(255,255,255,64)));
}
else {
poly[i].setBrush(QBrush(QColor(0,0,0,64)));
}
}
}
// Backup initial viewport
Vector<int,4> backupViewport=baseScene.getViewport();
// Backup initial cameras
vector<Camera> cameras;
const vector<pair<string, GlLayer*> >& layerList=baseScene.getLayersList();
for(vector<pair<string, GlLayer*> >::const_iterator it=layerList.begin(); it!=layerList.end(); ++it) {
cameras.push_back((*it).second->getCamera());
}
// Compute visible part of the scene
Camera &baseCamera=baseScene.getGraphCamera();
vector<Coord> cameraBoundingBox;
cameraBoundingBox.push_back(baseCamera.screenTo3DWorld(Coord(backupViewport[0],backupViewport[1],0)));
cameraBoundingBox.push_back(baseCamera.screenTo3DWorld(Coord(backupViewport[0]+backupViewport[2],backupViewport[1],0)));
cameraBoundingBox.push_back(baseCamera.screenTo3DWorld(Coord(backupViewport[0]+backupViewport[2],backupViewport[1]+backupViewport[3],0)));
cameraBoundingBox.push_back(baseCamera.screenTo3DWorld(Coord(backupViewport[0],backupViewport[1]+backupViewport[3],0)));
// This code modify cameraBoundingBox coords to have coords with (x,y,0)
// If we don't do this we will have invalid polygon when we do worldTo2DScreen transformations
Coord eyesVector=baseCamera.getEyes()-baseCamera.getCenter();
eyesVector=eyesVector*(1.f/eyesVector[2]);
for(unsigned int i=0; i<4; i++)
cameraBoundingBox[i]=cameraBoundingBox[i]-eyesVector*cameraBoundingBox[i][2];
// Change viewport of the scene to the overview viewport
baseScene.setViewport(0,0,width, height);
if(generatePixmap || _oldCameras.size()!=layerList.size()) {
// Center the scene
baseScene.centerScene();
_oldCameras.clear();
for(vector<pair<string, GlLayer*> >::const_iterator it=layerList.begin(); it!=layerList.end(); ++it) {
_oldCameras.push_back(it->second->getCamera());
}
}
else {
unsigned int i=0;
for(vector<pair<string, GlLayer*> >::const_iterator it=layerList.begin(); it!=layerList.end(); ++it) {
it->second->getCamera().loadCameraParametersWith(_oldCameras[i]);
++i;
}
}
// Project camera bounding box
Camera &overviewCamera=baseScene.getGraphCamera();
Coord p0=overviewCamera.worldTo2DScreen(cameraBoundingBox[0]);
Coord p1=overviewCamera.worldTo2DScreen(cameraBoundingBox[1]);
Coord p2=overviewCamera.worldTo2DScreen(cameraBoundingBox[2]);
Coord p3=overviewCamera.worldTo2DScreen(cameraBoundingBox[3]);
// Rotation of the coordinates to have no crossing lines
while(p1[0]>p3[0]) {
Coord tmp(p0);
p0=p1;
p1=p2;
p2=p3;
p3=tmp;
}
while(p1[1]<p3[1]) {
Coord tmp(p0);
p0=p3;
p3=p2;
p2=p1;
p1=tmp;
}
if(generatePixmap) {
bool edgesLabels=baseScene.getGlGraphComposite()->getRenderingParametersPointer()->isViewEdgeLabel();
bool nodesLabels=baseScene.getGlGraphComposite()->getRenderingParametersPointer()->isViewNodeLabel();
bool metaNodesLabels=baseScene.getGlGraphComposite()->getRenderingParametersPointer()->isViewMetaLabel();
baseScene.getGlGraphComposite()->getRenderingParametersPointer()->setViewEdgeLabel(false);
baseScene.getGlGraphComposite()->getRenderingParametersPointer()->setViewNodeLabel(false);
baseScene.getGlGraphComposite()->getRenderingParametersPointer()->setViewMetaLabel(false);
vector<bool> layersVisibility;
const vector<pair<string, GlLayer*> > &layersList=baseScene.getLayersList();
for(vector<pair<string, GlLayer*> >::const_iterator it=layersList.begin(); it!=layersList.end(); ++it) {
layersVisibility.push_back(it->second->isVisible());
if(it->second->isAWorkingLayer())
it->second->setVisible(false);
if(_hiddenLayers.count(it->first)!=0)
it->second->setVisible(false);
}
// Draw the scene
GlOffscreenRenderer::getInstance()->setViewPortSize(width-2*_frameWidth, height-2*_frameWidth);
GlOffscreenRenderer::getInstance()->renderExternalScene(&baseScene, true);
vector<bool>::iterator itTmp=layersVisibility.begin();
for(vector<pair<string, GlLayer*> >::const_iterator it=layersList.begin(); it!=layersList.end(); ++it) {
if((*itTmp)==true)
it->second->setVisible(true);
++itTmp;
}
GlGraphRenderingParameters *param = baseScene.getGlGraphComposite()->getRenderingParametersPointer();
param->setViewEdgeLabel(edgesLabels);
param->setViewNodeLabel(nodesLabels);
param->setViewMetaLabel(metaNodesLabels);
}
// invert applied camera transformations
unsigned int i=0;
for(vector<pair<string, GlLayer*> >::const_iterator it=layerList.begin(); it!=layerList.end(); ++it) {
it->second->getCamera()=cameras[i];
++i;
}
// invert applied viewport
baseScene.setViewport(backupViewport);
if(generatePixmap) {
// Load scene pixmap to the item
QPixmap pixmap;
QImage img = GlOffscreenRenderer::getInstance()->getImage();
pixmap.convertFromImage(img);
overview.setPos(_frameWidth, _frameWidth);
overview.setPixmap(pixmap);
}
// set lines and polygons coordinates
line[0].setLine(width-2*_frameWidth,0,p0[0],height-p0[1]);
line[1].setLine(0,0,p1[0],height-p1[1]);
line[2].setLine(0,height-2*_frameWidth,p2[0],height-p2[1]);
line[3].setLine(width-2*_frameWidth,height-2*_frameWidth,p3[0],height-p3[1]);
line[4].setLine(p0[0],height-p0[1], p1[0],height-p1[1]);
line[5].setLine(p1[0],height-p1[1], p2[0],height-p2[1]);
line[6].setLine(p2[0],height-p2[1], p3[0],height-p3[1]);
line[7].setLine(p3[0],height-p3[1], p0[0],height-p0[1]);
QVector<QPointF> tmpVect;
tmpVect.push_back(QPointF(width-2*_frameWidth,0));
tmpVect.push_back(QPointF(p0[0],height-p0[1]));
tmpVect.push_back(QPointF(p1[0],height-p1[1]));
tmpVect.push_back(QPointF(0,0));
poly[0].setPolygon(QPolygonF(tmpVect));
tmpVect.clear();
tmpVect.push_back(QPointF(0,0));
tmpVect.push_back(QPointF(p1[0],height-p1[1]));
tmpVect.push_back(QPointF(p2[0],height-p2[1]));
tmpVect.push_back(QPointF(0,height-2*_frameWidth));
poly[1].setPolygon(QPolygonF(tmpVect));
tmpVect.clear();
tmpVect.push_back(QPointF(0,height-2*_frameWidth));
tmpVect.push_back(QPointF(p2[0],height-p2[1]));
tmpVect.push_back(QPointF(p3[0],height-p3[1]));
tmpVect.push_back(QPointF(width-2*_frameWidth,height-2*_frameWidth));
poly[2].setPolygon(QPolygonF(tmpVect));
tmpVect.clear();
tmpVect.push_back(QPointF(width-2*_frameWidth,height-2*_frameWidth));
tmpVect.push_back(QPointF(p3[0],height-p3[1]));
tmpVect.push_back(QPointF(p0[0],height-p0[1]));
tmpVect.push_back(QPointF(width-2*_frameWidth,0));
poly[3].setPolygon(QPolygonF(tmpVect));
QPen pen(QColor(_frameColor[0], _frameColor[1], _frameColor[2], _frameColor[3]));
pen.setWidth(_frameWidth);
pen.setJoinStyle(Qt::MiterJoin);
overviewBorder.setPen(pen);
}
bool SceneLayersModel::setData(const QModelIndex &index, const QVariant &value, int role) {
if (index.column() == 0 || role != Qt::CheckStateRole)
return false;
if (GRAPH_COMPOSITE_IDS.contains(index.internalId())) {
quint32 id = index.internalId();
GlGraphRenderingParameters* p = _scene->getGlGraphComposite()->getRenderingParametersPointer();
if (index.column() == 1) {
bool visible = value.value<int>() == (int)(Qt::Checked);
if (id == NODES_ID)
p->setDisplayNodes(visible);
else if (id == EDGES_ID)
p->setDisplayEdges(visible);
else if (id == META_NODES_ID)
p->setDisplayMetaNodes(visible);
else if (id == NODES_LABELS_ID)
p->setViewNodeLabel(visible);
else if (id == EDGES_LABELS_ID)
p->setViewEdgeLabel(visible);
else if (id == META_NODES_LABELS_ID)
p->setViewMetaLabel(visible);
}
else if (index.column() == 2) {
int stencil = (value.value<int>() == (int)(Qt::Checked) ? FULL_STENCIL : NO_STENCIL);
if (id == NODES_ID)
p->setNodesStencil(stencil);
else if (id == EDGES_ID)
p->setEdgesStencil(stencil);
else if (id == SELECTED_NODES_ID)
p->setSelectedNodesStencil(stencil);
else if (id == SELECTED_EDGES_ID)
p->setSelectedEdgesStencil(stencil);
else if (id == META_NODES_ID)
p->setMetaNodesStencil(stencil);
else if (id == SELECTED_META_NODES_ID)
p->setSelectedMetaNodesStencil(stencil);
else if (id == META_NODES_LABELS_ID)
p->setMetaNodesLabelStencil(stencil);
else if (id == NODES_LABELS_ID)
p->setNodesLabelStencil(stencil);
else if (id == EDGES_LABELS_ID)
p->setEdgesLabelStencil(stencil);
}
emit drawNeeded(_scene);
return true;
}
GlSimpleEntity* entity = NULL;
GlLayer* layer = NULL;
if (!index.parent().isValid()) {
layer = reinterpret_cast<GlLayer*>(index.internalPointer());
entity = layer->getComposite();
}
else
entity = reinterpret_cast<GlSimpleEntity*>(index.internalPointer());
bool val = value.value<int>() == (int)Qt::Checked;
if (index.column() == 1) {
if (layer)
layer->setVisible(val);
entity->setVisible(val);
}
else if (index.column() == 2)
entity->setStencil(val ? FULL_STENCIL : 0xFFFF);
emit drawNeeded(_scene);
return true;
}
QVariant SceneLayersModel::data(const QModelIndex &index, int role) const {
GlComposite* parent = NULL;
GlSimpleEntity* entity = NULL;
GlLayer* layer = NULL;
if (GRAPH_COMPOSITE_IDS.contains(index.internalId())) {
quint32 id = index.internalId();
GlGraphRenderingParameters* parameters = _scene->getGlGraphComposite()->getRenderingParametersPointer();
QString display;
int stencil = NO_STENCIL;
bool visible = false;
if (id == NODES_ID) {
display = trUtf8("Nodes");
stencil = parameters->getNodesStencil();
visible = parameters->isDisplayNodes();
}
else if (id == EDGES_ID) {
display = trUtf8("Edges");
stencil = parameters->getEdgesStencil();
visible = parameters->isDisplayEdges();
}
else if (id == SELECTED_NODES_ID) {
display = trUtf8("Selected nodes");
stencil = parameters->getSelectedNodesStencil();
visible = parameters->isDisplayNodes();
}
else if (id == SELECTED_EDGES_ID) {
display = trUtf8("Selected edges");
stencil = parameters->getSelectedEdgesStencil();
visible = parameters->isDisplayEdges();
}
else if (id == META_NODES_ID) {
display = trUtf8("Meta nodes content");
stencil = parameters->getMetaNodesStencil();
visible = parameters->isDisplayMetaNodes();
}
else if (id == SELECTED_META_NODES_ID) {
display = trUtf8("Selected meta nodes");
stencil = parameters->getSelectedMetaNodesStencil();
visible = parameters->isDisplayMetaNodes();
}
else if (id == META_NODES_LABELS_ID) {
display = trUtf8("Meta nodes content labels");
stencil = parameters->getMetaNodesLabelStencil();
visible = parameters->isViewMetaLabel();
}
else if (id == NODES_LABELS_ID) {
display = trUtf8("Nodes labels");
stencil = parameters->getNodesLabelStencil();
visible = parameters->isViewNodeLabel();
}
else if (id == EDGES_LABELS_ID) {
display = trUtf8("Edges labels");
stencil = parameters->getEdgesLabelStencil();
visible = parameters->isViewEdgeLabel();
}
if (role == Qt::DisplayRole && index.column() == 0)
return display;
if (role == Qt::CheckStateRole) {
if (index.column() == 1)
return (visible ? Qt::Checked : Qt::Unchecked);
if (index.column() == 2)
return (stencil == NO_STENCIL ? Qt::Unchecked : Qt::Checked);
}
return QVariant();
}
if (!index.parent().isValid()) {
layer = reinterpret_cast<GlLayer*>(index.internalPointer());
entity = layer->getComposite();
}
else {
entity = reinterpret_cast<GlSimpleEntity*>(index.internalPointer());
parent = entity->getParent();
}
if (role == Qt::DisplayRole && index.column() == 0) {
if (layer != NULL)
return layer->getName().c_str();
std::map<std::string, GlSimpleEntity*> siblings = parent->getGlEntities();
for(std::map<std::string, GlSimpleEntity*>::iterator it = siblings.begin(); it != siblings.end(); ++it) {
if (it->second == entity)
return it->first.c_str();
}
}
if (role == Qt::FontRole && layer != NULL) {
QFont f;
f.setBold(true);
return f;
}
if (role == Qt::CheckStateRole) {
if (index.column() == 1)
return (entity->isVisible() ? Qt::Checked : Qt::Unchecked);
if (index.column() == 2)
return (entity->getStencil() == NO_STENCIL ? Qt::Unchecked : Qt::Checked);
}
if (role == Qt::TextAlignmentRole && index.column() != 0)
return Qt::AlignCenter;
return QVariant();
}
