~ubuntu-branches/ubuntu/precise/okular/precise-proposed

struct WordWithCharacters

{

    WordWithCharacters(TinyTextEntity *w, const TextList &c)

     : word(w), characters(c)

    {

    }

    

    inline QString text() const

    {

        return word->text();

    }

    

    inline const NormalizedRect &area() const

    {

      return word->area;

    }

    

    TinyTextEntity *word;

    TextList characters;

};

typedef QList<WordWithCharacters> WordsWithCharacters;

 

 * associated WordsWithCharacters in sorted order.

    RegionText(const WordsWithCharacters &wordsWithCharacters, const QRect &area)

        : m_region_wordWithCharacters(wordsWithCharacters), m_area(area)

        foreach(const WordWithCharacters &word, m_region_wordWithCharacters)

            res += word.text();

    inline WordsWithCharacters text() const

        return m_region_wordWithCharacters;

    inline void setText(const WordsWithCharacters &wordsWithCharacters)

        m_region_wordWithCharacters = wordsWithCharacters;

    WordsWithCharacters m_region_wordWithCharacters;

static bool compareTinyTextEntityX(const WordWithCharacters &first, const WordWithCharacters &second)

    QRect firstArea = first.area().roundedGeometry(1000,1000);

    QRect secondArea = second.area().roundedGeometry(1000,1000);

static bool compareTinyTextEntityY(const WordWithCharacters &first, const WordWithCharacters &second)

    const QRect firstArea = first.area().roundedGeometry(1000,1000);

    const QRect secondArea = second.area().roundedGeometry(1000,1000);

 * Sets a new world list. Deleting the contents of the old one

static void removeSpace(TextList *words)

    TextList::Iterator it = words->begin(), itEnd = words->end();

            it = words->erase(it);

 * We will read the TinyTextEntity from characters and try to create words from there.

 * Note: characters might be already characters for some generators, but we will keep

 * the nomenclature characters for the generator produced data. The resulting

 * WordsWithCharacters memory has to be managed by the caller, both the 

 * WordWithCharacters::word and WordWithCharacters::characters contents

