# Segmentação do texto fonte

## Índice

- 1. Introdução à segmentação
- 2. Segmentação de sentenças
  - 2.1. Sobre as regras
  - 2.2. Definição das regras
    - 2.2.1. Conjunto de regras
    - 2.2.2. Exemplos simples
  - 2.3. Expressões regulares para usar nas regras de segmentação
    - 2.3.1. Resumo de elaborações de expressões regulares

## Introdução à segmentação

As ferramentas da memória de tradução trabalham com unidades de texto chamadas segmentos. Existem várias maneiras de segmentar um texto.

O OmegaT analisa primeiro o texto pela segmentação de nível de estrutura Durante este processo somente a estrutura do arquivo fonte é usada para produzir segmentos. Por exemplo, os arquivos podem ser segmentados nas quebras de linha, nas linhas vazias ou não serem segmentados no nível de estrutura. Os arquivos com formatação (documentos OpenOffice.org, OpenDocument, XHTML e HTML) são segmentados nas tags de nível de bloco (ou seja, parágrafos).

Atributos de objeto traduzíveis (em arquivos XHTML ou HTML) são também extraídos para segmentos separados.

OmegaT também pode segmentar por sentenças. A segmentação de sentenças ocorre após a segmentação de nível de estrutura. Os segmentos criados durante os dois processos não podem ser modificados (divididos ou combinados) durante a tradução. Esta é uma limitação do OmegaT que nós reconhecemos.

Se você não estiver contente com a segmentação, terá que modificar o arquivo externamente e/ou modificar as regras de segmentação. Depois disso, terá que recarregar o projeto para que suas modificações sejam consideradas pelo programa.

## Segmentação de sentenças

Após o OmegaT segmentar o arquivo fonte em unidades lógicas -- os arquivos geralmente formatados em parágrafos -- ele segmentará esses parágrafos em sentenças, caso você não tenha desativado a opção de segmentação de sentença. De modo geral, o OmegaT segmenta os blocos lógicos do arquivo fonte conforme o que você determinar. Entretanto, o ajuste predefinido do OmegaT é segmentar em frases, o que chamaremos de segmentação de sentença.

A Segmentação de Sentença foi elaborada considerando o padrão SRX (Segmentation Rules eXchange)</a>, ou seja, Troca de Regras de Segmentação, embora no momento o OmegaT não seja compatível com todos os recursos SRX, nem pode importar/exportar as regras definidas no formato SRX. Porém, se você sabe como o SRX funciona, já sabe como o OmegaT funciona, pois eles são mais ou menos o mesmo.

### Sobre as regras

Existem dois tipos possíveis de regras

- As regras de quebra dividem o texto em segmentos.
- As regras de exceção especificam a parte do texto que não deve ser separada das outras.

Exemplo de regra de quebra: "Isto fazia sentido? Eu não tinha certeza." pode ser segmentada em duas sentenças depois do "`?`". Deve haver uma regra de quebra para o "`?`".

Exemplo de regra de exceção: "Quem tem medo da Sra. Woolf?" não pode ser segmentada após o "`.`". Deve haver uma regra de exceção para "`Sra.`".

As regras de quebra predefinidas devem ser suficientes para a maioria dos idiomas europeus e japonês, mas recomendamos definir mais regras de exceção para o idioma que você traduz, pois é impossível predefinir todas as exceções possíveis para todos os idiomas possíveis.

### Definição das regras

Para definir as regras, selecione Opções > Segmentação... no menu principal. Observe que se você modificar as opções de segmentação quando um projeto estiver aberto, terá que recarregar o projeto para que as modificações sejam efetivadas.

#### Conjunto de regras

Todos os conjuntos de regras de segmentação com um padrão de idioma correspondente são aplicados na ordem de prioridade estabelecida, portanto as regras para um idioma específico devem ter maior prioridade do que aquelas predefinidas.

Por exemplo, as regras para francês canadense (FR-CA) devem ter prioridade às regras para o francês (FR.*), e a outros idiomas definidos como padrão (.*). Assim, ao traduzir para o francês canadense, seu projeto usará as regras definidas para este idioma, depois as regras para o francês e as regras do idioma padrão, seguindo a ordem correta.

Para criar um conjunto vazio de regras, clique em Adicionar na metade superior da caixa de diálogo. Será exibida uma linha vazia na parte inferior de uma tabela. Mude o nome do conjunto de regras e o padrão do idioma. A sintaxe do padrão do idioma se ajusta à sintaxe de expressões regulares. Veja acima a seção Resumo de elaborações de expressões regulares.

Se o seu conjunto de regras processa um par de idioma-país, recomendamos que o coloque no topo da lista usando o botão Mover para cima.

Para editar um conjunto de regras, basta clicar nele na tabela; as regras aparecerão na parte inferior da janela.

