☰

XeLaTeX, LuaLaTeX, fontspec, unicode и нормализация

tag-icon • tag-icon xetex luatex unicode
XeLaTeX, LuaLaTeX, fontspec, unicode и нормализация

Меня беспокоит то, как LuaTeX и XeLaTeX нормализуют составные символы Unicode. Я имею в виду NFC / NFD.

См. следующий MWE

\documentclass{article}
\usepackage{fontspec}
\setmainfont{Linux Libertine O}

\begin{document}


ᾳ GREEK SMALL LETTER ALPHA (U+03B1) + COMBINING GREEK YPOGEGRAMMENI (U+0345)

ᾳ GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI (U+1FB3)

\end{document}

С LuaLaTeX я получаю: Пример скомпилирован с помощью LuaLaTeX

Как вы можете видеть, Lua не нормализует символы Unicode, а в Linux Libertine есть ошибка (http://sourceforge.net/p/linuxlibertine/bugs/266/), у меня плохой характер.

С помощью XeLaTeX я получаюПример скомпилирован с помощью XeLaTeX

Как видите, Unicode нормализован.

У меня три вопроса:

  1. Почему XeLaTeX нормализовался (в NFC), хотя я им не пользовался\XeTeXinputnormalization
  2. Изменилась ли эта функция с прошлого. Потому что мой предыдущий, с TeXLive 2012 send был плохой результат (см. статьи, которые я написал в это времяhttp://geekographie.maieul.net/Нормализация-де-карактеров)
  3. Есть ли в LuaTeX такая же опция, как \XeTeXinputnormalizationв XeTeX?

решение1

Я не знаю ответа на первые два вопроса, так как не пользуюсь XeTeX, но хочу предоставить вариант ответа на третий вопрос.

БлагодаряКод АртураМне удалось создать базовый пакет для нормализации юникода в LuaLaTeX. Коду потребовались лишь незначительные изменения для работы с текущим LuaTeX. Я размещу здесь только основной файл Lua, полный проект доступен наGithub как унинормализация.

Пример использования:

\documentclass{article}
\usepackage{fontspec}
\usepackage[czech]{babel}
\setmainfont{Linux Libertine O}
\usepackage[nodes,buffer=false, debug]{uninormalize}
\begin{document}

Some tests:
\begin{itemize}
  \item combined letter ᾳ %GREEK SMALL LETTER ALPHA (U+03B1) + COMBINING GREEK YPOGEGRAMMENI (U+0345)
  \item normal letter ᾳ% GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI (U+1FB3)
\end{itemize}

Some more combined and normal letters: 
óóōōöö

Linux Libertine does support some combined chars: \parbox{4em}{příliš}
\end{document}

(обратите внимание, что правильная версия этого файла находится на Github, в этом примере объединенные буквы были переданы неправильно)

Основная идея пакета заключается в следующем: обработать ввод, и когда найдена буква, за которой следуют комбинированные знаки, она заменяется нормализованной формой NFC. Предоставляются два метода, мой первый подход заключался в использовании обратных вызовов обработки узлов для замены разложенных глифов нормализованными символами. Это имело бы преимущество в том, что можно было бы включать и выключать обработку в любом месте, используя атрибуты узлов. Другой возможной функцией могла бы быть проверка того, содержит ли текущий шрифт нормализованный символ, и использование исходной формы, если его нет. К сожалению, в моих тестах он не работает с некоторыми символами, в частности, составной íнаходится в узлах как dotless i + ´, вместо i + ´, что после нормализации не дает правильный символ, поэтому вместо него используются составные символы. Но это дает вывод с неправильным размещением ударения. Поэтому этот метод нуждается либо в некоторой корректировке, либо он полностью неверен.

Итак, другой метод — использовать process_input_bufferобратный вызов для нормализации входного файла, когда он считывается с диска. Этот метод не позволяет использовать информацию из шрифтов, а также не позволяет отключаться в середине строки, но его значительно проще реализовать, функция обратного вызова может выглядеть так:

function buffer_callback(line) 
  return NFC(line)
end

что действительно приятное открытие после трех дней, потраченных на версию обработки узлов.

Для любопытства вот пакет Lua:

local M = {}
dofile("unicode-names.lua")
dofile('unicode-normalization.lua')
local NFC = unicode.conformance.toNFC
local char = unicode.utf8.char
local gmatch = unicode.utf8.gmatch
local name = unicode.conformance.name
local byte = unicode.utf8.byte
local unidata = characters.data
local length = unicode.utf8.len

M.debug = false

-- for some reason variable number of arguments doesn't work
local function debug_msg(a,b,c,d,e,f,g,h,i)
  if M.debug then
    local t = {a,b,c,d,e,f,g,h,i}
    print("[uninormalize]", unpack(t))
  end
end

local function make_hash (t) 
  local y = {}
  for _,v in ipairs(t) do 
    y[v] = true
  end
  return y
end

local letter_categories = make_hash {"lu","ll","lt","lo","lm"}

local mark_categories = make_hash {"mn","mc","me"}

local function printchars(s)
    local t = {}
    for x in gmatch(s,".") do
        t[#t+1] = name(byte(x))
    end
    debug_msg("characters",table.concat(t,":"))
end

local categories = {}


local function get_category(charcode)
  local charcode = charcode or ""
  if categories[charcode] then
    return categories[charcode] 
  else
    local unidatacode = unidata[charcode] or {}
    local category = unidatacode.category
    categories[charcode] = category
    return category
  end
end

-- get glyph char and category
local function glyph_info(n)
  local char = n.char
  return char, get_category(char)
end

local function get_mark(n)
  if n.id == 37 then
    local character, cat = glyph_info(n)
    if mark_categories[cat] then
      return char(character)
    end
  end
  return false
end

local function make_glyphs(head, nextn,s, lang, font, subtype) 
  local g = function(a) 
    local new_n = node.new(37, subtype)
    new_n.lang = lang
    new_n.font = font
    new_n.char = byte(a)
    return new_n
  end
  if length(s) == 1 then
    return node.insert_before(head, nextn,g(s))
  else
    local t = {}
    local first = true
    for x in gmatch(s,".") do
      debug_msg("multi letter",x)
        head, newn = node.insert_before(head, nextn, g(x))
    end
    return head
  end
end

local function normalize_marks(head, n)
  local lang, font, subtype = n.lang, n.font, n.subtype
  local text = {}
  text[#text+1] = char(n.char)
  local head, nextn = node.remove(head, n)
  --local nextn = n.next
  local info = get_mark(nextn)
  while(info) do
    text[#text+1] = info
    head, nextn = node.remove(head,nextn)
    info = get_mark(nextn)
  end
  local s = NFC(table.concat(text))
  debug_msg("We've got mark: " .. s)
  local new_n = node.new(37, subtype)
  new_n.lang = lang
  new_n.font = font
  new_n.char = byte(s)
  --head, new_n = node.insert_before(head, nextn, new_n)
  -- head, new_n = node.insert_before(head, nextn, make_glyphs(s, lang, font, subtype))
  head, new_n = make_glyphs(head, nextn, s, lang, font, subtype)
  local t = {}
  for x in node.traverse_id(37,head) do
    t[#t+1] = char(x.char)
  end
  debug_msg("Variables ", table.concat(t,":"), table.concat(text,";"), char(byte(s)),length(s))
  return head, nextn
end

local function normalize_glyphs(head, n)
  --local charcode = n.char
  --local category = get_category(charcode)
  local charcode, category = glyph_info(n)
  if letter_categories[category] then 
    local nextn = n.next
    if nextn.id == 37 then
      --local nextchar = nextn.char
      --local nextcat = get_category(nextchar)
      local nextchar, nextcat = glyph_info(nextn)
      if mark_categories[nextcat] then
        return normalize_marks(head,n)
      end
    end
  end
  return head, n.next 
end


function M.nodes(head)
    local t = {}
    local text = false
  local n = head
    -- for n in node.traverse(head) do
  while n do
        if n.id == 37 then
      local charcode = n.char
            debug_msg("unicode name",name(charcode))
            debug_msg("character category",get_category(charcode))
            t[#t+1]= char(charcode)
            text = true
      head, n = normalize_glyphs(head, n)
        else
            if text then
                local s = table.concat(t)
                debug_msg("text chunk",s)
                --printchars(NFC(s))
                debug_msg("----------")
            end
            text = false
            t = {}
      n = n.next
        end
    end
    return head
end

--[[
-- These functions aren't needed when processing buffer. We can call NFC on the whole input line
local unibytes = {}

local function get_charcategory(s)
  local s = s or ""
  local b = unibytes[s] or byte(s) or 0
  unibytes[s] = b
  return get_category(b)
end

local function normalize_charmarks(t,i)
  local c = {t[i]}
  local i = i + 1
  local s = get_charcategory(t[i])
  while mark_categories[s] do
    c[#c+1] = t[i]
    i = i + 1
    s = get_charcategory(t[i])
  end
  return NFC(table.concat(c)), i
end

local function normalize_char(t,i)
  local ch = t[i]
  local c = get_charcategory(ch)
  if letter_categories[c] then
    local nextc = get_charcategory(t[i+1])
    if mark_categories[nextc] then
      return normalize_charmarks(t,i)
    end
  end
  return ch, i+1
end
-- ]]
function M.buffer(line)
  --[[
  local t = {}
  local new_t = {}
  -- we need to make table witl all uni chars on the line
  for x in gmatch(line,".") do
    t[#t+1] = x
  end
  local i = 1
  -- normalize next char
  local c, i = normalize_char(t, i)
  new_t[#new_t+1] = c
  while t[i] do
    c, i = normalize_char(t,i)
    -- local  c = t[i]
    -- i =  i + 1
    new_t[#new_t+1] = c
  end
  return table.concat(new_t)
  --]]
  return NFC(line)
end


return M

а теперь пришло время для фотографий.

без нормализации:

введите описание изображения здесь

вы можете видеть, что составной греческий символ неверен, другие комбинации поддерживаются Linux Libertine

с нормализацией узлов:

введите описание изображения здесь

Греческие буквы верны, но íпервая часть přílišневерна. Это та проблема, о которой я говорил.

а теперь нормализация буфера:

введите описание изображения здесь

теперь все в порядке

Связанный контент