jp2tileprogriterator.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

        unsigned int stepX = m_sampleSizeRG[component].Width () * (1 << (precStepOrder[resLevel].Width () + nOfResLevels - resLevel - 1));
        unsigned int stepY = m_sampleSizeRG[component].Height() * (1 << (precStepOrder[resLevel].Height() + nOfResLevels - resLevel - 1));
        m_stepX = (!m_stepX) ? stepX : Min(m_stepX, stepX);
        m_stepY = (!m_stepY) ? stepY : Min(m_stepY, stepY);
    }
}

void JP2TileProgrIterator::OptimizeStepPerComponent(unsigned int component)
{
    m_stepX = 0; m_stepY = 0;
    MinimizeStepPerComponent(component);
}

void JP2TileProgrIterator::OptimizeStepAll()
{
    m_stepX = 0; m_stepY = 0;
    for (unsigned int component = 0; component < NOfComponents(); component++)
        MinimizeStepPerComponent(component);
}

// pcrl, rpcl,
bool JP2TileProgrIterator::DoPrecinctChange(const RectSize &precStepOrder, unsigned int nOfResLevels)
{
    unsigned int r    = nOfResLevels - 1 - m_resLevel;
    unsigned int rpx  = r + precStepOrder.Width() ;
    unsigned int rpy  = r + precStepOrder.Height();

    unsigned int trx0 = DivCeil(m_originX, m_sampleSizeRG[m_component].Width()  << r);
    unsigned int try0 = DivCeil(m_originY, m_sampleSizeRG[m_component].Height() << r);

    bool res =  ((m_x == m_originX && ((trx0 << r) % (1 << rpx))) || !(m_x % (1 << rpx)))
             && ((m_y == m_originY && ((try0 << r) % (1 << rpy))) || !(m_y % (1 << rpy)));

    if(res)
    {
        m_precinctX = RShiftFloor(DivCeil(m_x, m_sampleSizeRG[m_component].Width()  << r), precStepOrder.Width() ) - RShiftFloor(trx0, precStepOrder.Width() );
        m_precinctY = RShiftFloor(DivCeil(m_y, m_sampleSizeRG[m_component].Height() << r), precStepOrder.Height()) - RShiftFloor(try0, precStepOrder.Height());
    }

    return res;
}

bool JP2TileProgrIterator::DoPrecinctChangeCPRL(const RectSize &precStepOrder, unsigned int nOfResLevels)
{
    unsigned int r    = nOfResLevels - 1 - m_resLevel;
    unsigned int rpx  = r + precStepOrder.Width() ;
    unsigned int rpy  = r + precStepOrder.Height();

    unsigned int trx0 = DivCeil(m_originX, m_sampleSizeRG[m_component].Width()  << r);
    unsigned int try0 = DivCeil(m_originY, m_sampleSizeRG[m_component].Height() << r);

    bool res =  ((m_x == m_originX && ((trx0 << r) % (1 << rpx))) || !(m_x % (m_sampleSizeRG[m_component].Width()  << rpx)))
             && ((m_y == m_originY && ((try0 << r) % (1 << rpy))) || !(m_y % (m_sampleSizeRG[m_component].Height() << rpy)));

    if(res)
    {
        m_precinctX = RShiftFloor(DivCeil(m_x, m_sampleSizeRG[m_component].Width()  << r), precStepOrder.Width() ) - RShiftFloor(trx0, precStepOrder.Width() );
        m_precinctY = RShiftFloor(DivCeil(m_y, m_sampleSizeRG[m_component].Height() << r), precStepOrder.Height()) - RShiftFloor(try0, precStepOrder.Height());
    }

    return res;
}

bool JP2TileProgrIterator::StepLRCP()
{
    if (!m_isFirstVolume)  goto enter;
    else m_isFirstVolume = false;

    for (m_layer     =                0; m_layer     < NOfLayers     (); m_layer    ++)
    for (m_resLevel  = ResLevelFirst (); m_resLevel  < ResLevelBound (); m_resLevel ++)
    for (m_component = ComponentFirst(); m_component < ComponentBound(); m_component++)
    {
        if (m_resLevel >= CodingStyle(m_component).NOfResLevels()) continue;

        for (m_precinctY = 0; m_precinctY < PrecinctNOfRows(); m_precinctY++)
        for (m_precinctX = 0; m_precinctX < PrecinctNOfCols(); m_precinctX++)
        {
            if (m_layer >= PrecinctLayer())
            {
                PrecinctLayer() = m_layer;
                PrecinctLayer()++;
                return true;
            }
enter:
            ;
        }
    }
    return false;
}