A caixa de seleção 'Quebra/exceção' determina se é uma regra de quebra (caixa selecionada) ou uma regra de exceção (caixa não selecionada). Duas expressões regulares Antes e Depois especificam o que deve vir antes e depois de uma posição, de forma a indicar se é uma regra de exceção ou uma regra de quebra.

O processo de segmentação pode ser simplificado conforme segue. Imagine um cursor movendo-se no espaço logo após o primeiro caractere até antes do último caractere do texto do segmento. Para cada posição do cursor, consideramos cada regra em uma determinada ordem e tentamos aplicar ao padrão Antes para todo o texto que está à esquerda do cursor e o padrão Depois para o texto que está à direita de forma que encostem no cursor.

Para as regras que funcionam, se forem de exceção nada faremos senão parar de examinar mais regras; se forem regras de quebra, o texto à esquerda será considerado um segmento separado, isto válido para qualquer posição de cursor no texto.

#### Exemplos simples

Objetivo: definir uma segmentação após um ponto ('`.`') e antes de um espaço
  Antes: `\.` Depois: `\s`
  Observação: "`\.`" significa o caractere "`.`"
  "`\s`" significa qualquer caractere de espaçamento em branco
Objetivo: não segmentar após "`Mr.<c/code>"`
  Antes: `Mr\.` Depois: `\s`
  Observação: não esqueça de deixar a caixa de seleção desmarcada
Meta: definir uma segmentação após "。" (ponto usado no japonês)
  Antes: 。 Depois: (vazio)
  Observação: você pode deixar um campo vazio

### Expressões regulares para usar nas regras de segmentação

As próprias regras de segmentação são representadas com o uso de expressões regulares. Isto permite o máximo em flexibilidade na hora de definir as regras e estar de conformidade com o SRX.

#### Resumo de elaborações de expressões regulares

Essas não são as únicas elaborações que podem ser usadas nas regras de segmentação do OmegaT; são apenas as mais usadas. O OmegaT é compatível com todos os recursos de expressões regulares, conforme descrito no padrão SRX.

Elaborar | Correspondências
--- | ---
Flags
`(?i)` | Ativa correspondências que ignoram maiúsculas e minúsculas (o padrão predefinido faz a distinção entre maiúsculas e minúsculas).
Caracteres
x | O caractere x, exceto o seguinte...
`\u` hhhh | O caractere com valor hexadecimal `0x` hhhh
`\t` | O caractere de tabulação (`'\u0009'`)
`\n` | O caractere de nova linha (alimentação de linha) (`'\u000A'`)
`\r` | O caractere de retornar ao início da linha (`'\u000D'`)
Escapar
`\` | Nada, mas escapa o caractere seguinte. Isto é necessário se você quiser inserir quaisquer metacaracteres `!$()*+.<>?[\]^{|}` para corresponder a eles mesmos.
`\\` | Por exemplo, este é um caractere de barra invertida
`\Q` | Nada, mas escapa todos os caracteres até `\E`
`\E` | Nada, mas finaliza o escape iniciado pelo `\Q`
Classes de caracteres
`[abc]` | `a`, `b`, ou `c` (classe simples)
`[^abc]` | Qualquer caractere exceto `a`, `b`, ou `c` (negação)
`[a-zA-Z]` | `a` até `z` ou `A` até `Z`, inclusive (intervalo)
Classes de caracteres predefinidas
`.` | Qualquer caractere (exceto para terminadores de linha)
`\d` | Um dígito: `[0-9]`
`\D` | Um caractere que não seja dígito: `[^0-9]`
`\s` | Um caractere de espaçamento: `[ \t\n\x0B\f\r]`
`\S` | Um caractere que não seja de espaçamento: `[^\s]`
`\w` | Um caractere de palavra: `[a-zA-Z_0-9]`
`\W` | Um caractere que não seja de palavra: `[^\w]`
Correspondentes de limite (borda)
`^` | O início de uma linha
`$` | O final de uma linha
`\b` | Limite de uma palavra
`\B` | Limite que não seja de palavra
Quantificadores vorazes (gulosos ou possessivos)
Eles farão o maior número de correspondências possíveis. Por exemplo, `a+` corresponderá a `aaa` em `aaabbb`
X`?` | X, uma ou nenhuma
X`*` | X, zero ou mais vezes
X`+` | X, uma ou mais vezes
Quantificadores relutantes (não-vorazes)
Eles farão o menor número possível de correspondências. Por exemplo, `a+?` corresponderá o primeiro `a` em `aaabbb`
X`??` | X, uma ou nenhuma
X`*?` | X, zero ou mais vezes
X`+?` | X, uma ou mais vezes
Operadores lógicos
XY | X seguido por Y
X`|`Y | Ou X ou Y
`(`XY`)` | XY como um grupo único

Avisos legais