C++ Compound::setRange方法代码示例

/** Pure DB rendering when each node compose result from its pipes and transmit
    only one set of images to the destination node. */
static void _modeDB(       Config*  config,
                     const unsigned nChannels,
                     const unsigned nPipes    )
{
    Compound* compound = config->getCompounds()[0];

    vector<float> ranges( nChannels + 1, 0 );
    ranges[ nChannels ] = 1.0;
    for( unsigned i = 1; i < nChannels; ++i )
        ranges[ i ] = ranges[ i-1 ] + 1.0/nChannels;

    unsigned i = 0;
    // for each node
    for( unsigned n = 0 ; n < nChannels/nPipes; ++n )
    {
        Compound* childNode = compound;

        if( n != 0 ) // don't create separate compound for dst channel
        {
            childNode = new Compound( compound );
            std::ostringstream channelName;
            channelName << "channel" << n*nPipes;

            Channel* childChannel = config->find< Channel >( channelName.str());
            childNode->setChannel( childChannel );
        }

        // for each gpu on the node
        for( unsigned p = 0; p < nPipes; ++p )
        {
            Compound* childPipe = new Compound( childNode );
            childPipe->setRange( eq::Range( ranges[ i ], ranges[ i+1 ] ));

            if( i != n*nPipes )
            {
                std::ostringstream channelName;
                channelName << "channel" << i;

                Channel* childChannel =
                    config->find< Channel >( channelName.str( ));
                childPipe->setChannel( childChannel );

                std::ostringstream frameName;
                frameName << "frame.channel" << i;

                childPipe->addOutputFrame( ::Frame::create( frameName ));
                childNode->addInputFrame(  ::Frame::create( frameName ));
            }
            i++;
        }
        if( n != 0 ) // dst channel has no output
        {
            std::ostringstream frameName;
            frameName << "frame.channel" << n*nPipes;

            childNode->addOutputFrame( ::Frame::create( frameName ));
            compound->addInputFrame(   ::Frame::create( frameName ));
        }
    }
}