static WordsWithCharacters makeWordFromCharacters(const TextList &characters, int pageWidth, int pageHeight)

     * We will traverse characters and try to create words from the TinyTextEntities in it.

     * We create a RegionText named regionWord that contains the word and the characters associated with it and

     * a rectangle area of the element in newList. 

    WordsWithCharacters wordsWithCharacters;

 

    TextList::ConstIterator it = characters.begin(), itEnd = characters.end(), tmpIt;

        TextList wordCharacters;

        while (!space)

            if (textString.length())

                if (tmpIt == it)

                    wordCharacters.append(new TinyTextEntity(textString.normalized

                    wordCharacters.append(new TinyTextEntity(textString.normalized

            ++it;

            if (it == itEnd) break;

            if (!doesConsumeY(elementArea, lineArea, 60))

                --it;

            if (space != 0)

        if (!newString.isEmpty())

            const NormalizedRect newRect(lineArea, pageWidth, pageHeight);

            TinyTextEntity *word = new TinyTextEntity(newString.normalized(QString::NormalizationForm_KC), newRect);

            wordsWithCharacters.append(WordWithCharacters(word, wordCharacters));

    

    return wordsWithCharacters;

QList< QPair<WordsWithCharacters, QRect> > makeAndSortLines(const WordsWithCharacters &wordsTmp, int pageWidth, int pageHeight)

    

    QList< QPair<WordsWithCharacters, QRect> > lines;

    QList<WordWithCharacters> words = wordsTmp;

    QList<WordWithCharacters>::Iterator it = words.begin(), itEnd = words.end();

        const QRect elementArea = (*it).area().roundedGeometry(pageWidth,pageHeight);

        for( int i = 0 ; i < lines.length() ; i++)

            QRect &lineArea = lines[i].second;

                WordsWithCharacters &line = lines[i].first;

            WordsWithCharacters tmp;

            lines.append(QPair<WordsWithCharacters, QRect>(tmp, elementArea));

    for(int i = 0 ; i < lines.length() ; i++)

        WordsWithCharacters &list = lines[i].first;

        qSort(list.begin(), list.end(), compareTinyTextEntityX);

    

    return lines;

static void calculateStatisticalInformation(const QList<WordWithCharacters> &words, int pageWidth, int pageHeight, int *word_spacing, int *line_spacing, int *col_spacing)

    

    /**

     * Step 0

     */

    const QList< QPair<WordsWithCharacters, QRect> > sortedLines = makeAndSortLines(words, pageWidth, pageHeight);

    for(int i = 0 ; i < sortedLines.length(); i++)

        const QRect rectUpper = sortedLines.at(i).second;

        if(i+1 == sortedLines.length()) break;

        const QRect rectLower = sortedLines.at(i+1).second;

    for(int i = 0 ; i < sortedLines.length() ; i++)

        const WordsWithCharacters list = sortedLines.at(i).first;

        WordsWithCharacters::ConstIterator it = list.begin(), itEnd = list.end();

            const QRect area1 = (*it).area().roundedGeometry(pageWidth,pageHeight);

            const QRect area2 = (*(it+1)).area().roundedGeometry(pageWidth,pageHeight);

                before_max = (*it).text();

                after_max = (*(it+1)).text();

    if(sortedLines.length() == 1)

 * The resulting RegionTextList will contain RegionText whose WordsWithCharacters::word and

 * WordsWithCharacters::characters are reused from wordsWithCharacters (i.e. no new nor delete happens in this function)

static RegionTextList XYCutForBoundingBoxes(const QList<WordWithCharacters> &wordsWithCharacters, const NormalizedRect &boundingBox, int pageWidth, int pageHeight)

    QRect contentRect(boundingBox.geometry(pageWidth,pageHeight));

    const RegionText root(wordsWithCharacters, contentRect);

    int i = 0;

        int size_proj_y = node.area().height();

        int size_proj_x = node.area().width();

        for( int j = 0 ; j < size_proj_y ; ++j ) proj_on_yaxis[j] = 0;

        for( int j = 0 ; j < size_proj_x ; ++j ) proj_on_xaxis[j] = 0;

        const QList<WordWithCharacters> list = node.text();

        int word_spacing, line_spacing, column_spacing;

        calculateStatisticalInformation(list, pageWidth, pageHeight, &word_spacing, &line_spacing, &column_spacing);

 

        const int tcx = word_spacing * 2;

        const int tcy = line_spacing * 2;

        int avgX = 0;

        for(int j = 0 ; j < list.length() ; ++j )

            TinyTextEntity *ent = list.at(j).word;

            const QRect entRect = ent->area.geometry(pageWidth, pageHeight);

            for(int k = entRect.left() ; k <= entRect.left() + entRect.width() ; ++k)

            for(int k = entRect.top() ; k <= entRect.top() + entRect.height() ; ++k)

        for( int j = 0 ; j < size_proj_y ; ++j )

        for( int j = 0 ; j < size_proj_x ; ++j )

        for( int j = 0 ; j < size_proj_x ; ++j )

        for( int j = 0 ; j < size_proj_y ; ++j )

        for(int j = 1 ; j < size_proj_y ; ++j)

        for(int j = 1 ; j < size_proj_x ; ++j)

        WordsWithCharacters list1,list2;

            for( int j = 0 ; j < list.length() ; ++j )

                const WordWithCharacters word = list.at(j);

                const QRect wordRect = word.area().geometry(pageWidth,pageHeight);

                if(topRect.intersects(wordRect))

                    list1.append(word);

                    list2.append(word);

            for( int j = 0 ; j < list.length() ; ++j )

                const WordWithCharacters word = list.at(j);

                const QRect wordRect = word.area().geometry(pageWidth,pageHeight);

                if(leftRect.intersects(wordRect))

                    list1.append(word);

                else 

                    list2.append(word);

 * Add spaces in between words in a line. It reuses the pointers passed in tree and might add new ones. You will need to take care of deleting them if needed

WordsWithCharacters addNecessarySpace(RegionTextList tree, int pageWidth, int pageHeight)

     * 3. Finally, extract all the space separated texts from each region and return it

        QList< QPair<WordsWithCharacters, QRect> > sortedLines = makeAndSortLines(tmpRegion.text(), pageWidth, pageHeight);

        for(int i = 0 ; i < sortedLines.length() ; i++)

            WordsWithCharacters &list = sortedLines[i].first;

                const QRect area1 = list.at(k).area().roundedGeometry(pageWidth,pageHeight);

                const QRect area2 = list.at(k+1).area().roundedGeometry(pageWidth,pageHeight);

                    TinyTextEntity *ent1 = new TinyTextEntity(spaceStr, entRect);

                    TinyTextEntity *ent2 = new TinyTextEntity(spaceStr, entRect);

                    WordWithCharacters word(ent1, QList<TinyTextEntity*>() << ent2);

                    list.insert(k+1, word);

        WordsWithCharacters tmpList;

        for(int i = 0 ; i < sortedLines.length() ; i++)

            tmpList += sortedLines.at(i).first;

    WordsWithCharacters tmp;

    return tmp;

}

    const int pageWidth = m_page->m_page->width();

    const int pageHeight = m_page->m_page->height();

 

    TextList characters = m_words;

 

    removeSpace(&characters);

    const QList<WordWithCharacters> wordsWithCharacters = makeWordFromCharacters(characters, pageWidth, pageHeight);

    const RegionTextList tree = XYCutForBoundingBoxes(wordsWithCharacters, m_page->m_page->boundingBox(), pageWidth, pageHeight);

    const WordsWithCharacters listWithWordsAndSpaces = addNecessarySpace(tree, pageWidth, pageHeight);

    TextList listOfCharacters;

    foreach(const WordWithCharacters &word, listWithWordsAndSpaces)

    {

        delete word.word;

        listOfCharacters.append(word.characters);

    }

    setWordList(listOfCharacters);