SList<node>& DynamicSPQRForest::findPathSPQR (node sH, node tH, node& rT) const { SList<node>& pT = *OGDF_NEW SList<node>; node sT = spqrproper(sH->firstAdj()->theEdge()); node tT = spqrproper(tH->firstAdj()->theEdge()); node nT = findNCASPQR(sT,tT); while (sT!=nT) { edge eH = m_tNode_hRefEdge[sT]; node uH = eH->source(); node vH = eH->target(); if (uH!=sH && vH!=sH) pT.pushBack(sT); if (uH==tH || vH==tH) { rT = sT; return pT; } sT = spqrproper(m_hEdge_twinEdge[eH]); } SListIterator<node> iT = pT.rbegin(); while (tT!=nT) { edge eH = m_tNode_hRefEdge[tT]; node uH = eH->source(); node vH = eH->target(); if (uH!=tH && vH!=tH) { if (iT.valid()) pT.insertAfter(tT,iT); else pT.pushFront(tT); } if (uH==sH || vH==sH) { rT = tT; return pT; } tT = spqrproper(m_hEdge_twinEdge[eH]); } if (iT.valid()) pT.insertAfter(nT,iT); else pT.pushFront(nT); rT = nT; return pT; }
bool SDLEntity2D::LoadFrame ( std::string Name, std::string TexName, std::string MaskName, int FrameDelay, int x, int y, SGZ::RGBCOLOUR ColourKey ) { /// Load up a Texture into an Animation SListIterator<SGZAnimGroup2D*> AnimListITR = AnimList.getIterator(); for( AnimListITR.start(); AnimListITR.valid(); AnimListITR.forth() ) if((AnimListITR.item()->AnimName.compare(Name))==0) { SGZAnimFrame2D *Frame = new SGZAnimFrame2D; Frame->TextureName = TexName; Frame->MaskName = MaskName; Frame->delay = FrameDelay; Frame->u = x; Frame->v = y; Frame->colkey = ColourKey; AnimListITR.item()->FrameList.append(Frame); AnimListITR.item()->AnimNum++; AnimListITR.item()->FrameITR = AnimListITR.item()->FrameList.getIterator(); if(!manTextures->checkExist(TexName)) SGZ::Logger.log( SGZLOG::Warning, "Texture " + TexName + " has not been loaded yet.. make sure it is before calling this frame!"); return true; } SGZ::Logger.log( SGZLOG::Warning, "Animation \"" + Name + "\" does not exist!\n"); return false; }
// Reduction reduced a set of leaves determined by their keys stored // in leafKeys. Integer redNumber is for debugging only. bool PlanarPQTree::Reduction(SListPure<PlanarLeafKey<indInfo*>*> &leafKeys) { SListIterator<PlanarLeafKey<indInfo*>* > it; SListPure<PQLeafKey<edge,indInfo*,bool>*> castLeafKeys; for (it = leafKeys.begin(); it.valid(); ++it) castLeafKeys.pushBack((PQLeafKey<edge,indInfo*,bool>*) *it); return PQTree<edge,indInfo*,bool>::Reduction(castLeafKeys); }
bool MTexture::checkExist ( const std::string &Name ) { SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); for( TextureITR.start(); TextureITR.valid(); TextureITR.forth() ) if(TextureITR.item()->mName.compare(Name)==0) return true; return false; }
// Initializes a PQTree by a set of leaves that will korrespond to // the set of Keys stored in leafKeys. int PlanarPQTree::Initialize(SListPure<PlanarLeafKey<IndInfo*>*> &leafKeys) { SListIterator<PlanarLeafKey<IndInfo*>* > it; SListPure<PQLeafKey<edge,IndInfo*,bool>*> castLeafKeys; for (it = leafKeys.begin(); it.valid(); ++it) castLeafKeys.pushBack((PQLeafKey<edge,IndInfo*,bool>*) *it); return PQTree<edge,IndInfo*,bool>::Initialize(castLeafKeys); }
forall_nodes(v,G) { SListIterator<PlanarLeafKey<whaInfo*>* > it; for (it = inLeaves[v].begin(); it.valid(); ++it) { PlanarLeafKey<whaInfo*>* L = *it; outLeaves[L->userStructKey()->opposite(v)].pushFront(L); } }
std::string SDLEntity2D::CheckVar( std::string Name ) { SListIterator<SGZVarGroup*> VarITR = VarList.getIterator(); for( VarITR.start(); VarITR.valid(); VarITR.forth() ) if((VarITR.item()->Name.compare(Name))==0) return VarITR.item()->Variable; return "none"; }
bool MTexture::setColourKey ( const std::string &Name, const SGZ::RGBCOLOUR &key ) { SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); for( TextureITR.start(); TextureITR.valid(); TextureITR.forth() ) if(TextureITR.item()->mName.compare(Name)==0) TextureITR.item()->mData->setColourKey(key); SGZ::Logger.log( SGZLOG::Warning, "Texture " + Name + " does not exist!\n"); return false; }
// Reduction reduced a set of leaves determined by their keys stored // in leafKeys. Integer redNumber is for debugging only. bool PlanarSubgraphPQTree:: Reduction(SListPure<PlanarLeafKey<whaInfo*>*> &leafKeys, SList<PQLeafKey<edge,whaInfo*,bool>*> &eliminatedKeys, int redNumber) { SListPure<PQLeafKey<edge,whaInfo*,bool>*> castLeafKeys; SListIterator<PlanarLeafKey<whaInfo*>* > it; for (it = leafKeys.begin(); it.valid(); ++it) { castLeafKeys.pushBack((PQLeafKey<edge,whaInfo*,bool>*) *it); #ifdef OGDF_DEBUG if (int(ogdf::debugLevel) >= int(dlHeavyChecks)) { cout << (*it)->print() << endl; } #endif } determineMinRemoveSequence(castLeafKeys,eliminatedKeys); removeEliminatedLeaves(eliminatedKeys); SListIterator<PQLeafKey<edge,whaInfo*,bool>* > itn = castLeafKeys.begin(); SListIterator<PQLeafKey<edge,whaInfo*,bool>* > itp = itn++; for (; itn.valid();) { if ((*itn)->nodePointer()->status()== WHA_DELETE) { itn++; castLeafKeys.delSucc(itp); } else itp = itn++; } if ((*castLeafKeys.begin())->nodePointer()->status() == WHA_DELETE) castLeafKeys.popFront(); return Reduce(castLeafKeys,redNumber); }
void* MTexture::getTexture( const std::string &Name ) { SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); for( TextureITR.start(); TextureITR.valid(); TextureITR.forth() ) if(TextureITR.item()->mName.compare(Name)==0) { return TextureITR.item()->mData->getTexture(); } SGZ::Logger.log( SGZLOG::Warning, "Texture " + Name + " does not exist!\n"); return NULL; }
MTexture::~MTexture() { /** Destructor */ SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); TextureITR.start(); while (TextureITR.valid()) { mTextureList.remove(TextureITR); TextureITR.forth(); } }
bool MTexture::blitTexture ( const std::string &Name, const SGZ::VECTOR3 &vector, const SGZ::SCALER u, const SGZ::SCALER v, const SGZ::SCALER w, const SGZ::SCALER h ) { SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); for( TextureITR.start(); TextureITR.valid(); TextureITR.forth() ) if(TextureITR.item()->mName.compare(Name)==0) { TextureITR.item()->mData->blitTexture(vector,u,v,w,h); return true; } SGZ::Logger.log( SGZLOG::Warning, "Texture " + Name + " does not exist!\n"); return false; }
bool MTexture::delTexture( const std::string &Name ) { SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); for( TextureITR.start(); TextureITR.valid(); TextureITR.forth() ) if(TextureITR.item()->mName.compare(Name)==0) { mTextureList.remove(TextureITR); return true; } SGZ::Logger.log( SGZLOG::Warning, "Texture " + Name + " does not exist!\n"); return false; }
bool MTexture::addTexMask( const std::string &Name, const std::string &Maskname ) { SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); for( TextureITR.start(); TextureITR.valid(); TextureITR.forth() ) if(TextureITR.item()->mName.compare(Name)==0) { TextureITR.item()->mData->loadTextureMask(Maskname); return true; } SGZ::Logger.log( SGZLOG::Warning, "Texture " + Name + " does not exist!\n"); return false; }
bool SDLEntity2D::DeleteVar( std::string Name ) { SListIterator<SGZVarGroup*> VarITR = VarList.getIterator(); for( VarITR.start(); VarITR.valid(); VarITR.forth() ) if((VarITR.item()->Name.compare(Name))==0) { VarList.remove(VarITR); return true; } SGZ::Logger.log( SGZLOG::Warning, "Variable \"" + Name + "\" does not exist!\n"); return false; }
void UMLGraph::undoStars() { SListIterator<node> it = m_centerNodes.begin(); while (it.valid()) { undoStar(*it, false); ++it; }//while m_hiddenEdges->restore(); m_centerNodes.clear(); m_replacementEdge.init(); }//undostars
bool SDLEntity2D::ChangeVar ( std::string Name, std::string Value ) { /** Load up a Texture into an Animation*/ SListIterator<SGZVarGroup*> VarITR = VarList.getIterator(); for( VarITR.start(); VarITR.valid(); VarITR.forth() ) if((VarITR.item()->Name.compare(Name))==0) { VarITR.item()->Variable = Value; return true; } SGZ::Logger.log( SGZLOG::Warning, "Variable \"" + Name + "\" does not exist!\n"); return false; }
void VarEdgeInserterDynCore::insert(edge eOrig, SList<adjEntry>& eip) { eip.clear(); node s = m_pr.copy(eOrig->source()); node t = m_pr.copy(eOrig->target()); // find path from s to t in BC-tree // call of blockInsert() is done when we have found the path // if no path is found, s and t are in different connected components // and thus an empty edge insertion path is correct! DynamicSPQRForest& dSPQRF = m_pBC->dynamicSPQRForest(); SList<node>& path = dSPQRF.findPath(s, t); if (!path.empty()) { SListIterator<node> it = path.begin(); node repS = dSPQRF.repVertex(s, *it); for (SListIterator<node> jt = it; it.valid(); ++it) { node repT = (++jt).valid() ? dSPQRF.cutVertex(*jt, *it) : dSPQRF.repVertex(t, *it); // less than 3 nodes requires no crossings (cannot build SPQR-tree // for a graph with less than 3 nodes!) if (dSPQRF.numberOfNodes(*it) > 3) { List<adjEntry> L; blockInsert(repS, repT, L); // call biconnected case // transform crossed edges to edges in G for (adjEntry kt : L) { edge e = kt->theEdge(); eip.pushBack(e->adjSource() == kt ? dSPQRF.original(e)->adjSource() : dSPQRF.original(e)->adjTarget()); } } if (jt.valid()) repS = dSPQRF.cutVertex(*it, *jt); } } delete &path; }
// Function ReplaceFullRoot either replaces the full root // or one full child of a partial root of a pertinent subtree // by a single P-node with leaves corresponding the keys stored in leafKeys. void PlanarSubgraphPQTree:: ReplaceFullRoot(SListPure<PlanarLeafKey<whaInfo*>*> &leafKeys) { PQLeaf<edge,whaInfo*,bool> *leafPtr = 0; // dummy PQInternalNode<edge,whaInfo*,bool> *nodePtr = 0; // dummy //PQNodeKey<edge,whaInfo*,bool> *nodeInfoPtr = 0; // dummy PQNode<edge,whaInfo*,bool> *currentNode = 0; // dummy SListIterator<PlanarLeafKey<whaInfo*>* > it; if (!leafKeys.empty() && leafKeys.front() == leafKeys.back()) { //ReplaceFullRoot: replace pertinent root by a single leaf leafPtr = OGDF_NEW PQLeaf<edge,whaInfo*,bool>(m_identificationNumber++, EMPTY,(PQLeafKey<edge,whaInfo*,bool>*)leafKeys.front()); exchangeNodes(m_pertinentRoot,(PQNode<edge,whaInfo*,bool>*) leafPtr); if (m_pertinentRoot == m_root) m_root = (PQNode<edge,whaInfo*,bool>*) leafPtr; } else if (!leafKeys.empty()) // at least two leaves { //replace pertinent root by a $P$-node if ((m_pertinentRoot->type() == P_NODE) || (m_pertinentRoot->type() == Q_NODE)) { nodePtr = (PQInternalNode<edge,whaInfo*,bool>*)m_pertinentRoot; nodePtr->type(P_NODE); nodePtr->status(PERTROOT); nodePtr->childCount(0); while (!fullChildren(m_pertinentRoot)->empty()) { currentNode = fullChildren(m_pertinentRoot)->popFrontRet(); removeChildFromSiblings(currentNode); } } else if (m_pertinentRoot->type() == LEAF) { nodePtr = OGDF_NEW PQInternalNode<edge,whaInfo*,bool>(m_identificationNumber++, P_NODE,EMPTY); exchangeNodes(m_pertinentRoot,nodePtr); } SListPure<PQLeafKey<edge,whaInfo*,bool>*> castLeafKeys; for (it = leafKeys.begin(); it.valid(); ++it) castLeafKeys.pushBack((PQLeafKey<edge,whaInfo*,bool>*) *it); addNewLeavesToTree(nodePtr,castLeafKeys); } }
// Function ReplaceFullRoot either replaces the full root // or one full child of a partial root of a pertinent subtree // by a single P-node with leaves corresponding the keys stored in leafKeys. void PlanarPQTree::ReplaceFullRoot(SListPure<PlanarLeafKey<indInfo*>*> &leafKeys) { if (!leafKeys.empty() && leafKeys.front() == leafKeys.back()) { //ReplaceFullRoot: replace pertinent root by a single leaf PQLeaf<edge,indInfo*,bool> *leafPtr = OGDF_NEW PQLeaf<edge,indInfo*,bool>(m_identificationNumber++, EMPTY,(PQLeafKey<edge,indInfo*,bool>*)leafKeys.front()); exchangeNodes(m_pertinentRoot,(PQNode<edge,indInfo*,bool>*) leafPtr); if (m_pertinentRoot == m_root) m_root = (PQNode<edge,indInfo*,bool>*) leafPtr; m_pertinentRoot = 0; // check for this emptyAllPertinentNodes } else if (!leafKeys.empty()) // at least two leaves { PQInternalNode<edge,indInfo*,bool> *nodePtr = 0; // dummy //replace pertinent root by a $P$-node if ((m_pertinentRoot->type() == PQNodeRoot::PNode) || (m_pertinentRoot->type() == PQNodeRoot::QNode)) { nodePtr = (PQInternalNode<edge,indInfo*,bool>*)m_pertinentRoot; nodePtr->type(PQNodeRoot::PNode); nodePtr->childCount(0); while (!fullChildren(m_pertinentRoot)->empty()) removeChildFromSiblings(fullChildren(m_pertinentRoot)->popFrontRet()); } else if (m_pertinentRoot->type() == PQNodeRoot::leaf) { nodePtr = OGDF_NEW PQInternalNode<edge,indInfo*,bool>(m_identificationNumber++, PQNodeRoot::PNode,EMPTY); exchangeNodes(m_pertinentRoot,nodePtr); m_pertinentRoot = 0; // check for this emptyAllPertinentNodes } SListPure<PQLeafKey<edge,indInfo*,bool>*> castLeafKeys; SListIterator<PlanarLeafKey<indInfo*>* > it; for (it = leafKeys.begin(); it.valid(); ++it) castLeafKeys.pushBack((PQLeafKey<edge,indInfo*,bool>*) *it); addNewLeavesToTree(nodePtr,castLeafKeys); } }
bool MTexture::blitTexture ( const std::string &Name, const float x1, const float y1, const float u1, const float v1, const float x2, const float y2, const float u2, const float v2, const float x3, const float y3, const float u3, const float v3, const float x4, const float y4, const float u4, const float v4, const int layer ) { SListIterator<TextureObj*> TextureITR = mTextureList.getIterator(); for( TextureITR.start(); TextureITR.valid(); TextureITR.forth() ) if(TextureITR.item()->mName.compare(Name)==0) { TextureITR.item()->mData->blitTexture( x1, y1, u1, v1, x2, y2, u2, v2, x3, y3, u3, v3, x4, y4, u4, v4, layer); return true; } SGZ::Logger.log( SGZLOG::Warning, "Texture " + Name + " does not exist!\n"); return false; }
bool SDLEntity2D::DeleteAnimation( std::string Name ) { SListIterator<SGZAnimGroup2D*> AnimListITR = AnimList.getIterator(); for( AnimListITR.start(); AnimListITR.valid(); AnimListITR.forth() ) if((AnimListITR.item()->AnimName.compare(Name))==0) { AnimListITR.item()->FrameITR.start(); while (AnimListITR.item()->FrameITR.valid()) { AnimListITR.item()->FrameList.remove(AnimListITR.item()->FrameITR); AnimListITR.item()->FrameITR.forth(); } AnimList.remove(AnimListITR); return true; } SGZ::Logger.log( SGZLOG::Warning, "Animation \"" + Name + "\" does not exist!\n"); return false; }
void PlanarSubgraphPQTree:: removeEliminatedLeaves(SList<PQLeafKey<edge,whaInfo*,bool>*> &eliminatedKeys) { PQNode<edge,whaInfo*,bool>* nodePtr = 0; PQNode<edge,whaInfo*,bool>* parent = 0; PQNode<edge,whaInfo*,bool>* sibling = 0; SListIterator<PQLeafKey<edge,whaInfo*,bool>*> it; for (it = eliminatedKeys.begin(); it.valid(); it++) { nodePtr = (*it)->nodePointer(); parent = nodePtr->parent(); sibling = nodePtr->getNextSib(NULL); removeNodeFromTree(parent,nodePtr); checkIfOnlyChild(sibling,parent); if (parent->status() == TO_BE_DELETED) { parent->status(WHA_DELETE); } nodePtr->status(WHA_DELETE); } }
void EmbedPQTree::ReplaceFullRoot( SListPure<PlanarLeafKey<indInfo*>*> &leafKeys, SListPure<PQBasicKey<edge,indInfo*,bool>*> &frontier, node v, bool addIndicator, PQNode<edge,indInfo*,bool> *opposite) { EmbedIndicator *newInd = 0; front(m_pertinentRoot,frontier); if (addIndicator) { indInfo *newInfo = OGDF_NEW indInfo(v); embedKey *nodeInfoPtr = OGDF_NEW embedKey(newInfo); newInd = OGDF_NEW EmbedIndicator(m_identificationNumber++, (PQNodeKey<edge,indInfo*,bool>*)nodeInfoPtr); newInd->setNodeInfo(nodeInfoPtr); nodeInfoPtr->setNodePointer(newInd); } if (!leafKeys.empty() && leafKeys.front() == leafKeys.back()) { //ReplaceFullRoot: replace pertinent root by a single leaf if (addIndicator) { opposite = m_pertinentRoot->getNextSib(opposite); if (!opposite) // m_pertinentRoot is endmost child { addNodeToNewParent(m_pertinentRoot->parent(),newInd, m_pertinentRoot,opposite); } else addNodeToNewParent(0,newInd,m_pertinentRoot,opposite); // Setting the sibling pointers into opposite direction of // scanning the front allows to track swaps of the indicator newInd->changeSiblings(m_pertinentRoot,0); newInd->changeSiblings(opposite,0); newInd->putSibling(m_pertinentRoot,LEFT); newInd->putSibling(opposite,RIGHT); } PQLeaf<edge,indInfo*,bool> *leafPtr = OGDF_NEW PQLeaf<edge,indInfo*,bool>(m_identificationNumber++, EMPTY,(PQLeafKey<edge,indInfo*,bool>*)leafKeys.front()); exchangeNodes(m_pertinentRoot,(PQNode<edge,indInfo*,bool>*) leafPtr); if (m_pertinentRoot == m_root) m_root = (PQNode<edge,indInfo*,bool>*) leafPtr; m_pertinentRoot = 0; // check for this emptyAllPertinentNodes } else if (!leafKeys.empty()) // at least two leaves { //replace pertinent root by a $P$-node if (addIndicator) { opposite = m_pertinentRoot->getNextSib(opposite); if (!opposite) // m_pertinentRoot is endmost child { addNodeToNewParent(m_pertinentRoot->parent(),newInd, m_pertinentRoot,opposite); } else addNodeToNewParent(0,newInd,m_pertinentRoot,opposite); // Setting the sibling pointers into opposite direction of // scanning the front allows to track swaps of the indicator newInd->changeSiblings(m_pertinentRoot,0); newInd->changeSiblings(opposite,0); newInd->putSibling(m_pertinentRoot,LEFT); newInd->putSibling(opposite,RIGHT); } PQInternalNode<edge,indInfo*,bool> *nodePtr = 0; // dummy if ((m_pertinentRoot->type() == PQNodeRoot::PNode) || (m_pertinentRoot->type() == PQNodeRoot::QNode)) { nodePtr = (PQInternalNode<edge,indInfo*,bool>*)m_pertinentRoot; nodePtr->type(PQNodeRoot::PNode); nodePtr->childCount(0); while (!fullChildren(m_pertinentRoot)->empty()) { PQNode<edge,indInfo*,bool> *currentNode = fullChildren(m_pertinentRoot)->popFrontRet(); removeChildFromSiblings(currentNode); } } else if (m_pertinentRoot->type() == PQNodeRoot::leaf) { nodePtr = OGDF_NEW PQInternalNode<edge,indInfo*,bool>(m_identificationNumber++, PQNodeRoot::PNode,EMPTY); exchangeNodes(m_pertinentRoot,nodePtr); m_pertinentRoot = 0; // check for this emptyAllPertinentNodes } SListPure<PQLeafKey<edge,indInfo*,bool>*> castLeafKeys; SListIterator<PlanarLeafKey<indInfo*>* > it; for (it = leafKeys.begin(); it.valid(); ++it) castLeafKeys.pushBack((PQLeafKey<edge,indInfo*,bool>*) *it); addNewLeavesToTree(nodePtr,castLeafKeys); } }
void randomHierarchy(Graph &G, int numberOfNodes,int numberOfEdges, bool planar,bool singleSource,bool longEdges) { G.clear(); node *nnr = new node[3*numberOfNodes]; int *vrt = new int[3*numberOfNodes]; int *fst = new int[numberOfNodes+1]; List<bEdge> startEdges; bEdge actEdge, nextEdge, toDelete; node v; int act, next, n1, n2, idc=0; double x1, x2, r; bool connected; /** Place nodes **/ for(int i = 0; i < numberOfNodes; i++) G.newNode(); int numberOfLayers=0, totNumber=0, realCount=0; fst[0] = 0; forall_nodes(v,G) { if(longEdges&&numberOfLayers) vrt[totNumber++] = 1; nnr[totNumber] = v; vrt[totNumber++] = 0; realCount++; r = double(randomNumber(0,1000)) / 1000.0; if((totNumber == 1 && singleSource) || realCount == numberOfNodes || r*r*numberOfNodes < 1) { if(longEdges && numberOfLayers) vrt[totNumber++] = 1; fst[++numberOfLayers] = totNumber; } } /** Determine allowed neighbours **/ int *leftN = new int[totNumber]; int *rightN = new int[totNumber]; for(int l = 1; l < numberOfLayers; l++) { if(planar) { n1 = fst[l-1]; n2 = fst[l]; leftN[n2] = n1; while(n1 < fst[l] && n2 < fst[l+1]) { r = double(randomNumber(0,1000)) / 1000.0; if(n1 != fst[l]-1 && (n2 == fst[l+1]-1 || r < (double)(fst[l]-fst[l-1])/(double)(fst[l+1]-fst[l-1]))) n1++; else { rightN[n2] = n1; if(++n2 < fst[l+1]) leftN[n2] = n1; } } } else for(n2 = fst[l]; n2 < fst[l+1]; n2++) { leftN [n2] = fst[l-1]; rightN[n2] = fst[l]-1; } } /** Insert edges **/ SList<bEdge> *edgeIn = new SList<bEdge>[totNumber]; SList<bEdge> *edgeOut = new SList<bEdge>[totNumber]; if(numberOfLayers) { x1 = numberOfEdges; x2 = 0; for(n2 = fst[1]; n2 < totNumber; n2++) if(!vrt[n2]) x2 += rightN[n2] - leftN[n2]+1; for(n2 = fst[1]; n2 < totNumber; n2++) if(!vrt[n2]) { connected = !singleSource; for(n1 = leftN[n2]; n1 <= rightN[n2] || !connected; n1++) { r = double(randomNumber(0,1000)) / 1000.0; if(r < x1/x2 || n1 > rightN[n2]) { next = (n1 <= rightN[n2] ? n1 : randomNumber(leftN[n2],rightN[n2])); act = n2; nextEdge = OGDF_NEW BEdge(next,act,idc++); while(vrt[next]) { act = next; next = randomNumber(leftN[act],rightN[act]); edgeOut[act].pushBack(nextEdge); nextEdge = OGDF_NEW BEdge(next,act,idc++); edgeIn[act].pushBack(nextEdge); } startEdges.pushBack(nextEdge); connected = 1; x1 -= 1; } if(n1<=rightN[n2]) x2-=1; } } } delete[] leftN; delete[] rightN; if(planar) for(act = 0; act < totNumber; act++) { CmpTail cmpTail; edgeIn[act].quicksort(cmpTail); CmpHead cmpHead; edgeOut[act].quicksort(cmpHead); } for(act = 0; act < totNumber; act++) { SListIterator<bEdge> it; for(it = edgeIn[act].begin(); it.valid(); ++it) { nextEdge = *it; nextEdge->next = edgeOut[act].popFrontRet(); } } delete[] edgeOut; ListIterator<bEdge> it; for(it = startEdges.begin(); it.valid(); ++it) { actEdge = *it; nextEdge = actEdge; while(vrt[nextEdge->head]) nextEdge = nextEdge->next; G.newEdge(nnr[actEdge->tail], nnr[nextEdge->head]); } /** Clean up **/ for(it = startEdges.begin(); it.valid(); ++it) { nextEdge = *it; toDelete = nextEdge; while(vrt[nextEdge->head]) { nextEdge = nextEdge->next; delete toDelete; toDelete = nextEdge; } delete toDelete; } delete[] edgeIn; delete[] fst; delete[] vrt; delete[] nnr; }
// separate pertinent nodes in the lists of possible different minor-types void FindKuratowskis::splitInMinorTypes( const SListPure<adjEntry>& externalFacePath, int marker) { // mark nodes, which are before stopX or behind stopY in CCW-traversal and add // all extern nodes strictly between stopX and stopY to list // externE for minor E (pertinent nodes are considered because of the // position of z left or right of w) SListConstIterator<adjEntry> itExtern; SListIterator<WInfo> it = k.wNodes.begin(); node x; bool between = false; SListPure<WInfo*> infoList; SListIterator<WInfo*> itList; ExternE externEdummy; // compute list of externE nodes for (itExtern=externalFacePath.begin(); itExtern.valid(); ++itExtern) { x = (*itExtern)->theNode(); if (x==k.stopX || x==k.stopY) { between = (between==false) ? true : false; } else { if (!between) { m_wasHere[x]=marker; } else { if (pBM->externallyActive(x,k.V_DFI)) { externEdummy.theNode = x; // check minor type B and save extern linkage if (it.valid() && (*it).w==x && !m_pertinentRoots[x].empty() && m_lowPoint[m_nodeFromDFI[-m_dfi[m_pertinentRoots[x].back()]]] < k.V_DFI) { WInfo& info(*it); // checking minor type B info.minorType |= WInfo::B; // mark extern node for later extraction externEdummy.startnodes.pushBack(0); // create externE-list k.externE.pushBack(externEdummy); // save extern linkage info.externEStart = k.externE.rbegin(); info.externEEnd = k.externE.rbegin(); } else { // create externE-list externEdummy.startnodes.clear(); k.externE.pushBack(externEdummy); } // save for each wNode the first externally active successor // on the external face for (itList = infoList.begin(); itList.valid(); ++itList) (*itList)->firstExternEAfterW = x; infoList.clear(); } // get appropriate WInfo if (it.valid() && (*it).w==x) { infoList.pushBack(&(*it)); ++it; } } } } // divide wNodes in different minor types // avoids multiple computation of the externE range itExtern = externalFacePath.begin(); SListIterator<ExternE> itExternE = k.externE.begin(); WInfo* oldInfo = NULL; for (it=k.wNodes.begin(); it.valid(); ++it) { WInfo& info(*it); // checking minor type A if (k.RReal!=k.V) info.minorType |= WInfo::A; // if a XYPath exists if (info.highestXYPath!=NULL) { if (m_wasHere[info.highestXYPath->front()->theNode()]==marker) info.pxAboveStopX = true; if (m_wasHere[info.highestXYPath->back()->theNode()]==marker) info.pyAboveStopY = true; // checking minor type C if (info.pxAboveStopX || info.pyAboveStopY) info.minorType |= WInfo::C; // checking minor type D if (info.zPath!=NULL) info.minorType |= WInfo::D; // checking minor type E if (!k.externE.empty()) { node t; // compute valid range of externE-nodes in linear time if (oldInfo!=NULL && info.highestXYPath==oldInfo->highestXYPath) { // found the same highestXYPath as before info.externEStart = oldInfo->externEStart; info.externEEnd = oldInfo->externEEnd; if (oldInfo->minorType & WInfo::E) info.minorType |= WInfo::E; } else { // compute range of a new highestXYPath node px; if (info.pxAboveStopX) px = k.stopX; else px = info.highestXYPath->front()->theNode(); node py; if (info.pyAboveStopY) py = k.stopY; else py = info.highestXYPath->back()->theNode(); while ((*itExtern)->theNode() != px) ++itExtern; t = (*(++itExtern))->theNode(); node start = NULL; node end = NULL; while (t != py) { if (pBM->externallyActive(t,k.V_DFI)) { if (start==NULL) start = t; end = t; } t = (*(++itExtern))->theNode(); } if (start != NULL) { while ((*itExternE).theNode != start) ++itExternE; info.externEStart = itExternE; // mark node to extract external subgraph later (*itExternE).startnodes.pushBack(0); node temp = start; while (temp != end) { temp = (*++itExternE).theNode; // mark node to extract external subgraph later (*itExternE).startnodes.pushBack(0); } info.externEEnd = itExternE; info.minorType |= WInfo::E; } oldInfo = &info; } } } /* // use this to find special kuratowski-structures if ((info.minorType & (WInfo::A|WInfo::B|WInfo::C|WInfo::D|WInfo::E)) == (WInfo::A|WInfo::B|WInfo::C|WInfo::D|WInfo::E)) { char t; cin >> t; } */ } // extract the externalSubgraph of all saved externally active nodes // exclude the already extracted minor b-types #ifdef OGDF_DEBUG int visited = m_nodeMarker+1; #endif for (itExternE=k.externE.begin(); itExternE.valid(); ++itExternE) { if ((*itExternE).startnodes.empty()) continue; ExternE& externE(*itExternE); externE.startnodes.clear(); if (m_bundles) { OGDF_ASSERT(m_wasHere[externE.theNode] < visited); extractExternalSubgraphBundles(externE.theNode,k.V_DFI, k.externalSubgraph,++m_nodeMarker); } else { extractExternalSubgraph(externE.theNode,k.V_DFI,externE.startnodes, externE.endnodes); SListIterator<int> itInt; SListPure<edge> dummy; for (itInt = externE.startnodes.begin(); itInt.valid(); ++itInt) externE.externalPaths.pushBack(dummy); } } }
bool SDLEntity2D::Update ( float deltaTime ) { mDeltaTime = deltaTime; position.x += velocity.x * deltaTime; position.y += velocity.y * deltaTime; position.z += velocity.z * deltaTime; /// Update our beloved entity SListIterator<SGZAnimGroup2D*> AnimListITR = AnimList.getIterator(); offset.x = (Uint16)position.x; offset.y = (Uint16)position.y; offset.w = (Uint16)entityWidth; offset.h = (Uint16)entityHeight; //CurrentFrame = SDL_GetVideoSurface(); for( AnimListITR.start(); AnimListITR.valid(); AnimListITR.forth() ) if((AnimListITR.item()->AnimName.compare(CurrentAnim))==0) { if(AnimListITR.item()->AnimTimer.currenttime() >= AnimListITR.item()->FrameITR.item()->delay) { AnimListITR.item()->FrameITR.forth(); AnimListITR.item()->CurAnim++; AnimListITR.item()->AnimTimer.reset(); } if (AnimListITR.item()->FrameList.size() == AnimListITR.item()->CurAnim) { AnimListITR.item()->CurAnim = 0; AnimListITR.item()->FrameITR.start(); } if(AnimListITR.item()->FrameITR.valid()) { frame.x = (Uint16)AnimListITR.item()->FrameITR.item()->u; frame.y = (Uint16)AnimListITR.item()->FrameITR.item()->v; frame.w = (Uint16)entityWidth; frame.h = (Uint16)entityHeight; CurrentFrame = static_cast<SDL_Surface*>(manTextures->getTexture(AnimListITR.item()->FrameITR.item()->TextureName)); SDL_SetColorKey(CurrentFrame, SDL_SRCCOLORKEY, SDL_MapRGB( CurrentFrame->format, (Uint32)AnimListITR.item()->FrameITR.item()->colkey.r, (Uint32)AnimListITR.item()->FrameITR.item()->colkey.g, (Uint32)AnimListITR.item()->FrameITR.item()->colkey.b)); offset.w = (Uint16)entityWidth; offset.h = (Uint16)entityHeight; offset.x = (Sint16)position.x; offset.y = (Sint16)position.y; Uint32 old32Colour = SDL_MapRGB( CurrentFrame->format, oldColour.r, oldColour.g, oldColour.b); Uint32 new32Colour = SDL_MapRGB( CurrentFrame->format, newColour.r, newColour.g, newColour.b); //SDL_LockSurface(CurrentFrame); SDL_BlitSurface(CurrentFrame, &frame, SDL_GetVideoSurface(), &offset ); if (SDL_GetVideoSurface()->format->BitsPerPixel == 16) { Uint16 *pixels = (Uint16 *)SDL_GetVideoSurface()->pixels; for (int index_y = offset.y; index_y < offset.y + offset.h; ++index_y){ for (int index_x = offset.x; index_x < offset.x + offset.w; ++index_x){ Uint16 colour = pixels[ ( index_y * SDL_GetVideoSurface()->w ) + index_x ]; if ( colour == old32Colour ) pixels[ ( index_y * SDL_GetVideoSurface()->w ) + index_x ] = new32Colour; else pixels[ ( index_y * SDL_GetVideoSurface()->w ) + index_x ] = colour; } } } else { Uint32 *pixels = (Uint32 *)CurrentFrame->pixels; for (int index_y = 0; index_y < CurrentFrame->h; ++index_y){ for (int index_x = 0; index_x < CurrentFrame->w; ++index_x){ Uint32 colour = pixels[ ( index_y * CurrentFrame->w ) + index_x ]; if ( colour == old32Colour ) pixels[ ( index_y * CurrentFrame->w ) + index_x ] = new32Colour; else pixels[ ( index_y * CurrentFrame->w ) + index_x ] = colour; } } } //SDL_UnlockSurface(CurrentFrame); } return true; } return true; }