bool JP2TileProgrIterator::StepRLCP()
{
    if (!m_isFirstVolume)  goto enter;
    else m_isFirstVolume = false;

    for (m_resLevel  = ResLevelFirst (); m_resLevel  < ResLevelBound (); m_resLevel ++)
    for (m_layer     =                0; m_layer     < NOfLayers     (); m_layer    ++)
    for (m_component = ComponentFirst(); m_component < ComponentBound(); m_component++)
    {
        if (m_resLevel >= CodingStyle(m_component).NOfResLevels()) continue;

        for (m_precinctY = 0; m_precinctY < PrecinctNOfRows(); m_precinctY++)
        for (m_precinctX = 0; m_precinctX < PrecinctNOfCols(); m_precinctX++)
        {
            if (m_layer >= PrecinctLayer())
            {
                PrecinctLayer() = m_layer;
                PrecinctLayer()++;
                return true;
            }
enter:
            ;
        }
    }
    return false;
}

bool JP2TileProgrIterator::StepRPCL()
{
    unsigned int    nOfResLevels;
    const RectSize *precStepOrder;

    if (!m_isFirstVolume)
    {
        nOfResLevels  = CodingStyle(m_component).NOfResLevels ();
        precStepOrder = CodingStyle(m_component).PrecStepOrder();
        goto  enter;
    }
    else
    {
        OptimizeStepAll();
        m_isFirstVolume = false;
    }


    for (m_resLevel  = ResLevelFirst() ; m_resLevel  < ResLevelBound (); m_resLevel++)
    for (m_y         = m_originY       ; m_y         < m_boundY        ; m_y += m_stepY - (m_y % m_stepY))
    for (m_x         = m_originX       ; m_x         < m_boundX        ; m_x += m_stepX - (m_x % m_stepX))
    for (m_component = ComponentFirst(); m_component < ComponentBound(); m_component++)
    {
        nOfResLevels  = CodingStyle(m_component).NOfResLevels ();
        precStepOrder = CodingStyle(m_component).PrecStepOrder();

        if (m_resLevel >= nOfResLevels)  continue;
        if (IsEmptyResLevel())           continue;

        if (DoPrecinctChange(precStepOrder[m_resLevel], nOfResLevels))
        {
            for (m_layer = 0; m_layer < NOfLayers(); m_layer++)
            {
                if (m_layer >= PrecinctLayer())
                {
                    PrecinctLayer()++;
                    return true;
                }
enter:
                ;
            }
        }
    }
    return false;
}

bool JP2TileProgrIterator::StepPCRL()
{
    unsigned int    nOfResLevels;
    const RectSize *precStepOrder;

    if (!m_isFirstVolume)
    {
        nOfResLevels  = CodingStyle(m_component).NOfResLevels ();
        precStepOrder = CodingStyle(m_component).PrecStepOrder();
        goto  enter;
    }
    else
    {
        OptimizeStepAll();
        m_isFirstVolume = false;
    }

    for (m_y         =        m_originY; m_y         < m_boundY        ; m_y += m_stepY - (m_y % m_stepY))
    for (m_x         =        m_originX; m_x         < m_boundX        ; m_x += m_stepX - (m_x % m_stepX))
    for (m_component = ComponentFirst(); m_component < ComponentBound(); m_component++)
    {
        nOfResLevels  = CodingStyle(m_component).NOfResLevels ();
        precStepOrder = CodingStyle(m_component).PrecStepOrder();

        for (m_resLevel = ResLevelFirst(); m_resLevel < nOfResLevels && m_resLevel < ResLevelBound(); ++m_resLevel)
        {
            if (IsEmptyResLevel()) continue;

            if (DoPrecinctChange(precStepOrder[m_resLevel], nOfResLevels))
            {
                for (m_layer = 0; m_layer < NOfLayers(); m_layer++)
                {
                    if (m_layer >= PrecinctLayer())
                    {
                        PrecinctLayer()++;
                        return true;
                    }
enter:
                    ;
                }
            }
        }
    }

    return false;
}

bool JP2TileProgrIterator::StepCPRL()
{
    unsigned int    nOfResLevels;
    const RectSize *precStepOrder;

    if (!m_isFirstVolume)
    {
        nOfResLevels  = CodingStyle(m_component).NOfResLevels ();
        precStepOrder = CodingStyle(m_component).PrecStepOrder();
        goto  enter;
    }
    else m_isFirstVolume = false;

    for (m_component = ComponentFirst(); m_component < ComponentBound(); ++m_component)
    {
        nOfResLevels  = CodingStyle(m_component).NOfResLevels ();
        precStepOrder = CodingStyle(m_component).PrecStepOrder();

        OptimizeStepPerComponent(m_component);

        for (m_y = m_originY; m_y < m_boundY; m_y += m_stepY - (m_y % m_stepY))
        for (m_x = m_originX; m_x < m_boundX; m_x += m_stepX - (m_x % m_stepX))
        {
            for (m_resLevel = ResLevelFirst(); m_resLevel < nOfResLevels && m_resLevel < ResLevelBound(); ++m_resLevel)
            {
                if (IsEmptyResLevel()) continue;

                if (DoPrecinctChangeCPRL(precStepOrder[m_resLevel], nOfResLevels))
                {
                    for (m_layer = 0; m_layer < NOfLayers(); m_layer++)
                    {
                        if (m_layer >= PrecinctLayer())
                        {
                            PrecinctLayer()++;
                            return true;
                        }
enter:
                        ;
                    }
                }
            }
        }
    }
    return false;
}