C++ AbstractNode::x方法代码示例

void BalanceGraph::newProcessRegion(Region *region, Graph &graph)
{
    // if we do not need to move the region
    if(region->getDforce() == 0) {
        return;
    }

    double minMovement = region->getDforce();
    if(minMovement < 0) {
        minMovement = (-1)*minMovement;
    }

    for(Segment* s : region->segments) {
        for(AbstractNode* node : s->nodes) {
            int layer = node->getLayer();
            int positionInLayer = node->getPositionInLayer();

            // attempting to move to the left
            if(region->getDforce() < 0) {

                // If we are the leftmost node
                if(positionInLayer == 0) {
                    continue;
                }

                AbstractNode* leftNode = graph.getLayers().at(layer).at(positionInLayer-1);

                // if leftNode is in the same region
                if(nodeToSegment.value(leftNode)->region == s->region) {
                    continue;
                }

                double availableMovement = node->x() - (leftNode->x() + leftNode->boundingRect().width() + 10);

                if(availableMovement < minMovement) {
                    minMovement = availableMovement;
                }
            }

            // Attempting to move to the right
            if(region->getDforce() > 0) {

                // if we are the rightmost in layer
                if(positionInLayer == graph.getLayers().at(layer).size()-1) {
                    continue;
                }

                AbstractNode* rightNode = graph.getLayers().at(layer).at(positionInLayer+1);

                // if rightNode is in the same region
                if(nodeToSegment.value(rightNode)->region == s->region) {
                    continue;
                }

                double availableMovement = rightNode->x() - (node->x() + node->boundingRect().width() + 10);

                if(availableMovement < minMovement) {
                    minMovement = availableMovement;
                }

            }
        }
    } // Calculate the maximal movement

    // move the whole region
    for(Segment* s : region->segments) {
        for(AbstractNode* n : s->nodes) {

            // movement to the left
            if(region->getDforce() < 0) {
                n->moveBy(-minMovement,0);
            } else {
                n->moveBy(minMovement,0);
            }
        }
    }

}

void BalanceGraph::newSweep(Graph &graph, BalanceGraph::direction direction)
{
    if(direction == DOWN) {
        calculateDownForces();
    } else {
        calculateUpForces();
    }

    // Generate trivial regions
    QList<Region*> regions;
    for(Segment* segment : segments) {
        Region* region = new Region();
        segment->region = region;
        region->minTopologicNumber = segment->topologicNumber;
        region->segments.append(segment);
        regions.append(region);
    }

    // Combine regions
    bool regionsChanged = true;
    while(regionsChanged) {
        regionsChanged = false;

        // Combine
        for(Segment* segment : segments) {
            for(AbstractNode* left : segment->nodes) {
                int layer = left->getLayer();
                int positionOfLeft = left->getPositionInLayer();

                // if we are last in the layer
                if(positionOfLeft == graph.getLayers().at(layer).size()-1) {
                    continue;
                }

                AbstractNode* right = graph.getLayers().at(layer).at(positionOfLeft+1);

                Region* leftRegion = nodeToSegment.value(left)->region;
                Region* rightRegion = nodeToSegment.value(right)->region;

                // if we are the same region just continue
                if(leftRegion == rightRegion) {
                    continue;
                }

                // we are touching another node
                if(right->x() <=  (left->x() + 10 + left->boundingRect().width())) {

                    // if we are about to walk into each other
                    if(leftRegion->getDforce() >= rightRegion->getDforce()) {
                        regionsChanged = true;

                        for(Segment* s : rightRegion->segments) {
                            leftRegion->segments.append(s);
                            s->region = leftRegion;
                            leftRegion->minTopologicNumber = std::min(leftRegion->minTopologicNumber,s->topologicNumber);
                        }
                        delete rightRegion;
                        regions.removeAll(rightRegion);
                    }

                }

            }
        } // Combining regions

    } // While regions not changed

    /*
    for(Region* r : regions) {
        qDebug() << "Region:";
        for(Segment* s : r->segments) {
            qDebug() << s->nodes.first()->getName();
        }
    }
    */

    // Order by minTopologicalNumber
    std::sort(regions.begin(),regions.end(),[](const Region* const r1, const Region* const r2){return r1->minTopologicNumber < r2->minTopologicNumber;});


    // Process each region
    for(Region* r : regions) {
        newProcessRegion(r,graph);
    }




    // Done. Delete regions
    for(Region* r : regions) {
        delete r;
    }

}