void TreeEqualizer::_assign( Node* node, const Viewport& vp,
                             const Range& range )
{
    LBLOG( LOG_LB2 ) << "assign " << vp << ", " << range << " time "
                     << node->time << " split " << node->split << std::endl;
    LBASSERTINFO( vp.isValid(), vp );
    LBASSERTINFO( range.isValid(), range );
    LBASSERTINFO( node->resources > 0.f || !vp.hasArea() || !range.hasData(),
                  "Assigning work to unused compound: " << vp << ", " << range);

    Compound* compound = node->compound;
    if( compound )
    {
        LBASSERTINFO( vp == Viewport::FULL || range == Range::ALL,
                      "Mixed 2D/DB load-balancing not implemented" );

        compound->setViewport( vp );
        compound->setRange( range );
        LBLOG( LOG_LB2 ) << compound->getChannel()->getName() << " set " << vp
                         << ", " << range << std::endl;
        return;
    }

    switch( node->mode )
    {
    case MODE_VERTICAL:
    {
        // Ensure minimum size
        const Compound* root = getCompound();
        const float pvpW = float( root->getInheritPixelViewport().w );
        const float end = vp.getXEnd();
        const float boundary = float( node->boundary2i.x( )) / pvpW;
        float absoluteSplit = vp.x + vp.w * node->split;

        if( node->left->resources == 0.f )
            absoluteSplit = vp.x;
        else if( node->right->resources == 0.f )
            absoluteSplit = end;
        else if( boundary > 0 )
        {
            const float right = vp.getXEnd() - absoluteSplit;
            const float left = absoluteSplit - vp.x;
            const float maxRight = float( node->right->maxSize.x( )) / pvpW;
            const float maxLeft = float( node->left->maxSize.x( )) / pvpW;

            if( right > maxRight )
                absoluteSplit = end - maxRight;
            else if( left > maxLeft )
                absoluteSplit = vp.x + maxLeft;
            
            if( (absoluteSplit - vp.x) < boundary )
                absoluteSplit = vp.x + boundary;
            if( (end - absoluteSplit) < boundary )
                absoluteSplit = end - boundary;
                
            const uint32_t ratio = uint32_t( absoluteSplit / boundary + .5f );
            absoluteSplit = ratio * boundary;
        }

        absoluteSplit = LB_MAX( absoluteSplit, vp.x );
        absoluteSplit = LB_MIN( absoluteSplit, end);

        node->split = (absoluteSplit - vp.x ) / vp.w;
        LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at X "
                         << node->split << std::endl;

        // traverse children
        Viewport childVP = vp;
        childVP.w = (absoluteSplit - vp.x);
        _assign( node->left, childVP, range );

        childVP.x = childVP.getXEnd();
        childVP.w = end - childVP.x;

        // Fix 2994111: Rounding errors with 2D LB and 16 sources
        //   Floating point rounding may create a width for the 'right'
        //   child which is slightly below the parent width. Correct it.
        while( childVP.getXEnd() < end )
            childVP.w += std::numeric_limits< float >::epsilon();

        _assign( node->right, childVP, range );
        break;
    }

    case MODE_HORIZONTAL:
    {
        // Ensure minimum size
        const Compound* root = getCompound();
        const float pvpH = float( root->getInheritPixelViewport().h );
        const float end = vp.getYEnd();
        const float boundary = float( node->boundary2i.y( )) / pvpH;
        float absoluteSplit = vp.y + vp.h * node->split;

        if( node->left->resources == 0.f )
            absoluteSplit = vp.y;
        else if( node->right->resources == 0.f )
            absoluteSplit = end;
        else if( boundary > 0 )
        {
            const float right = vp.getYEnd() - absoluteSplit;
//.........这里部分代码省略.........

/** DB_ds rendering when each node compose result from its pipes on to first 
    pipe, then result is used in DB_ds compositing between nodes */
static void _modeDS(       Config*                config,
                     const unsigned               nChannels,
                     const unsigned               nPipes,
                     const vector< vector<int> >& descr,
                     const vector<float>&         xMarks,
                     const vector<float>&         yMarks  )
{
    Compound* compound = config->getCompounds()[0];

    vector<float> ranges( nChannels + 1, 0 );
    ranges[ nChannels ] = 1.0;
    for( unsigned i = 1; i < nChannels; ++i )
        ranges[ i ] = ranges[ i-1 ] + 1.0/nChannels;

    const unsigned nNodes = nChannels/nPipes;
    if( descr.size() < nNodes )
    {
        cerr << "Description file is incomplete" << std::endl;
        return;
    }

    const int rows      = int( yMarks.size( )) - 1;
    const int columns   = int( xMarks.size( )) - 1;
    const int cells     = rows*columns;

    // check that all specified viewports are within a grid
    for( size_t i = 0; i < nNodes; ++i  )
    {
        const vector< int >& vals = descr[i];
        for( size_t j  = 0; j < vals.size(); ++j )
            if( vals[j] >= cells || vals[j] < 0 )
            {
                cerr << "description of region is invalid: "
                     << vals[j] << " no such cell" << std::endl;
                return;
            }
    }

    // fill all viewports for grid
    vector< eq::Viewport > tmpVP;
    for( int y = 0; y < rows; ++y )
        for( int x = 0; x < columns; ++x )
            tmpVP.push_back( eq::Viewport( xMarks[x],
                                           yMarks[y],
                                           xMarks[x+1]-xMarks[x],
                                           yMarks[y+1]-yMarks[y] ));
    // build per-node viewports
    vector< eq::Viewport > vp( nNodes );
    for( size_t i = 0; i < nNodes; ++i  )
    {
        const vector< int >& vals = descr[i];
        vp[i] = tmpVP[vals[0]];

        for( size_t j  = 1; j < vals.size(); ++j )
            vp[i].unite( tmpVP[vals[j]] );
    }

    unsigned i = 0;
    // for each node
    for( unsigned n = 0 ; n < nNodes; ++n )
    {
        Compound* child = compound;

        if( n != 0 ) // don't create separate compound for dst channel
        {
            child = new Compound( compound );
            std::ostringstream channelName;
            channelName << "channel" << n*nPipes;

            Channel* childChannel = config->find< Channel >( channelName.str());
            child->setChannel( childChannel );
        }

        Compound* childNode = new Compound( child );

        // for each gpu on the node
        for( unsigned p = 0; p < nPipes; ++p )
        {
            Compound* childPipe = new Compound( childNode );
            childPipe->setRange( eq::Range( ranges[ i ], ranges[ i+1 ] ));

            if( i != n*nPipes )
            {
                std::ostringstream channelName;
                channelName << "channel" << i;

                Channel* childChannel =
                    config->find< Channel >( channelName.str( ));
                childPipe->setChannel( childChannel );


                std::ostringstream frameName;
                frameName << "frame.channel" << i;

                childPipe->addOutputFrame( ::Frame::create( frameName ));
                childNode->addInputFrame(  ::Frame::create( frameName ));
            }
            i++;
//.........这里部分代码省略.........