double Marker::calculater(const Node &sp, const Node &cp) { double x = cp.getX() - sp.getX(); double y = cp.getY()- sp.getY(); double l = sqrt(x*x+y*y); return l; }
void DrawTreeCairo::DrawSpeciesEdgesWithContour() { Color& cfill = config->species_edge_color; Color& cline = config->species_edge_contour_color; cairo_set_line_width(cr, s_contour_width); cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND); cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND); const double midnode = leafWidth; Node *root = species->getRootNode(); cairo_move_to(cr, 0, root->getY()+midnode); cairo_rel_line_to(cr, root->getX(), 0); cairo_rel_line_to(cr,0, -(midnode * 2) ); cairo_rel_line_to(cr, -(root->getX()), 0); cairo_close_path(cr); cairo_set_source_rgba(cr, cline.red, cline.green, cline.blue, 1); cairo_stroke_preserve(cr); cairo_set_source_rgba(cr, cfill.red, cfill.green, cfill.blue, 1); cairo_fill(cr); for ( Node *n = species->preorder_begin(); n != 0; n = species->preorder_next(n) ) { const double x = n->getX(); const double y = n->getY(); if (!n->isLeaf()) { double pmidx; double pmidy; intersection(x, y - midnode, n->getLeftChild()->getX(), n->getLeftChild()->getY()-midnode, x, y + midnode, n->getRightChild()->getX(), n->getRightChild()->getY()+midnode, pmidx, pmidy); cairo_move_to(cr, x, y + midnode); cairo_rel_line_to(cr,n->getLeftChild()->getX()-x,n->getLeftChild()->getY()-y); cairo_rel_line_to(cr, 0, -(midnode * 2) ); cairo_line_to(cr, pmidx, pmidy); cairo_line_to(cr,n->getRightChild()->getX(),n->getRightChild()->getY()+midnode); cairo_rel_line_to(cr, 0, - (midnode * 2) ); cairo_line_to(cr, x, y - midnode); cairo_close_path(cr); cairo_set_source_rgba(cr, cline.red, cline.green, cline.blue, 1); cairo_stroke_preserve(cr); cairo_set_source_rgba(cr, cfill.red, cfill.green, cfill.blue, 1); cairo_fill(cr); } } }
void LSPositionFindingAStar::calculateHeuristics(Node& targetNode) { for(int x=0; x< _GRID_RESOLUTION_X_AXIS; x++) { for(int y=0; y< _GRID_RESOLUTION_Y_AXIS; y++) { int x_temp = abs(m_map[x][y].getX() - targetNode.getX()); int y_temp = abs(m_map[x][y].getY() - targetNode.getY()); m_map[x][y].setH((x_temp+y_temp)*10); m_map[x][y].setParentNode(nullptr); m_map[x][y].setG(0); if(m_map[x][y].getNodeStatus() !=LOCKED) { m_map[x][y].setNodeStatus(NONE); } else {std::cout<< "LOCKED";} /* x = m_X; y = m_Y; H = 0; G = 0; parentNode = nullptr; nodeType= NODE_WALKABLE; nodeStatus = NONE;*/ } } }
void DrawTreeCairo::GeneTreeMarkers() { cairo_set_source_rgba(cr,config->gene_edge_color.red,config->gene_edge_color.green,config->gene_edge_color.blue,1); if(parameters->isMarkerColor) { cairo_set_source_rgba(cr,config->umColor.red,config->umColor.green,config->umColor.blue,0.80); } cairo_select_font_face (cr, parameters->gene_font.c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD); cairo_set_font_size(cr,fontsize * parameters->markerscale); cairo_text_extents (cr, "i", &extents); const double offset = extents.width / 2; for(vector<double>::const_iterator i = parameters->uMarker.begin(); i != parameters->uMarker.end(); i++) { if (*i < gene->getNumberOfNodes()) { Node *n = gene->getNode(*i); ostringstream os; os << *i; const string st = os.str(); cairo_move_to(cr,n->getX() + parameters->ux_offset + offset,n->getY() + parameters->uy_offset + offset); cairo_show_text(cr,st.c_str()); } } }
/** * Find the leaf node which directly contains this chunk. * * @param aChunk the chunk to be located. If non null, the parameters ax and az are ignored. * @param ax the chunkspace coordinate of the chunk to be located. Only used if param aChunk is null * @param az the chunkspace coordinate of the chunk to be located. Only used if param aChunk is null */ TerrainQuadTree::Node * TerrainQuadTree::Node::findChunkNode (const ProceduralTerrainAppearance::Chunk * const chunk, int x, int z, int size) { Node * node = this; if (chunk) { x = chunk->getChunkX (); z = chunk->getChunkZ (); size = static_cast <int> (chunk->getChunkWidthInMeters () / m_minChunkWidthInMeters); } if (!node->nodeEncloses (x, z)) return 0; while (node) { if (node->getSize() == size && node->getX() == x && node->getZ() == z) return node; const int which = node->getQuadrant (x, z); node = node->m_subNodes [which]; } return 0; }
void DrawTreeCairo::DrawTimeEdges() { cairo_set_line_width (cr, linewidth); const double midnode = leafWidth; cairo_set_font_size (cr, fontsize); cairo_set_source_rgba (cr,parameters->allFontColor.red,parameters->allFontColor.green,parameters->allFontColor.blue, 1); cairo_move_to(cr, 0, pageheight); cairo_line_to(cr, pagewidth, pageheight); cairo_line_to(cr, pagewidth, 0); cairo_set_line_width(cr, 1); cairo_set_dash(cr, dashed1, len1, 0); for(unsigned u = 0; u < species->getNumberOfNodes(); u++) { Node* n = species->getNode(u); if (!n->isLeaf()) { cairo_move_to(cr, n->getX(), pageheight); cairo_line_to(cr, n->getX(), n->getY() + midnode); } } cairo_stroke(cr); cairo_set_dash(cr, dashed3, 0, 0); }
void RoadNetwork::run() { city = this->getData("City"); param.RoadNetworkRa = this->getRasterData("City",vRoadNetworkRa); param.RoadNetworkRa->setSize(param.Width, param.Height, param.CellSize, param.CellSize,0,0); param.RoadNetworkRa->clear(); param.roadDistanceToRiver = param.roadDistanceToRiver_in / param.CellSize; param.roadBasisLength = param.roadBasisLength_in / param.CellSize; param.dAlpha = param.dAlpha_in / 0.01745329; param.roadConnectivity = param.dAlpha_in / param.CellSize; Node StartPoint; StartPoint.x = 0; StartPoint.y = this->findPointNearRiver(StartPoint.x, param.roadDistanceToRiver, param.topoStatus); param.RoadNetworkRa->setCell(StartPoint.x, StartPoint.y, 1); Node EndPoint; EndPoint.x = param.Width -1; EndPoint.y = this->findPointNearRiver(EndPoint.x, param.roadDistanceToRiver, param.topoStatus); param.RoadNetworkRa->setCell(EndPoint.x, EndPoint.y, 1); std::vector<Node> vP ; std::vector<std::string> centers = city->getUUIDsOfComponentsInView(vCityCenters); foreach(std::string c , centers) { Node * p = this->city->getNode(c); vP.push_back(Node(p->getX()/param.CellSize, p->getY()/param.CellSize, p->getZ())); }
void QuadTree::move(TreeElement &elem) { Node *node = elem.getNode(); if (node) { if (node == this->_mainNode) { this->_mainNode->getElements().erase(&elem); this->push(elem); } else { if (node->getElements().size() > 1) node->getElements().erase(&elem); else { int nbChilds = node->getNbChilds(); if (nbChilds < 2) { Node *parent = node->getParent(); node = this->eraseNode(node, elem.getNodeNb()); if (parent) { if (parent->getElements().empty() && parent->getNbChilds() == 1) node = this->eraseNode(parent, elem.getNodeNb()); } } else node->getElements().erase(&elem); } int nodeNb = this->findNodeNb(elem); if (this->isInMiddle(elem)) { this->_mainNode->getElements().insert(&elem); elem.setNode(this->_mainNode); } else if (elem.getNodeNb() != nodeNb) this->push(elem); else { elem.setXElementAbs(); elem.setYElementAbs(); if (!node) this->_mainNode->getChilds()[nodeNb] = this->createNode(elem); else if (this->isInSquare(elem, node->getX(), node->getY(), node->getSize())) { Node *tmp = node; Node *prev = node; while ((tmp = this->findChild(tmp, elem)) != 0) prev = tmp; tmp = prev; this->insertChild(tmp, elem); } else this->insertOnTop(node, elem, nodeNb); } } } }
void QuadTree::collide(QuadTree const &quadTree, QuadTree::callInfo call) const { Node *node; Node *node2; if (call == QuadTree::ALL) { for (Elements::const_iterator it = this->_mainNode->getElements().begin(); it != this->_mainNode->getElements().end(); ++it) quadTree.collideBranches(**it, QuadTree::ALL); } else { for (Elements::const_iterator it = this->_mainNode->getElements().begin(); it != this->_mainNode->getElements().end(); ++it) quadTree.collide(**it, static_cast<QuadTree::callInfo>(QuadTree::ALL & (~call))); } for (Elements::const_iterator it = quadTree._mainNode->getElements().begin(); it != quadTree._mainNode->getElements().end(); ++it) this->collide(**it, call); for (int i = 0; i < 4; ++i) { node = this->_mainNode->getChilds()[i]; node2 = quadTree._mainNode->getChilds()[i]; if (node && node2 && this->collideRect(node->getX(), node->getY(), node->getSize(), node->getSize(), node2->getX(), node2->getY(), node2->getSize(), node2->getSize())) this->collideNodes(node, node2, call); } }
void QuadTree::push(TreeElement &elem) { if (this->isInMiddle(elem)) { this->_mainNode->getElements().insert(&elem); elem.setNode(this->_mainNode); return ; } elem.setXElementAbs(); elem.setYElementAbs(); int nodeNb = this->findNodeNb(elem); elem.setNodeNb(nodeNb); if (!this->_mainNode->getChilds()[nodeNb]) this->_mainNode->getChilds()[nodeNb] = this->createNode(elem); else { Node *node = this->_mainNode->getChilds()[nodeNb]; if (this->isInSquare(elem, node->getX(), node->getY(), node->getSize())) { Node *prev = node; while ((node = this->findChild(node, elem)) != 0) prev = node; node = prev; this->insertChild(node, elem); } else this->insertParent(elem, nodeNb); } }
void WaterFaker::postStepProc(FEMUtil &femUtil, NodeHandler &nodeHandler, TimeHandler &timeHandler) { for (int i = 0; i < nodeHandler.getNodeNum(); i++) { Node* current = nodeHandler.getNode(i); float dt = timeHandler.getDeltaTime() / current->getData(MASSI); current->move(current->getData(MXI) * dt, current->getData(MYI) * dt, 0); // current->getData(MZI) * dt); float x = current->getX(); float y = current->getY(); if (isnan(x) || isnan(y)) { printf("NANTIME!!\n"); exit(1); } if (x < WALL_MINX) { current->setData(MXI, -current->getData(MXI) * .9f); current->setX(WALL_MINX); } else if (x > WALL_MAXX) { current->setData(MXI, -current->getData(MXI) * .9f); current->setX(WALL_MAXX); } if (y < WALL_MINY) { current->setData(MYI, 0); current->setY(WALL_MINY); } else if (y > WALL_MAXY) { current->setData(MYI, 0); current->setY(WALL_MAXY); } } }
void DrawTreeCairo::TimeLabelsOnEdges() { cairo_set_source_rgba (cr, 0, 0, 0, 1); for(unsigned u = 0; u < species->getNumberOfNodes(); u++) { Node* n = species->getNode(u); const string timelabel = double2charp(n->getTime()); double xpos = n->getX(); double ypos = n->getY(); if (!n->isLeaf()) { cairo_text_extents (cr, timelabel.c_str(), &extents); xpos = xpos - (extents.width + extents.x_advance); ypos = ypos - leafWidth; cairo_move_to(cr,xpos,ypos); cairo_save(cr); if(parameters->horiz) { cairo_rotate(cr,-(pi/4)); } cairo_show_text(cr,timelabel.c_str()); cairo_restore(cr); } } }
Node *QuadTree::findChild(Node *node, TreeElement &elem) const { Node *child = node->getChild(elem); if (child && this->isInSquare(elem, child->getX(), child->getY(), child->getSize())) return (child); return (0); }
void NodeTable::addNode ( const Node& node ) { int row = node.getNumber() - 1; insertRow( row ); setCoord( row, 0, node.getX() ); setCoord( row, 1, node.getY() ); setFixationItem( row, node.getFixation() ); }
void WaterFaker::solveStep(FEMUtil &femUtil, NodeHandler &nodeHandler, TimeHandler &timeHandler) { for (int i = 0; i < nodeHandler.getNodeNum(); i++) { Node* current = nodeHandler.getNode(i); Node* other; float fx = rand() * RAND_AMOUNT / RAND_MAX; float fy = -GRAVITY + frand() * RAND_AMOUNT; // float fz = 0; float adx, dx; float ady, dy; float dist; float force; float dt = timeHandler.getDeltaTime(); for (int j = 0; j < nodeHandler.getNodeNum(); j++) { if (j != i) { other = nodeHandler.getNode(j); dx = current->getX() - other->getX(); adx = fabs(dx); if (adx < MAX_RAD) { dy = current->getY() - other->getY(); ady = fabs(dy); if (ady < MAX_RAD) { dist = sqrt(dx*dx+dy*dy); if (dist < MAX_RAD) { force = MAX_FORCE * ((MAX_RAD - dist) / (MAX_RAD - MIN_RAD)); // printf("Collision %f\n", force); if (dist > ARB_SMALL) { fx += dx * force / dist; fy += dy * force / dist; } else { other->move(frand() * 2 * MAX_RAD, frand() * 2 * MAX_RAD, 0); printf("Too Small\n"); } } } } } } current->setData(MXI, current->getData(MXI) + fx * dt); current->setData(MYI, current->getData(MYI) + fy * dt); // current->setData(MZI, current->getData(MZI) + fz * dt); // printf("Force %f %f %f - Momentum %f %f %f\n", fx, fy, fz, current->getData(MXI), current->getData(MYI), current->getData(MZI)); } }
void PNP::addInterrupt(Place *pi, string condition, Place *po) { Node *pe = next(next(pi)); // exec place string ae=pe->getName(); std::size_t pos = ae.find("."); // position of "." in str std::string a = ae.substr(0,pos); Transition *ts = addTransition(a+".interrupt ["+condition+"]"); ts->setY(pe->getY()-1); ts->setX(pe->getX()); // upper line wrt pe connect(pe,ts); connect(ts,po); }
void DrawTreeCairo::DrawSpeciesEdges() { cairo_set_source_rgba(cr,config->species_edge_color.red,config->species_edge_color.green,config->species_edge_color.blue,1); cairo_set_line_width(cr, 1); const double midnode = leafWidth; Node *root = species->getRootNode(); cairo_move_to(cr, 0, (root->getY() + midnode) ); cairo_rel_line_to(cr,root->getX(),0); cairo_rel_line_to(cr, 0, -(midnode * 2) ); cairo_rel_line_to(cr, -(root->getX()) , 0); cairo_close_path(cr); cairo_stroke_preserve(cr); cairo_fill(cr); for ( Node *n = species->preorder_begin(); n != 0; n = species->preorder_next(n) ) { const double x = n->getX(); const double y = n->getY(); cairo_set_source_rgba(cr,config->species_edge_color.red,config->species_edge_color.green,config->species_edge_color.blue,1); if (!n->isLeaf()) { cairo_move_to(cr,x,y + midnode); cairo_rel_line_to(cr,n->getLeftChild()->getX()-x,n->getLeftChild()->getY()-y); cairo_rel_line_to(cr,0,-midnode*2); cairo_rel_line_to(cr,x-n->getLeftChild()->getX(),(y) - (n->getLeftChild()->getY())); cairo_close_path(cr); cairo_stroke_preserve(cr); cairo_fill(cr); cairo_move_to(cr,x,y - midnode); cairo_rel_line_to(cr,n->getRightChild()->getX()-x,n->getRightChild()->getY()-y); cairo_rel_line_to(cr,0,midnode*2); cairo_rel_line_to(cr,x-n->getRightChild()->getX(),y - n->getRightChild()->getY()); cairo_close_path(cr); cairo_stroke_preserve(cr); cairo_fill(cr); } cairo_stroke(cr); } }
vector<Node> Graph::getNeighbors(Node n) { vector<Node> nbrs; if( n.neighborEmpty() ) { for( int x = n.getX()-proximity; x <= n.getX()+proximity; x += proximity ) for( int y = n.getY()-proximity; y <= n.getY()+proximity; y += proximity ) if( ! ( x == n.getX() && y == n.getY() ) ) if ( isWithinBorders(x, y) && !isPathObstructed(n.getX(), n.getY(), x, y) ) { vector<Node> nd = getNode(x,y) ; vector<Node>::iterator iter; for( iter = nd.begin(); iter != nd.end(); iter++ ) { nbrs.push_back(*iter); n.addNeighbor(*iter); } } } else nbrs = n.getNeighbors(); return nbrs; }
void Crowd::binsort() { int i,j,k,l; double ndiv,factx,facty,factz; deque<int> ibin; Node* nd; int num; /*//// double stx,sty,stz; stx = stdpt.getX()/stdrate; sty = stdpt.getY()/stdrate; stz = stdpt.getZ()/stdrate; */ ///// ///binlist.clear(); num = getSize(); ///for(i=0;i<num;i++) binlist.push_back(i); ndiv = (int)pow((double)num,0.1); factx = ndiv / ((getXWidth()) * 1.01 / getMaxWidth()); facty = ndiv / ((getYWidth()) * 1.01 / getMaxWidth()); factz = ndiv / ((getZWidth()) * 1.01 / getMaxWidth()); for(l = 0; l < num; l++) { nd = getNode(l); i = (int)((nd->getX()) * factx); j = (int)((nd->getY()) * factz); k = (int)((nd->getZ()) * facty); ////// //i = (int)((nd->getX()-stx)*factx); //j = (int)((nd->getY()-sty)*factz); //k = (int)((nd->getZ()-stz)*facty); /////////// if((k % 2) == 0) { if((j % 2) == 0) ibin.push_back((int)(k * ndiv * ndiv + j * ndiv + i + 1)); else ibin.push_back((int)(k * ndiv * ndiv + (j + 1) * ndiv - i)); } else { if((j % 2) == 0) ibin.push_back((int)(k * ndiv * ndiv + (ndiv - j) * ndiv - i)); else ibin.push_back((int)(k * ndiv * ndiv + (ndiv - j - 1) * ndiv + i + 1)); } } dtm::quickSort(0,num - 1,binlist,ibin); }
void QuadTree::collideNodes(Node *node, Node *node2, QuadTree::callInfo call) const { Node *checkpoint; int nbChilds = 0; if (!node->getElements().empty()) { for (Node *tmp = node2; tmp; tmp = tmp->getParent()) this->collideElements(node->getElements(), tmp->getElements(), call); } for (int i = 0; i < 4; ++i) { Node *child = node2->getChilds()[i]; if (child && this->collideRect(node->getX(), node->getY(), node->getSize(), node->getSize(), child->getX(), child->getY(), child->getSize(), child->getSize())) { ++nbChilds; checkpoint = this->collideNode(node, child, call); } } if (nbChilds == 1) { for (int i = 0; i < 4; ++i) { if (node->getChilds()[i]) this->collideNodes(node->getChilds()[i], checkpoint, call); } } else { for (int i = 0; i < 4; ++i) { Node *child = node->getChilds()[i]; if (child && this->collideRect(node2->getX(), node2->getY(), node2->getSize(), node2->getSize(), child->getX(), child->getY(), child->getSize(), child->getSize())) this->collideNodes(child, node2, call); } } }
void DrawTreeCairo::DrawGeneEdges() { Color& regular = config->gene_edge_color; cairo_set_source_rgba(cr, regular.red, regular.green, regular.blue,1); cairo_set_line_width(cr, linewidth / 2); for (unsigned i = 0; i < gene->getNumberOfNodes(); i++) { Node *n = gene->getNode(i); if (!n->isRoot()) { if(n->getReconcilation() == Node::LateralTransfer) { LGT.insert(std::make_pair(n,0)); } else { newDrawPath(n); } } else if ((*lambda)[n]->isRoot()) { cairo_move_to(cr,n->getX(),n->getY()); cairo_line_to(cr,0,n->getY()); } else { //TODO can the root be further away than 1 node? cairo_move_to(cr,n->getX(),n->getY()); cairo_line_to(cr,species->getRootNode()->getX(),species->getRootNode()->getY()); cairo_line_to(cr,0,species->getRootNode()->getY()); } } DrawLGT(); cairo_stroke(cr); }
// add node to open or visited list void AStar::addNode(int x, int y, float newCost, Node* parent, Node* newNode) { if (!newNode->getPass()) { return; } // I had to use the x, y to compair nodes due to pointer issue (and out of time) Node* addNode = newNode; for (unsigned int i = 0; i < m_visitedList.size(); i++) { if (addNode->getX() == m_visitedList[i]->getX() && addNode->getY() == m_visitedList[i]->getY()) { return; } } // create temp node and establish it for the open list Node* newChild = new Node(x, y, parent, true); newChild->setG(newCost); newChild->setH(parent->manhattenDist(m_goal)); for (unsigned int i = 0; i < m_openList.size(); i++) { if (addNode->getX() == m_openList[i]->getX() && addNode->getY() == m_openList[i]->getY()) { float newF = newChild->getG() + newCost + m_openList[i]->getH(); if (m_openList[i]->getF() > newF) { m_openList[i]->setG(newChild->getG() + newCost); m_openList[i]->setParent(newChild); } else { delete newChild; return; } } } m_openList.push_back(newChild); }
void NetworkVisualiser::process() { const int NODE_WIDTH = 80; const int NODE_HEIGHT = 40; Canvas c = NodeCore::Canvas(300, 300); Network* net = (Network*)asData("network"); NodeList nodes = net->getNodes(); for (NodeIterator iter = nodes.begin(); iter != nodes.end(); ++iter) { Node* node = (*iter); NodeCore::BezierPath p = NodeCore::BezierPath(); p.rect(node->getX(), node->getY(), NODE_WIDTH, NODE_HEIGHT); c.append(p); } _setOutput(c); }
void StrategicPositioningSystem::FindNewPostionForLS() // 1:Set Action to Moving 2:Find new Move Location 3:Find Path to new move { //1. Find the New cube to move which has Line of sight. ds::Node* pathNodes = strategicPositionFinding.getClosestPosition(*m_pOwner->m_pCurrent_location, *m_pOwner->m_pCurrent_target); Node node = *pathNodes; //2. Find the convinient path to the new move location. ds::CubeGeomerty* next_move_cube = new ds::CubeGeomerty((*pathNodes).getCubeCoordinates().location); pathNodes = pathfindingAStar.A_Star(*m_pOwner->m_pCurrent_location, *next_move_cube); //3. Set the Agent action to MOve as the agent wil be moving to the new cube for next few frames. m_pOwner->m_Agent_Action = MOVING; if(m_pOwner->m_pCurrent_Move_target !=nullptr){ m_map[static_cast<int>((*m_pOwner->m_pCurrent_Move_target).location.x)][static_cast<int>((*m_pOwner->m_pCurrent_Move_target).location.y)].setNodeStatus(OPEN); } m_pOwner->m_pCurrent_Move_target = new ds::CubeGeomerty((*pathNodes).getCubeCoordinates().location); m_map[static_cast<int>((*m_pOwner->m_pCurrent_Move_target).location.x)][static_cast<int>((*m_pOwner->m_pCurrent_Move_target).location.y)].setNodeStatus(LOCKED); // MultiAgent Changes, set the next move target as NODE_COLLISION so that other agents wont select it as target. //m_map[static_cast<int>((*m_pOwner->m_pCurrent_Move_target).location.x)][static_cast<int>((*m_pOwner->m_pCurrent_Move_target).location.y)].setNodeType(NODE_COLLISION); //4. Create a vector of nodes to move through to get to the new cube; std::cout <<"\n**************************"; m_pOwner->m_Move_path_nodes.clear(); while(true) { if(nullptr != pathNodes){ Node node = *pathNodes; // Dereference the object for the parent node // Add here m_pOwner->m_Move_path_nodes.push_back(new ds::CubeGeomerty(node.getCubeCoordinates().location)); std::cout << "\nAI:(" << node.getX() << "," << node.getY() << ")"; pathNodes = node.getParentNode(); //node.setNodeStatus(PATH); } else { break; } } }
void DrawTreeCairo::DrawSpeciesNodeLabels() { cairo_select_font_face (cr, parameters->species_font.c_str(), CAIRO_FONT_SLANT_ITALIC, CAIRO_FONT_WEIGHT_BOLD); cairo_set_source_rgba (cr, parameters->speciesFontColor.red, parameters->speciesFontColor.green, parameters->speciesFontColor.blue, 1); cairo_set_font_size (cr, speciesfontsize); for(unsigned u = 0; u < species->getNumberOfNodes(); u++) { Node* n = species->getNode(u); ostringstream st; if(parameters->do_not_draw_species_tree == false) { if (parameters->ids_on_inner_nodes) { st << n->getNumber(); } st << " " + n->getName(); } const string ns = st.str(); const double xpos = n->getX(); const double ypos = n->getY(); cairo_text_extents (cr, ns.c_str(), &extents); if(n->isLeaf()) { cairo_move_to(cr, xpos + (extents.height / 2) , ypos + leafWidth); } else { cairo_move_to(cr, xpos - (0.25 * extents.width) , ypos + leafWidth); } cairo_save(cr); if(parameters->horiz) { cairo_rotate(cr,-(pi/4)); } cairo_show_text(cr,ns.c_str()); cairo_restore(cr); } cairo_stroke(cr); }
void QuadTree::insertOnTop(Node *node, TreeElement &elem, int nodeNb) { Node *parent; while ((parent = node->getParent()) && !this->isInSquare(elem, parent->getX(), parent->getY(), parent->getSize())) node = parent; if (parent) { Node *prev = parent; while ((parent = this->findChild(parent, elem)) != 0) prev = parent; parent = prev; this->insertChild(parent, elem); } else { this->insertParent(elem, nodeNb); } }
void QuadTree::collide(TreeElement &elem, int x, int y, int width, int height, Node *currentNode, QuadTree::callInfo call) const { for (Elements::const_iterator it = currentNode->getElements().begin(); it != currentNode->getElements().end(); ++it) { if (this->collideRect(x, y, width, height, (*it)->getXElementAbs(), (*it)->getYElementAbs(), (*it)->getWidthElement(), (*it)->getHeightElement())) { if (call & QuadTree::RIGHT) elem.collide(**it); if (call & QuadTree::LEFT) (*it)->collide(elem); } } for (int i = 0; i < 4; ++i) { Node *node = currentNode->getChilds()[i]; if (node && this->collideRect(x, y, width, height, node->getX(), node->getY(), node->getSize(), node->getSize())) this->collide(elem, x, y, width, height, node, call); } }
Node *QuadTree::collideNode(Node *node, Node *node2, QuadTree::callInfo call) const { int nbChilds = 0; Node *checkpoint; this->collideElements(node->getElements(), node2->getElements(), call); for (int i = 0; i < 4; ++i) { Node *child = node2->getChilds()[i]; if (child && this->collideRect(node->getX(), node->getY(), node->getSize(), node->getSize(), child->getX(), child->getY(), child->getSize(), child->getSize())) { ++nbChilds; checkpoint = this->collideNode(node, child, call); } } if (nbChilds == 1) return (checkpoint); return (node2); }
void DrawTreeCairo::DrawGeneNodes() { Color& duplCol = config->gene_dupl_color; Color& specCol = config->gene_spec_color; cairo_set_line_width(cr,2); for ( Node *n = gene->preorder_begin(); n != 0; n = gene->preorder_next(n) ) { const double x = n->getX(); const double y = n->getY(); if(n->getReconcilation() == Node::Leaf || n->getReconcilation() == Node::Speciation) //speciation or leaf { cairo_set_source_rgba(cr, specCol.red, specCol.green, specCol.blue, 1); cairo_arc(cr,x, y, (leafWidth / 10), 0.0, 2*pi); cairo_fill(cr); } else if (n->getReconcilation() == Node::Duplication) //duplication { nDupl++; cairo_set_source_rgba(cr, duplCol.red, duplCol.green, duplCol.blue, 1); cairo_rectangle(cr,x - ( (leafWidth / 5) / 2 ),y - ( (leafWidth / 5) / 2), leafWidth / 5, leafWidth / 5); cairo_fill(cr); } else if (n->getReconcilation() == Node::LateralTransfer) //duplication { nTrans++; cairo_set_source_rgba(cr, duplCol.red, duplCol.green, duplCol.blue, 1); cairo_rectangle(cr,x - ( (leafWidth / 5) / 2 ),y - ( (leafWidth / 5) / 2), leafWidth / 5, leafWidth / 5); cairo_fill(cr); } } cairo_stroke(cr); }
void DrawTreeCairo::DrawSpeciesNodes() { Color& cfill = config->species_node_color; Color& cline = config->species_node_contour_color; for ( Node *n = species->preorder_begin(); n != 0; n = species->preorder_next(n) ) { if (!n->isLeaf()) { cairo_save(cr); cairo_translate (cr,n->getX(), n->getY()); cairo_scale(cr, 0.3, 1); cairo_arc (cr, 0.0, 0.0,leafWidth, 0.0, 2 * pi); cairo_set_source_rgba(cr, cfill.red, cfill.green, cfill.blue, 1); cairo_fill_preserve(cr); cairo_set_line_width(cr, s_contour_width); cairo_set_source_rgba(cr, cline.red, cline.green, cline.blue, 1); cairo_stroke(cr); cairo_restore(cr); } } }