Nesta se¸c˜ao s˜ao apresentados os conceitos e defini¸c˜oes necess´arios para o entendimento do problema e do algoritmo proposto. As de- fini¸c˜oes s˜ao exemplificadas com o aux´ılio da Figura 2.
Defini¸c˜ao 1 ( ´Arvore DOM) . A ´arvore DOM (Document Object Model) ´e uma estrutura hier´arquica, derivada do c´odigo HTML, que representa uma p´agina web. Cada n´o desta ´arvore representa um “ob- jeto” do documento HTML. A especifica¸c˜ao de referˆencia ´e mantida pelo cons´orcio W 3C (W3C, 2005) que ´e o ´org˜ao encarregado de manter os padr˜oes e especifica¸c˜oes da web.
Exemplo. Na Figura 2 um pequeno trecho de c´odigo HTML ´e utilizado para ilustrar como uma ´arvore DOM ´e constru´ıda a partir do c´odigo. Defini¸c˜ao 2 (tag paths) . Um tag path (TP) ´e uma string descre- vendo o caminho absoluto, a partir da raiz da ´arvore DOM, at´e um dado n´o da ´arvore. Seja “ni” um determinado n´o da ´arvore DOM,
onde “i” representa a posi¸c˜ao/ordem, em profundidade, do n´o “ni” na
´
arvore, ent˜ao ´e dito que T Pi´e a string descrevendo o caminho, a partir
37
Exemplo. Na Figura 2, o caminho absoluto T P4 do n´o body at´e a
c´elula da tabela td4´e T P4= “body/table/tr/td”.
Defini¸c˜ao 3 (Sequˆencia de tag paths) . Uma sequˆencia de tag paths (TPS) de uma ´arvore DOM com “n” n´os ´e definida como sendo a sequˆencia ordenada T P S[1..n] = (T P1, T P2, T P3, ..., T Pn−1, T Pn) onde
dois tag paths T Pi e T Pj, com i 6= j, s˜ao considerados iguais apenas
se seus caminhos e suas defini¸c˜oes de estilo s˜ao iguais, caso contr´ario eles s˜ao considerados diferentes.
Exemplo. Na Figura 2 ´e mostrada a T P S de um dado trecho de c´odigo HTML, onde cada T P recebe um c´odigo, produzindo T P S = (1, 2, 3, 4, 4, 3, 4, 4). Na sequˆencia de tag paths os tag paths n˜ao s˜ao re- presentados pelas suas strings, mas sim por c´odigos (ou s´ımbolos), com objetivo de facilitar sua manipula¸c˜ao, onde tag paths iguais recebem o mesmo c´odigo. Esta defini¸c˜ao ´e similar `a utilizada em Xie et al. (2012), onde cada tag path ´e representado na sequˆencia por um s´ımbolo, ex- ceto que neste trabalho foram incorporadas as defini¸c˜oes de estilo das tags. Como as defini¸c˜oes CSS s˜ao utilizadas para diferenciar e caracte- rizar as diversas regi˜oes de uma p´agina, ´e muito importante levar em considera¸c˜ao essas defini¸c˜oes na momento de segmentar a p´agina. Defini¸c˜ao 4 (Alfabeto da TPS) . Seja Σ o conjunto contendo to- dos os s´ımbolos de uma dada sequˆencia T P S de tamanho “n”, Σ ´e dito o alfabeto de T P S definido como Σ = {α|T P S[i] = α ∧ 1 ≤ i ≤ n}, onde α ´e um s´ımbolo do alfabeto.
Exemplo. Na Figura 2, a T P S ´e formada apenas pelos s´ımbolos “1”,“2”, “3” e “4”, ent˜ao seu alfabeto ´e Σ = {1, 2, 3, 4}. Informal- mente falando, o alfabeto cont´em todos os s´ımbolos distintos de uma determinada sequˆencia.
Defini¸c˜ao 5 (Conjunto de frequˆencias de tag paths) . Seja (s, f ) um par ordenado onde “s” ´e um s´ımbolo de um alfabeto de uma determinada TPS e “f ” ´e o n´umero de vezes que o s´ımbolo “s” ocorre nesta TPS, ent˜ao o conjunto de frequˆencias F S de uma TPS ´e definido como sendo o conjunto de todos os pares (s, f ) existentes nesta TPS, ou seja F S = {(s1, fs1), (s2, fs2), (s3, fs3), . . . , (sn−1, fsn−1), (sn, fsn)},
onde “n”´e o tamanho do alfabeto da TPS.
Exemplo. Na Figura 2, o s´ımbolo “1” ocorre uma vez na sequˆencia, o s´ımbolo “2” ocorre uma vez tamb´em, o s´ımbolo “3” duas ve- zes e o s´ımbolo “4” quatro vezes, ent˜ao para esta sequˆencia F S =
38
{(1, 1), (2, 1), (3, 2), (4, 4)}. O conjunto F S ´e o mapeamento de todos os s´ımbolos de uma sequˆencia para suas respectivas frequˆencias.
Defini¸c˜ao 6 (Limiares de frequˆencia) . Dada uma T P S com al- fabeto Σ e conjunto de frequˆencias F S, os limiares de frequˆencia F T s˜ao definidos como sendo a sequˆencia ordenada contendo apenas as frequˆencias distintas de F S. Assim, temos que F T = {f |∃(s, f ) ∧ (s, f ) ∈ F S ∧ s ∈ Σ}, onde “s” ´e um s´ımbolo do alfabeto Σ e “f ” ´e sua respectiva frequˆencia.
Exemplo. Na TPS exibida na Figura 2, o conjunto de frequˆencias dos tag paths ´e F S = {(1, 1), (2, 1), (3, 2), (4, 4)}. Neste caso, o conjunto dos limiares de frequˆencia ´e igual a F T = {1, 2, 4}, pois os s´ımbolos “1” e “2” tem frequˆencia igual a 1, o s´ımbolo “3” tem frequˆencia igual a 2 e o s´ımbolo “4” tem frequˆencia igual a 4. O conjunto F T ´e necess´ario para filtrar os s´ımbolos da TPS. Se F T = {1, 2, 4}, ent˜ao n˜ao faria sentido filtrar s´ımbolos com frequˆencia igual a 3, pois n˜ao existem s´ımbolos na sequˆencia com esta frequˆencia.
Defini¸c˜ao 7 (Regi˜ao) . Seja uma TPS a concatena¸c˜ao de duas ou- tras sequˆencias T P S = T P Sa.T P Sb, ent˜ao ´e dito que T P Sa e T P Sb
s˜ao regi˜oes de T P S, sse Σa∩ Σb= ∅.
Exemplo. Na Figura 2 a TPS pode ser dividida em duas subsequˆencias T P Sa = T P S[1..2] = (1, 2) e T P Sb= T P S[3..8] = (3, 4, 4, 3, 4, 4), com
alfabetos Σa = {1, 2} e Σb = {3, 4}, ent˜ao T P Sa a T P Sb s˜ao regi˜oes
distintas de T P S, pois a intersec¸c˜ao de seus respectivos alfabetos ´e vazia.
3.3 PROPOSTA
No presente trabalho ´e proposto um novo algoritmo para seg- menta¸c˜ao das regi˜oes de uma p´agina web e identifica¸c˜ao da regi˜ao prin- cipal. O algoritmo proposto leva em considera¸c˜ao a estrutura e o estilo de formata¸c˜ao das p´aginas e ´e computacionalmente eficiente pois, con- forme demonstrado mais adiante, na Se¸c˜ao 3.5, sua complexidade ´e, na m´edia, linear em rela¸c˜ao ao tamanho da p´agina. A p´agina web, que ´e submetida ao algoritmo, ´e representada como uma sequˆencia de tag paths. O algoritmo proposto ´e formulado a partir de duas hip´oteses:
39
1. diferentes regi˜oes de uma p´agina web s˜ao descritas por diferentes tag paths;
A formula¸c˜ao da hip´otese 1 vem da observa¸c˜ao de que as v´arias regi˜oes de uma p´agina web s˜ao diferentes ramifica¸c˜oes da ´arvore DOM e essas regi˜oes s˜ao descritas ou utilizando tags distintas para cada regi˜ao ou, se as tags forem semelhantes, com diferentes estilos, para que cada regi˜ao possa ser facilmente distinguida pelo usu´ario/leitor da p´agina. Se todas as regi˜oes de uma p´agina se parecessem, seria mais dif´ıcil, para o usu´ario, distingui-las. Ent˜ao, pela Defini¸c˜ao 3, pode-se notar que os s´ımbolos utilizados em cada regi˜ao de uma p´agina web deveriam ser diferentes, e ent˜ao deve ser poss´ıvel segmentar a p´agina como apresentado na Defini¸c˜ao 7. Esta hip´otese, como ´e poss´ıvel observar, ´e geral o suficiente para poder ser reutilizada em outros contextos, com objetivo de segmentar p´aginas web, que n˜ao o de extra¸c˜ao estruturada. 2. em sites com conte´udo estruturado, a regi˜ao principal ´e mais
densa/maior que as demais regi˜oes (menus, an´uncios, texto, etc.). A hip´otese 2 vem do contexto no qual a segmenta¸c˜ao proposta neste trabalho ´e aplicada (i.e. extra¸c˜ao estruturada). Como se est´a considerando apenas p´aginas com registros, e para descre- ver a estrutura desses registros s˜ao necess´arios n´os da ´arvore DOM, ent˜ao s˜ao necess´arios mais n´os para descrever conte´udo estruturado do que ´e necess´ario para conte´udo n˜ao estruturado (e.g. texto). Portanto, ´e razo´avel assumir que, para p´aginas que contˆem registros, a regi˜ao principal da p´agina ´e a maior de todas (i.e. a que cont´em mais n´os).
Utilizando as defini¸c˜oes da Se¸c˜ao 3.2 e as hip´oteses acima, po- demos formular o problema de segmenta¸c˜ao de p´aginas e identifica¸c˜ao da regi˜ao principal como: “encontrar a maior regi˜ao da T P S de uma p´agina web que possua um alf abeto que n˜ao se intersecte com o alf abeto de outras regi˜oes menores”.
Um detalhe crucial que deve ser levado em considera¸c˜ao, ´e que podem existir tag paths em um documento que representam divis˜oes estruturais da p´agina (i.e. formata¸c˜ao visual da p´agina). Estes tag paths, se forem divis˜oes, ocorrer˜ao ao longo de toda a T P S, impedindo a identifica¸c˜ao das regi˜oes, pois sempre haver´a uma intersec¸c˜ao dos al- fabetos. Para remover este “ru´ıdo” da sequˆencia, podemos filtrar os s´ımbolos com frequˆencias mais baixas, sem prejudicar o processo de segmenta¸c˜ao, pois os s´ımbolos com frequˆencias mais altas continuam
40
sendo considerados. Para ilustrar este procedimento, ´e apresentado um exemplo de uma p´agina web na Listagem 3.1 que inicia e termina com o mesmo tag path (“/body/br”, Linhas 2 e 18) e tem trˆes regi˜oes delimi- tadas, tamb´em, pelo mesmo tag path (“/body/div”, Linhas 3, 8 e 13). Partindo da hip´otese 1, em que diferentes tag paths s˜ao utilizados para descrever cada regi˜ao, sem filtrar os s´ımbolos de baixa frequˆencia da T P S, n˜ao seria poss´ıvel identificar essas regi˜oes utilizando o algoritmo proposto. Listagem 3.1 – C´odigo HTML 1 <body> 2 <br> < !−− c a b e ¸c a l h o −−> 3 <div> < !−− menu −−> 4 <span c l a s s =’ r e g i o n 1 ’> . . . </span> 5 . . . 6 <span c l a s s =’ r e g i o n 1 ’> . . . </span> 7 </ div> 8 <div> < !−− r e g i ˜a o p r i n c i p a l −−> 9 <span c l a s s =’ r e g i o n 2 ’> . . . </span> 10 . . . 11 <span c l a s s =’ r e g i o n 2 ’> . . . </span> 12 </ div> 13 <div> < !−− p u b l i c i d a d e −−> 14 <span c l a s s =’ r e g i o n 3 ’> . . . </span> 15 . . . 16 <span c l a s s =’ r e g i o n 3 ’> . . . </span> 17 </ div> 18 <br> < !−− r o d a p´e −−> 19 </body>
A TPS, do c´odigo HTML apresentado na Listagem 3.1, ´e T P S = (1, 2, 3, 4, ..., 4, 3, 5, ..., 5, 3, 6, ..., 6, 2). Como os s´ımbolos 2 e 3 ocorrem ao longo de toda a sequˆencia, os alfabetos das regi˜oes de menus, publici- dade e da regi˜ao principal, sempre ter˜ao uma intersec¸c˜ao. Por´em, consi- derando agora, para fins ilustrativos, apenas os s´ımbolos com frequˆencia maior que 3, durante o processo de segmenta¸c˜ao ´e poss´ıvel encontrar as regi˜oes com alfabetos distintos (sem intersec¸c˜oes) e dividir a T P S da seguinte maneira:
T P Sf iltrada = (, , , 4, ..., 4, , 5, ..., 5, , 6, ..., 6, ) menus = (4, ..., 4)
principal = (5, ..., 5) publicidade = (6, ..., 6)
41
Neste exemplo, estipulamos uma determinada frequˆencia apenas para ilustrar qual o objetivo deste procedimento. Entretanto, no algo- ritmo searchRegion(), a filtragem, de fato, ´e realizada iterativamente. Cada frequˆencia ´e “testada” at´e que seja poss´ıvel localizar um ponto para dividir a sequˆencia.
3.4 ALGORITMOS
Nesta se¸c˜ao, s˜ao apresentados os algoritmos desenvolvidos para tratar o problema definido na Se¸c˜ao 3.3. Eles s˜ao os seguintes:
• tagP athSequenceF ilter() ´e o algoritmo de n´ıvel mais alto, que recebe um arquivo HTML como entrada, chama os demais algoritmos e retorna uma ´arvore DOM, podada, apenas com o conte´udo da regi˜ao principal;
• convertT oSeq() converte a ´arvore DOM de uma p´agina web para sua representa¸c˜ao T P S;
• searchRegion() ´e o algoritmo principal, que realiza a busca, propriamente dita, pela regi˜ao principal da T P S;
• f ilterAlphabet() filtra um alfabeto, removendo os s´ımbolos de menor frequˆencia, tornando o algoritmo de busca mais robusto e resistente ao ru´ıdo;
• pruneDOM T ree() poda a ´arvore DOM original, dei- xando apenas o conte´udo da regi˜ao principal encontrado com searchRegion, mantendo a estrutura do documento original.
42
A Figura 3 apresenta uma vis˜ao de alto n´ıvel da intera¸c˜ao exis- tente entre os algoritmos desenvolvidos no presente trabalho, com o algoritmo principal (searchRegion) destacado.
3.4.1 Algoritmo de tagP athSequenceF ilter()
Algoritmo 1 Filtra o ru´ıdo de uma p´agina web Input: inputF ile - um arquivo HTML
Output: ´arvore DOM de inputF ile podada
1: procedure tagPathSequenceFilter(inputF ile) 2: DOM T ree ← parseHT M L(inputF ile)
3: convertT oSeq(DOM T ree.body,“ ”, T P S) . “ ” = string vazia
4: searchRegion(T P S)
5: pruneDOM T ree(DOM T ree.body, T P S)
6: return DOM T ree
7: end procedure
O procedimento tagP athSequenceF ilter() no Algoritmo 1 re- torna a regi˜ao principal de inputF ile. O procedimento parseHT M L(), na Linha 2, converte o c´odigo HTML em uma ´arvore DOM; convertTo- Seq(), na Linha 3, converte a ´arvore DOM em uma TPS; o procedimento searchRegion(), na Linha 4, procura recursivamente pela maior regi˜ao da TPS que possui um alfabeto ´unico e, finalmente; pruneDOM T ree(), na Linha 5, retira da ´arvore DOM (poda) todos os n´os que n˜ao fazem parte da TPS resultante, preservando a estrutura do documento retor- nado na Linha 6.
Em seguida s˜ao detalhados os algoritmos convertT oSeq(), searchRegion(), f ilterAlphabet() e pruneDOM T ree(). O algoritmo parseHT M L(), que consiste em gerar a ´arvore DOM a partir do c´odigo HTML, n˜ao faz parte do escopo deste trabalho e, portanto, n˜ao ´e dis- cutido aqui.
3.4.2 Algoritmo de convertT oSeq()
O procedimento convertT oSeq() no Algoritmo 2 converte uma p´agina web de sua representa¸c˜ao em ´arvore DOM para uma repre- senta¸c˜ao em formato TPS, percorrendo a ´arvore DOM em profundi- dade. Inicialmente ´e chamado no Algoritmo 1 com um tag path vazio como parˆametro, que representa a string do tag path anterior (i.e. da
43
Algoritmo 2 Converte uma ´arvore DOM para a representa¸c˜ao de sequˆencia de tag path
Input: node - um n´o da ´arvore DOM, inicialmente a raiz da ´arvore Input: tp - o tag path anterior, inicialmente vazio
Input: T P S - a T P S de uma ´arvore DOM, inicialmente vazia Output: a T P S de uma ´arvore DOM armazenada em T P S
1: procedure convertToSeq(node,tp,TPS by ref.) 2: tp ← concat(tp,“/”, node.tag, node.style)
3: if tp 3 tagP athM ap then
4: tagP athM ap ← tagP athM ap + {tp}
5: tagP athM ap[tp].code ← tagP athM ap.size 6: end if
7: T P S ← concat(T P S, tagP athM ap[tp].code);
8: for each child of node do
9: convertT oSeq(child, tp, T P S)
10: end for
11: end procedure
chamada recursiva anterior). Na Linha 2, o tag path anterior ´e conca- tenado com a tag atual e com suas defini¸c˜oes de estilo, com objetivo de distinguir caminhos repetidos com estilos diferentes; na Linha 3, ´e verificado se o tag path atual j´a foi visto antes pelo algoritmo ou n˜ao (tagP athM ap ´e utilizado para este prop´osito) e, se n˜ao, na Linha 4, ele ´
e inserido no conjunto tagP athM ap e um novo c´odigo ´e atribu´ıdo a ele na Linha 5, como mostrado na Defini¸c˜ao 3; na Linha 7, o c´odigo do tag path ´e concatenado ao final da sequˆencia e, finalmente, o procedimento ´
e invocado recursivamente na Linha 9 para cara filho de node.
3.4.3 Algoritmo de searchRegion()
Este ´e o algoritmo central, j´a que ´e respons´avel por encontrar a regi˜ao principal e, para facilitar seu entendimento, foi inclu´ıda uma ilustra¸c˜ao do seu funcionamento (a Figura 4). Ela apresenta uma ilus- tra¸c˜ao da execu¸c˜ao do algoritmo excluindo o procedimento de filtragem dos s´ımbolos com baixas frequˆencias para maior clareza, pois a inten¸c˜ao ´
e passar a id´eia principal. Na Figura 4 est˜ao representadas as v´arias itera¸c˜oes feitas em cima da sequˆencia at´e o ponto em que a regi˜ao prin- cipal ´e localizada. Em cada itera¸c˜ao, o cursor percorre as posi¸c˜oes da sequˆencia e verifica, em cada posi¸c˜ao, se n˜ao h´a intersec¸c˜ao entre os
44
alfabetos das subsequˆencias “a” e “b” e, neste caso, inicia uma nova itera¸c˜ao em cima da maior subsequˆencia resultante, at´e que esta n˜ao possa mais ser subdividida, situa¸c˜ao em que a regi˜ao principal foi lo- calizada. Uma descri¸c˜ao detalhada ´e apresentada para a listagem do algoritmo.
45
Algoritmo 3 Busca regi˜oes da TPS com alfabetos diferentes
Entrada: tagP athSequence - a T P S de uma determinada p´agina web Sa´ıda: a regi˜ao principal da T P S, armazenada em tagP athSequence
1: procedure searchRegion(tagP athSequence[1..n] by reference)
2: Σ ← ∅ . alfabeto da sequˆencia
3: t ← 0 . ´ındice dos limiares de frequˆencia
4: for i ← 1..n do
5: sym ← tagP athSequence[i] 6: if sym 3 Σ then 7: Σ ← Σ ∪ {sym} 8: symCount[sym] ← 0 9: end if 10: symCount[sym] ← symCount[sym] + 1 11: end for
12: thresholds ← OrderedSetOf F requencies(symCount) 13: regionF ound ← f alse
14: while not regionF ound do 15: t ← t + 1
16: currΣ ← f ilterAlphabet(Σ, symCount, thresholds[t]) 17: if currΣ.size < 2 then 18: break 19: end if 20: currSymCount ← symCount 21: regionΣ ← ∅ 22: for i ← 1..n do
23: sym ← tagP athSequence[i] 24: if sym ∈ currΣ then
25: regionΣ ← regionΣ ∪ {sym}
26: currSymCount[sym] ← currSymCount[sym] − 1 27: if currSymCount[sym] = 0 then
28: currΣ ← currΣ − {sym}
29: if currΣ ∩ regionΣ = ∅ then
30: if (currΣ 6= ∅) ∧ (n − 2i)/n > 0.20 then
31: regionF ound ← true
32: end if 33: break 34: end if 35: end if 36: end if 37: end for 38: end while
39: if regionF ound then 40: if i < n/2 then
41: tagP athSequence ← tagP athSequence[i + 1..n]
42: else
43: tagP athSequence ← tagP athSequence[1..i]
44: end if
45: searchRegion(tagP athSequence) 46: end if
46
O procedimento searchRegion() no Algoritmo 3 calcula o al- fabeto da TPS e as frequˆencias correspondentes de cada s´ımbolo nas Linhas 4 a 11; na Linha 12, os limiares de frequˆencia, como especificado na Defini¸c˜ao 6, s˜ao calculados; nas Linhas 14 a 38 ´e realizada a busca por uma posi¸c˜ao na sequˆencia onde ´e poss´ıvel dividi-la (i.e. onde existe uma regi˜ao); na Linha 15 os limiares de frequˆencia s˜ao iterados; na Li- nha 16 o alfabeto da TPS, da Defini¸c˜ao 4, ´e filtrado, como descrito na Subse¸c˜ao 3.4.4; na Linha 22 a TPS ´e iterada; na Linha 25 o alfabeto da regi˜ao ´e calculado e; nas Linhas 27 a 35 ´e verificado se existe uma inter- sec¸c˜ao entre os alfabetos das duas partes da TPS (uma intersec¸c˜ao vazia indica que uma poss´ıvel regi˜ao foi encontrada, como na Defini¸c˜ao 7). A regi˜ao encontrada s´o ´e considerada v´alida se for ao menos 20% maior que o restante da sequˆencia. Caso contr´ario, o filtro de frequˆencia ´e ite- rado e a busca prossegue. Este percentual ´e, na verdade, um parˆametro com o prop´osito de evitar relatar uma regi˜ao sob condi¸c˜oes amb´ıguas (nos experimentos foi utilizado o valor de 20%); finalmente nas Linhas 39 a 46 a TPS ´e dividida se uma regi˜ao foi encontrada, chamando o procedimento searchRegion() recursivamente na Linha 45.
3.4.4 Algoritmo de f ilterAlphabet()
Algoritmo 4 Filtra s´ımbolos de baixa frequˆencia no alfabeto Input: Σ - alfabeto a ser filtrado
Input: symCount - conjunto das frequˆencias (F S) dos s´ımbolos de Σ Input: threshold - limiar de frequˆencia
Output: alfabeto filtrado
1: procedure filterAlphabet(Σ, symCount, threshold) 2: f ilteredΣ ← ∅
3: for i ← 1..n do
4: if symCount[Σ[i]] ≥ threshold then
5: f ilteredΣ ← f ilteredΣ ∪ {Σ[i]}
6: end if
7: end for
8: return f ilteredΣ
9: end procedure
O procedimento f ilterAlphabet() no Algoritmo 4 remove do al- fabeto Σ, todo s´ımbolo com frequˆencia inferior a threshold. Nas Linhas 3 to 7 apenas os s´ımbolos com frequˆencia maior ou igual a threshold
47
s˜ao inseridos no conjunto resultante. O resultado de f ilterAlphabet() ´e utilizado no Algoritmo 3, Linha 24, onde apenas os s´ımbolos em currΣ s˜ao considerados durante a busca pela regi˜ao principal.
3.4.5 Algoritmo de pruneDOM T ree()
Algoritmo 5 Poda da ´arvore DOM (n´os que n˜ao pertencem `a sequˆencia)
Input: node - um n´o da ´arvore DOM, inicialmente a raiz Input: sequence - a TPS que deve permanecer na ´arvore DOM Output: ´arvore DOM podada, referenciada em node
1: procedure pruneDOMTree(node by ref.,sequence) 2: for each child of node do
3: if pruneDOM T ree(child, sequence) = true then
4: remove child from node
5: end if
6: end for
7: if node 3 sequence and node.childCount = 0 then
8: return true
9: end if
10: return f alse
11: end procedure
O procedimento pruneDOM T ree() no Algoritmo 5 percorre a ´
arvore DOM em profundidade removendo os n´os que n˜ao pertencem a sequence. Na Linha 3 a ´arvore DOM ´e percorrida; nas Linhas 7 a 9 ´e decidido se o n´o node deve ser removido ou n˜ao.
Um n´o ´e removido da ´arvore apenas se ele n˜ao est´a em sequence e n˜ao tem nenhum filho. Ao evitar a exclus˜ao de n´os internos da ´
arvore que ainda possuem filhos, mesmo quando estes n´os internos n˜ao pertencem `a sequˆencia, ´e poss´ıvel manter a estrutura da ´arvore rema- nescente intacta, evitando afetar, negativamente, a etapa subsequente de extra¸c˜ao estruturada.