1709 lines
54 KiB
PHP
1709 lines
54 KiB
PHP
<?php
|
|
|
|
/**
|
|
* Detects the language of a given piece of text.
|
|
*
|
|
* Attempts to detect the language of a sample of text by correlating ranked
|
|
* 3-gram frequencies to a table of 3-gram frequencies of known languages.
|
|
*
|
|
* Implements a version of a technique originally proposed by Cavnar & Trenkle
|
|
* (1994): "N-Gram-Based Text Categorization"
|
|
*
|
|
* PHP version 5
|
|
*
|
|
* @category Text
|
|
* @package Text_LanguageDetect
|
|
* @author Nicholas Pisarro <infinityminusnine+pear@gmail.com>
|
|
* @copyright 2005-2006 Nicholas Pisarro
|
|
* @license http://www.debian.org/misc/bsd.license BSD
|
|
* @version SVN: $Id: LanguageDetect.php 322353 2012-01-16 08:41:43Z cweiske $
|
|
* @link http://pear.php.net/package/Text_LanguageDetect/
|
|
* @link http://langdetect.blogspot.com/
|
|
*/
|
|
|
|
require_once 'Text/LanguageDetect/Exception.php';
|
|
require_once 'Text/LanguageDetect/Parser.php';
|
|
require_once 'Text/LanguageDetect/ISO639.php';
|
|
|
|
/**
|
|
* Language detection class
|
|
*
|
|
* Requires the langauge model database (lang.dat) that should have
|
|
* accompanied this class definition in order to be instantiated.
|
|
*
|
|
* Example usage:
|
|
*
|
|
* <code>
|
|
* require_once 'Text/LanguageDetect.php';
|
|
*
|
|
* $l = new Text_LanguageDetect;
|
|
*
|
|
* $stdin = fopen('php://stdin', 'r');
|
|
*
|
|
* echo "Supported languages:\n";
|
|
*
|
|
* try {
|
|
* $langs = $l->getLanguages();
|
|
* } catch (Text_LanguageDetect_Exception $e) {
|
|
* die($e->getMessage());
|
|
* }
|
|
*
|
|
* sort($langs);
|
|
* echo join(', ', $langs);
|
|
*
|
|
* while ($line = fgets($stdin)) {
|
|
* print_r($l->detect($line, 4));
|
|
* }
|
|
* </code>
|
|
*
|
|
* @category Text
|
|
* @package Text_LanguageDetect
|
|
* @author Nicholas Pisarro <infinityminusnine+pear@gmail.com>
|
|
* @copyright 2005 Nicholas Pisarro
|
|
* @license http://www.debian.org/misc/bsd.license BSD
|
|
* @version Release: @package_version@
|
|
* @link http://pear.php.net/package/Text_LanguageDetect/
|
|
* @todo allow users to generate their own language models
|
|
*/
|
|
class Text_LanguageDetect
|
|
{
|
|
/**
|
|
* The filename that stores the trigram data for the detector
|
|
*
|
|
* If this value starts with a slash (/) or a dot (.) the value of
|
|
* $this->_data_dir will be ignored
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $_db_filename = 'lang.dat';
|
|
|
|
/**
|
|
* The filename that stores the unicode block definitions
|
|
*
|
|
* If this value starts with a slash (/) or a dot (.) the value of
|
|
* $this->_data_dir will be ignored
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $_unicode_db_filename = 'unicode_blocks.dat';
|
|
|
|
/**
|
|
* The data directory
|
|
*
|
|
* Should be set by PEAR installer
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $_data_dir = '@data_dir@';
|
|
|
|
/**
|
|
* The trigram data for comparison
|
|
*
|
|
* Will be loaded on start from $this->_db_filename
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
var $_lang_db = array();
|
|
|
|
/**
|
|
* stores the map of the trigram data to unicode characters
|
|
*
|
|
* @access private
|
|
* @var array
|
|
*/
|
|
var $_unicode_map;
|
|
|
|
/**
|
|
* The size of the trigram data arrays
|
|
*
|
|
* @var int
|
|
* @access private
|
|
*/
|
|
var $_threshold = 300;
|
|
|
|
/**
|
|
* the maximum possible score.
|
|
*
|
|
* needed for score normalization. Different depending on the
|
|
* perl compatibility setting
|
|
*
|
|
* @access private
|
|
* @var int
|
|
* @see setPerlCompatible()
|
|
*/
|
|
var $_max_score = 0;
|
|
|
|
/**
|
|
* Whether or not to simulate perl's Language::Guess exactly
|
|
*
|
|
* @access private
|
|
* @var bool
|
|
* @see setPerlCompatible()
|
|
*/
|
|
var $_perl_compatible = false;
|
|
|
|
/**
|
|
* Whether to use the unicode block detection to speed up processing
|
|
*
|
|
* @access private
|
|
* @var bool
|
|
*/
|
|
var $_use_unicode_narrowing = true;
|
|
|
|
/**
|
|
* stores the result of the clustering operation
|
|
*
|
|
* @access private
|
|
* @var array
|
|
* @see clusterLanguages()
|
|
*/
|
|
var $_clusters;
|
|
|
|
/**
|
|
* Which type of "language names" are accepted and returned:
|
|
*
|
|
* 0 - language name ("english")
|
|
* 2 - 2-letter ISO 639-1 code ("en")
|
|
* 3 - 3-letter ISO 639-2 code ("eng")
|
|
*/
|
|
var $_name_mode = 0;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* Will attempt to load the language database. If it fails, you will get
|
|
* an exception.
|
|
*/
|
|
function __construct()
|
|
{
|
|
$data = $this->_readdb($this->_db_filename);
|
|
$this->_checkTrigram($data['trigram']);
|
|
$this->_lang_db = $data['trigram'];
|
|
|
|
if (isset($data['trigram-unicodemap'])) {
|
|
$this->_unicode_map = $data['trigram-unicodemap'];
|
|
}
|
|
|
|
// Not yet implemented:
|
|
if (isset($data['trigram-clusters'])) {
|
|
$this->_clusters = $data['trigram-clusters'];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the path to the location of the database
|
|
*
|
|
* @param string $fname File name to load
|
|
*
|
|
* @return string expected path to the language model database
|
|
* @access private
|
|
*/
|
|
function _get_data_loc($fname)
|
|
{
|
|
if ($fname{0} == '/' || $fname{0} == '.') {
|
|
// if filename starts with a slash, assume it's an absolute pathname
|
|
// and skip whatever is in $this->_data_dir
|
|
return $fname;
|
|
|
|
} elseif ($this->_data_dir != '@' . 'data_dir' . '@') {
|
|
// if the data dir was set by the PEAR installer, use that
|
|
return $this->_data_dir . '/Text_LanguageDetect/' . $fname;
|
|
|
|
} else {
|
|
// assume this was just unpacked somewhere
|
|
// try the local working directory if otherwise
|
|
return __DIR__ . '/../data/' . $fname;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads the language trigram database from filename
|
|
*
|
|
* Trigram datbase should be a serialize()'d array
|
|
*
|
|
* @param string $fname the filename where the data is stored
|
|
*
|
|
* @return array the language model data
|
|
* @throws Text_LanguageDetect_Exception
|
|
* @access private
|
|
*/
|
|
function _readdb($fname)
|
|
{
|
|
// finds the correct data dir
|
|
$fname = $this->_get_data_loc($fname);
|
|
|
|
// input check
|
|
if (!file_exists($fname)) {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Language database does not exist: ' . $fname,
|
|
Text_LanguageDetect_Exception::DB_NOT_FOUND
|
|
);
|
|
} elseif (!is_readable($fname)) {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Language database is not readable: ' . $fname,
|
|
Text_LanguageDetect_Exception::DB_NOT_READABLE
|
|
);
|
|
}
|
|
|
|
return unserialize(file_get_contents($fname));
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks if this object is ready to detect languages
|
|
*
|
|
* @param array $trigram Trigram data from database
|
|
*
|
|
* @return void
|
|
* @access private
|
|
*/
|
|
function _checkTrigram($trigram)
|
|
{
|
|
if (!is_array($trigram)) {
|
|
if (ini_get('magic_quotes_runtime')) {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Error loading database. Try turning magic_quotes_runtime off.',
|
|
Text_LanguageDetect_Exception::MAGIC_QUOTES
|
|
);
|
|
}
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Language database is not an array.',
|
|
Text_LanguageDetect_Exception::DB_NOT_ARRAY
|
|
);
|
|
} elseif (empty($trigram)) {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Language database has no elements.',
|
|
Text_LanguageDetect_Exception::DB_EMPTY
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Omits languages
|
|
*
|
|
* Pass this function the name of or an array of names of
|
|
* languages that you don't want considered
|
|
*
|
|
* If you're only expecting a limited set of languages, this can greatly
|
|
* speed up processing
|
|
*
|
|
* @param mixed $omit_list language name or array of names to omit
|
|
* @param bool $include_only if true will include (rather than
|
|
* exclude) only those in the list
|
|
*
|
|
* @return int number of languages successfully deleted
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
public function omitLanguages($omit_list, $include_only = false)
|
|
{
|
|
$deleted = 0;
|
|
|
|
$omit_list = $this->_convertFromNameMode($omit_list);
|
|
|
|
if (!$include_only) {
|
|
// deleting the given languages
|
|
if (!is_array($omit_list)) {
|
|
$omit_list = strtolower($omit_list); // case desensitize
|
|
if (isset($this->_lang_db[$omit_list])) {
|
|
unset($this->_lang_db[$omit_list]);
|
|
$deleted++;
|
|
}
|
|
} else {
|
|
foreach ($omit_list as $omit_lang) {
|
|
if (isset($this->_lang_db[$omit_lang])) {
|
|
unset($this->_lang_db[$omit_lang]);
|
|
$deleted++;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// deleting all except the given languages
|
|
if (!is_array($omit_list)) {
|
|
$omit_list = array($omit_list);
|
|
}
|
|
|
|
// case desensitize
|
|
foreach ($omit_list as $key => $omit_lang) {
|
|
$omit_list[$key] = strtolower($omit_lang);
|
|
}
|
|
|
|
foreach (array_keys($this->_lang_db) as $lang) {
|
|
if (!in_array($lang, $omit_list)) {
|
|
unset($this->_lang_db[$lang]);
|
|
$deleted++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// reset the cluster cache if the number of languages changes
|
|
// this will then have to be recalculated
|
|
if (isset($this->_clusters) && $deleted > 0) {
|
|
$this->_clusters = null;
|
|
}
|
|
|
|
return $deleted;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the number of languages that this object can detect
|
|
*
|
|
* @access public
|
|
* @return int the number of languages
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
function getLanguageCount()
|
|
{
|
|
return count($this->_lang_db);
|
|
}
|
|
|
|
/**
|
|
* Checks if the language with the given name exists in the database
|
|
*
|
|
* @param mixed $lang Language name or array of language names
|
|
*
|
|
* @return bool true if language model exists
|
|
*/
|
|
public function languageExists($lang)
|
|
{
|
|
$lang = $this->_convertFromNameMode($lang);
|
|
|
|
if (is_string($lang)) {
|
|
return isset($this->_lang_db[strtolower($lang)]);
|
|
|
|
} elseif (is_array($lang)) {
|
|
foreach ($lang as $test_lang) {
|
|
if (!isset($this->_lang_db[strtolower($test_lang)])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
|
|
} else {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Unsupported parameter type passed to languageExists()',
|
|
Text_LanguageDetect_Exception::PARAM_TYPE
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the list of detectable languages
|
|
*
|
|
* @access public
|
|
* @return array the names of the languages known to this object<<<<<<<
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
function getLanguages()
|
|
{
|
|
return $this->_convertToNameMode(
|
|
array_keys($this->_lang_db)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Make this object behave like Language::Guess
|
|
*
|
|
* @param bool $setting false to turn off perl compatibility
|
|
*
|
|
* @return void
|
|
*/
|
|
public function setPerlCompatible($setting = true)
|
|
{
|
|
if (is_bool($setting)) { // input check
|
|
$this->_perl_compatible = $setting;
|
|
|
|
if ($setting == true) {
|
|
$this->_max_score = $this->_threshold;
|
|
} else {
|
|
$this->_max_score = 0;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Sets the way how language names are accepted and returned.
|
|
*
|
|
* @param integer $name_mode One of the following modes:
|
|
* 0 - language name ("english")
|
|
* 2 - 2-letter ISO 639-1 code ("en")
|
|
* 3 - 3-letter ISO 639-2 code ("eng")
|
|
*
|
|
* @return void
|
|
*/
|
|
function setNameMode($name_mode)
|
|
{
|
|
$this->_name_mode = $name_mode;
|
|
}
|
|
|
|
/**
|
|
* Whether to use unicode block ranges in detection
|
|
*
|
|
* Should speed up most detections if turned on (detault is on). In some
|
|
* circumstances it may be slower, such as for large text samples (> 10K)
|
|
* in languages that use latin scripts. In other cases it should speed up
|
|
* detection noticeably.
|
|
*
|
|
* @param bool $setting false to turn off
|
|
*
|
|
* @return void
|
|
*/
|
|
public function useUnicodeBlocks($setting = true)
|
|
{
|
|
if (is_bool($setting)) {
|
|
$this->_use_unicode_narrowing = $setting;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts a piece of text into trigrams
|
|
*
|
|
* @param string $text text to convert
|
|
*
|
|
* @return array array of trigram frequencies
|
|
* @access private
|
|
* @deprecated Superceded by the Text_LanguageDetect_Parser class
|
|
*/
|
|
function _trigram($text)
|
|
{
|
|
$s = new Text_LanguageDetect_Parser($text);
|
|
$s->prepareTrigram();
|
|
$s->prepareUnicode(false);
|
|
$s->setPadStart(!$this->_perl_compatible);
|
|
$s->analyze();
|
|
return $s->getTrigramFreqs();
|
|
}
|
|
|
|
/**
|
|
* Converts a set of trigrams from frequencies to ranks
|
|
*
|
|
* Thresholds (cuts off) the list at $this->_threshold
|
|
*
|
|
* @param array $arr array of trigram
|
|
*
|
|
* @return array ranks of trigrams
|
|
* @access protected
|
|
*/
|
|
function _arr_rank($arr)
|
|
{
|
|
|
|
// sorts alphabetically first as a standard way of breaking rank ties
|
|
$this->_bub_sort($arr);
|
|
|
|
// below might also work, but seemed to introduce errors in testing
|
|
//ksort($arr);
|
|
//asort($arr);
|
|
|
|
$rank = array();
|
|
|
|
$i = 0;
|
|
foreach ($arr as $key => $value) {
|
|
$rank[$key] = $i++;
|
|
|
|
// cut off at a standard threshold
|
|
if ($i >= $this->_threshold) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $rank;
|
|
}
|
|
|
|
/**
|
|
* Sorts an array by value breaking ties alphabetically
|
|
*
|
|
* @param array &$arr the array to sort
|
|
*
|
|
* @return void
|
|
* @access private
|
|
*/
|
|
function _bub_sort(&$arr)
|
|
{
|
|
// should do the same as this perl statement:
|
|
// sort { $trigrams{$b} == $trigrams{$a}
|
|
// ? $a cmp $b : $trigrams{$b} <=> $trigrams{$a} }
|
|
|
|
// needs to sort by both key and value at once
|
|
// using the key to break ties for the value
|
|
|
|
// converts array into an array of arrays of each key and value
|
|
// may be a better way of doing this
|
|
$combined = array();
|
|
|
|
foreach ($arr as $key => $value) {
|
|
$combined[] = array($key, $value);
|
|
}
|
|
|
|
usort($combined, array($this, '_sort_func'));
|
|
|
|
$replacement = array();
|
|
foreach ($combined as $key => $value) {
|
|
list($new_key, $new_value) = $value;
|
|
$replacement[$new_key] = $new_value;
|
|
}
|
|
|
|
$arr = $replacement;
|
|
}
|
|
|
|
/**
|
|
* Sort function used by bubble sort
|
|
*
|
|
* Callback function for usort().
|
|
*
|
|
* @param array $a first param passed by usort()
|
|
* @param array $b second param passed by usort()
|
|
*
|
|
* @return int 1 if $a is greater, -1 if not
|
|
* @see _bub_sort()
|
|
* @access private
|
|
*/
|
|
function _sort_func($a, $b)
|
|
{
|
|
// each is actually a key/value pair, so that it can compare using both
|
|
list($a_key, $a_value) = $a;
|
|
list($b_key, $b_value) = $b;
|
|
|
|
if ($a_value == $b_value) {
|
|
// if the values are the same, break ties using the key
|
|
return strcmp($a_key, $b_key);
|
|
|
|
} else {
|
|
// if not, just sort normally
|
|
if ($a_value > $b_value) {
|
|
return -1;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// 0 should not be possible because keys must be unique
|
|
}
|
|
|
|
/**
|
|
* Calculates a linear rank-order distance statistic between two sets of
|
|
* ranked trigrams
|
|
*
|
|
* Sums the differences in rank for each trigram. If the trigram does not
|
|
* appear in both, consider it a difference of $this->_threshold.
|
|
*
|
|
* This distance measure was proposed by Cavnar & Trenkle (1994). Despite
|
|
* its simplicity it has been shown to be highly accurate for language
|
|
* identification tasks.
|
|
*
|
|
* @param array $arr1 the reference set of trigram ranks
|
|
* @param array $arr2 the target set of trigram ranks
|
|
*
|
|
* @return int the sum of the differences between the ranks of
|
|
* the two trigram sets
|
|
* @access private
|
|
*/
|
|
function _distance($arr1, $arr2)
|
|
{
|
|
$sumdist = 0;
|
|
|
|
foreach ($arr2 as $key => $value) {
|
|
if (isset($arr1[$key])) {
|
|
$distance = abs($value - $arr1[$key]);
|
|
} else {
|
|
// $this->_threshold sets the maximum possible distance value
|
|
// for any one pair of trigrams
|
|
$distance = $this->_threshold;
|
|
}
|
|
$sumdist += $distance;
|
|
}
|
|
|
|
return $sumdist;
|
|
|
|
// todo: there are other distance statistics to try, e.g. relative
|
|
// entropy, but they're probably more costly to compute
|
|
}
|
|
|
|
/**
|
|
* Normalizes the score returned by _distance()
|
|
*
|
|
* Different if perl compatible or not
|
|
*
|
|
* @param int $score the score from _distance()
|
|
* @param int $base_count the number of trigrams being considered
|
|
*
|
|
* @return float the normalized score
|
|
* @see _distance()
|
|
* @access private
|
|
*/
|
|
function _normalize_score($score, $base_count = null)
|
|
{
|
|
if ($base_count === null) {
|
|
$base_count = $this->_threshold;
|
|
}
|
|
|
|
if (!$this->_perl_compatible) {
|
|
return 1 - ($score / $base_count / $this->_threshold);
|
|
} else {
|
|
return floor($score / $base_count);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Detects the closeness of a sample of text to the known languages
|
|
*
|
|
* Calculates the statistical difference between the text and
|
|
* the trigrams for each language, normalizes the score then
|
|
* returns results for all languages in sorted order
|
|
*
|
|
* If perl compatible, the score is 300-0, 0 being most similar.
|
|
* Otherwise, it's 0-1 with 1 being most similar.
|
|
*
|
|
* The $sample text should be at least a few sentences in length;
|
|
* should be ascii-7 or utf8 encoded, if another and the mbstring extension
|
|
* is present it will try to detect and convert. However, experience has
|
|
* shown that mb_detect_encoding() *does not work very well* with at least
|
|
* some types of encoding.
|
|
*
|
|
* @param string $sample a sample of text to compare.
|
|
* @param int $limit if specified, return an array of the most likely
|
|
* $limit languages and their scores.
|
|
*
|
|
* @return mixed sorted array of language scores, blank array if no
|
|
* useable text was found
|
|
* @see _distance()
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
public function detect($sample, $limit = 0)
|
|
{
|
|
// input check
|
|
if (!Text_LanguageDetect_Parser::validateString($sample)) {
|
|
return array();
|
|
}
|
|
|
|
// check char encoding
|
|
// (only if mbstring extension is compiled and PHP > 4.0.6)
|
|
if (function_exists('mb_detect_encoding')
|
|
&& function_exists('mb_convert_encoding')
|
|
) {
|
|
// mb_detect_encoding isn't very reliable, to say the least
|
|
// detection should still work with a sufficient sample
|
|
// of ascii characters
|
|
$encoding = mb_detect_encoding($sample);
|
|
|
|
// mb_detect_encoding() will return FALSE if detection fails
|
|
// don't attempt conversion if that's the case
|
|
if ($encoding != 'ASCII' && $encoding != 'UTF-8'
|
|
&& $encoding !== false
|
|
) {
|
|
// verify the encoding exists in mb_list_encodings
|
|
if (in_array($encoding, mb_list_encodings())) {
|
|
$sample = mb_convert_encoding($sample, 'UTF-8', $encoding);
|
|
}
|
|
}
|
|
}
|
|
|
|
$sample_obj = new Text_LanguageDetect_Parser($sample);
|
|
$sample_obj->prepareTrigram();
|
|
if ($this->_use_unicode_narrowing) {
|
|
$sample_obj->prepareUnicode();
|
|
}
|
|
$sample_obj->setPadStart(!$this->_perl_compatible);
|
|
$sample_obj->analyze();
|
|
|
|
$trigram_freqs =& $sample_obj->getTrigramRanks();
|
|
$trigram_count = count($trigram_freqs);
|
|
|
|
if ($trigram_count == 0) {
|
|
return array();
|
|
}
|
|
|
|
$scores = array();
|
|
|
|
// use unicode block detection to narrow down the possibilities
|
|
if ($this->_use_unicode_narrowing) {
|
|
$blocks =& $sample_obj->getUnicodeBlocks();
|
|
|
|
if (is_array($blocks)) {
|
|
$present_blocks = array_keys($blocks);
|
|
} else {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Error during block detection',
|
|
Text_LanguageDetect_Exception::BLOCK_DETECTION
|
|
);
|
|
}
|
|
|
|
$possible_langs = array();
|
|
|
|
foreach ($present_blocks as $blockname) {
|
|
if (isset($this->_unicode_map[$blockname])) {
|
|
|
|
$possible_langs = array_merge(
|
|
$possible_langs,
|
|
array_keys($this->_unicode_map[$blockname])
|
|
);
|
|
|
|
// todo: faster way to do this?
|
|
}
|
|
}
|
|
|
|
// could also try an intersect operation rather than a union
|
|
// in other words, choose languages whose trigrams contain
|
|
// ALL of the unicode blocks found in this sample
|
|
// would improve speed but would be completely thrown off by an
|
|
// unexpected character, like an umlaut appearing in english text
|
|
|
|
$possible_langs = array_intersect(
|
|
array_keys($this->_lang_db),
|
|
array_unique($possible_langs)
|
|
);
|
|
|
|
// needs to intersect it with the keys of _lang_db in case
|
|
// languages have been omitted
|
|
|
|
} else {
|
|
// or just try 'em all
|
|
$possible_langs = array_keys($this->_lang_db);
|
|
}
|
|
|
|
|
|
foreach ($possible_langs as $lang) {
|
|
$scores[$lang] = $this->_normalize_score(
|
|
$this->_distance($this->_lang_db[$lang], $trigram_freqs),
|
|
$trigram_count
|
|
);
|
|
}
|
|
|
|
unset($sample_obj);
|
|
|
|
if ($this->_perl_compatible) {
|
|
asort($scores);
|
|
} else {
|
|
arsort($scores);
|
|
}
|
|
|
|
// todo: drop languages with a score of $this->_max_score?
|
|
|
|
// limit the number of returned scores
|
|
if ($limit && is_numeric($limit)) {
|
|
$limited_scores = array();
|
|
|
|
$i = 0;
|
|
foreach ($scores as $key => $value) {
|
|
if ($i++ >= $limit) {
|
|
break;
|
|
}
|
|
|
|
$limited_scores[$key] = $value;
|
|
}
|
|
|
|
return $this->_convertToNameMode($limited_scores, true);
|
|
} else {
|
|
return $this->_convertToNameMode($scores, true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns only the most similar language to the text sample
|
|
*
|
|
* Calls $this->detect() and returns only the top result
|
|
*
|
|
* @param string $sample text to detect the language of
|
|
*
|
|
* @return string the name of the most likely language
|
|
* or null if no language is similar
|
|
* @see detect()
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
public function detectSimple($sample)
|
|
{
|
|
$scores = $this->detect($sample, 1);
|
|
|
|
// if top language has the maximum possible score,
|
|
// then the top score will have been picked at random
|
|
if (!is_array($scores) || empty($scores)
|
|
|| current($scores) == $this->_max_score
|
|
) {
|
|
return null;
|
|
} else {
|
|
return key($scores);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing the most similar language and a confidence
|
|
* rating
|
|
*
|
|
* Confidence is a simple measure calculated from the similarity score
|
|
* minus the similarity score from the next most similar language
|
|
* divided by the highest possible score. Languages that have closely
|
|
* related cousins (e.g. Norwegian and Danish) should generally have lower
|
|
* confidence scores.
|
|
*
|
|
* The similarity score answers the question "How likely is the text the
|
|
* returned language regardless of the other languages considered?" The
|
|
* confidence score is one way of answering the question "how likely is the
|
|
* text the detected language relative to the rest of the language model
|
|
* set?"
|
|
*
|
|
* To see how similar languages are a priori, see languageSimilarity()
|
|
*
|
|
* @param string $sample text for which language will be detected
|
|
*
|
|
* @return array most similar language, score and confidence rating
|
|
* or null if no language is similar
|
|
* @see detect()
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
public function detectConfidence($sample)
|
|
{
|
|
$scores = $this->detect($sample, 2);
|
|
|
|
// if most similar language has the max score, it
|
|
// will have been picked at random
|
|
if (!is_array($scores) || empty($scores)
|
|
|| current($scores) == $this->_max_score
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
$arr['language'] = key($scores);
|
|
$arr['similarity'] = current($scores);
|
|
if (next($scores) !== false) { // if false then no next element
|
|
// the goal is to return a higher value if the distance between
|
|
// the similarity of the first score and the second score is high
|
|
|
|
if ($this->_perl_compatible) {
|
|
$arr['confidence'] = (current($scores) - $arr['similarity'])
|
|
/ $this->_max_score;
|
|
|
|
} else {
|
|
$arr['confidence'] = $arr['similarity'] - current($scores);
|
|
|
|
}
|
|
|
|
} else {
|
|
$arr['confidence'] = null;
|
|
}
|
|
|
|
return $arr;
|
|
}
|
|
|
|
/**
|
|
* Returns the distribution of unicode blocks in a given utf8 string
|
|
*
|
|
* For the block name of a single char, use unicodeBlockName()
|
|
*
|
|
* @param string $str input string. Must be ascii or utf8
|
|
* @param bool $skip_symbols if true, skip ascii digits, symbols and
|
|
* non-printing characters. Includes spaces,
|
|
* newlines and common punctutation characters.
|
|
*
|
|
* @return array
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
public function detectUnicodeBlocks($str, $skip_symbols)
|
|
{
|
|
$skip_symbols = (bool)$skip_symbols;
|
|
$str = (string)$str;
|
|
|
|
$sample_obj = new Text_LanguageDetect_Parser($str);
|
|
$sample_obj->prepareUnicode();
|
|
$sample_obj->prepareTrigram(false);
|
|
$sample_obj->setUnicodeSkipSymbols($skip_symbols);
|
|
$sample_obj->analyze();
|
|
$blocks = $sample_obj->getUnicodeBlocks();
|
|
unset($sample_obj);
|
|
return $blocks;
|
|
}
|
|
|
|
/**
|
|
* Returns the block name for a given unicode value
|
|
*
|
|
* If passed a string, will assume it is being passed a UTF8-formatted
|
|
* character and will automatically convert. Otherwise it will assume it
|
|
* is being passed a numeric unicode value.
|
|
*
|
|
* Make sure input is of the correct type!
|
|
*
|
|
* @param mixed $unicode unicode value or utf8 char
|
|
*
|
|
* @return mixed the block name string or false if not found
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
public function unicodeBlockName($unicode)
|
|
{
|
|
if (is_string($unicode)) {
|
|
// assume it is being passed a utf8 char, so convert it
|
|
if (self::utf8strlen($unicode) > 1) {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Pass a single char only to this method',
|
|
Text_LanguageDetect_Exception::PARAM_TYPE
|
|
);
|
|
}
|
|
$unicode = $this->_utf8char2unicode($unicode);
|
|
|
|
} elseif (!is_int($unicode)) {
|
|
throw new Text_LanguageDetect_Exception(
|
|
'Input must be of type string or int.',
|
|
Text_LanguageDetect_Exception::PARAM_TYPE
|
|
);
|
|
}
|
|
|
|
$blocks = $this->_read_unicode_block_db();
|
|
|
|
$result = $this->_unicode_block_name($unicode, $blocks);
|
|
|
|
if ($result == -1) {
|
|
return false;
|
|
} else {
|
|
return $result[2];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Searches the unicode block database
|
|
*
|
|
* Returns the block name for a given unicode value. unicodeBlockName() is
|
|
* the public interface for this function, which does input checks which
|
|
* this function omits for speed.
|
|
*
|
|
* @param int $unicode the unicode value
|
|
* @param array $blocks the block database
|
|
* @param int $block_count the number of defined blocks in the database
|
|
*
|
|
* @return mixed Block name, -1 if it failed
|
|
* @see unicodeBlockName()
|
|
* @access protected
|
|
*/
|
|
function _unicode_block_name($unicode, $blocks, $block_count = -1)
|
|
{
|
|
// for a reference, see
|
|
// http://www.unicode.org/Public/UNIDATA/Blocks.txt
|
|
|
|
// assume that ascii characters are the most common
|
|
// so try it first for efficiency
|
|
if ($unicode <= $blocks[0][1]) {
|
|
return $blocks[0];
|
|
}
|
|
|
|
// the optional $block_count param is for efficiency
|
|
// so we this function doesn't have to run count() every time
|
|
if ($block_count != -1) {
|
|
$high = $block_count - 1;
|
|
} else {
|
|
$high = count($blocks) - 1;
|
|
}
|
|
|
|
$low = 1; // start with 1 because ascii was 0
|
|
|
|
// your average binary search algorithm
|
|
while ($low <= $high) {
|
|
$mid = floor(($low + $high) / 2);
|
|
|
|
if ($unicode < $blocks[$mid][0]) {
|
|
// if it's lower than the lower bound
|
|
$high = $mid - 1;
|
|
|
|
} elseif ($unicode > $blocks[$mid][1]) {
|
|
// if it's higher than the upper bound
|
|
$low = $mid + 1;
|
|
|
|
} else {
|
|
// found it
|
|
return $blocks[$mid];
|
|
}
|
|
}
|
|
|
|
// failed to find the block
|
|
return -1;
|
|
|
|
// todo: differentiate when it's out of range or when it falls
|
|
// into an unassigned range?
|
|
}
|
|
|
|
/**
|
|
* Brings up the unicode block database
|
|
*
|
|
* @return array the database of unicode block definitions
|
|
* @throws Text_LanguageDetect_Exception
|
|
* @access protected
|
|
*/
|
|
function _read_unicode_block_db()
|
|
{
|
|
// since the unicode definitions are always going to be the same,
|
|
// might as well share the memory for the db with all other instances
|
|
// of this class
|
|
static $data;
|
|
|
|
if (!isset($data)) {
|
|
$data = $this->_readdb($this->_unicode_db_filename);
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Calculate the similarities between the language models
|
|
*
|
|
* Use this function to see how similar languages are to each other.
|
|
*
|
|
* If passed 2 language names, will return just those languages compared.
|
|
* If passed 1 language name, will return that language compared to
|
|
* all others.
|
|
* If passed none, will return an array of every language model compared
|
|
* to every other one.
|
|
*
|
|
* @param string $lang1 the name of the first language to be compared
|
|
* @param string $lang2 the name of the second language to be compared
|
|
*
|
|
* @return array scores of every language compared
|
|
* or the score of just the provided languages
|
|
* or null if one of the supplied languages does not exist
|
|
* @throws Text_LanguageDetect_Exception
|
|
*/
|
|
public function languageSimilarity($lang1 = null, $lang2 = null)
|
|
{
|
|
$lang1 = $this->_convertFromNameMode($lang1);
|
|
$lang2 = $this->_convertFromNameMode($lang2);
|
|
if ($lang1 != null) {
|
|
$lang1 = strtolower($lang1);
|
|
|
|
// check if language model exists
|
|
if (!isset($this->_lang_db[$lang1])) {
|
|
return null;
|
|
}
|
|
|
|
if ($lang2 != null) {
|
|
if (!isset($this->_lang_db[$lang2])) {
|
|
// check if language model exists
|
|
return null;
|
|
}
|
|
|
|
$lang2 = strtolower($lang2);
|
|
|
|
// compare just these two languages
|
|
return $this->_normalize_score(
|
|
$this->_distance(
|
|
$this->_lang_db[$lang1],
|
|
$this->_lang_db[$lang2]
|
|
)
|
|
);
|
|
|
|
} else {
|
|
// compare just $lang1 to all languages
|
|
$return_arr = array();
|
|
foreach ($this->_lang_db as $key => $value) {
|
|
if ($key != $lang1) {
|
|
// don't compare a language to itself
|
|
$return_arr[$key] = $this->_normalize_score(
|
|
$this->_distance($this->_lang_db[$lang1], $value)
|
|
);
|
|
}
|
|
}
|
|
asort($return_arr);
|
|
|
|
return $return_arr;
|
|
}
|
|
|
|
|
|
} else {
|
|
// compare all languages to each other
|
|
$return_arr = array();
|
|
foreach (array_keys($this->_lang_db) as $lang1) {
|
|
foreach (array_keys($this->_lang_db) as $lang2) {
|
|
// skip comparing languages to themselves
|
|
if ($lang1 != $lang2) {
|
|
|
|
if (isset($return_arr[$lang2][$lang1])) {
|
|
// don't re-calculate what's already been done
|
|
$return_arr[$lang1][$lang2]
|
|
= $return_arr[$lang2][$lang1];
|
|
|
|
} else {
|
|
// calculate
|
|
$return_arr[$lang1][$lang2]
|
|
= $this->_normalize_score(
|
|
$this->_distance(
|
|
$this->_lang_db[$lang1],
|
|
$this->_lang_db[$lang2]
|
|
)
|
|
);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $return_arr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cluster known languages according to languageSimilarity()
|
|
*
|
|
* WARNING: this method is EXPERIMENTAL. It is not recommended for common
|
|
* use, and it may disappear or its functionality may change in future
|
|
* releases without notice.
|
|
*
|
|
* Uses a nearest neighbor technique to generate the maximum possible
|
|
* number of dendograms from the similarity data.
|
|
*
|
|
* @access public
|
|
* @return array language cluster data
|
|
* @throws Text_LanguageDetect_Exception
|
|
* @see languageSimilarity()
|
|
* @deprecated this function will eventually be removed and placed into
|
|
* the model generation class
|
|
*/
|
|
function clusterLanguages()
|
|
{
|
|
// todo: set the maximum number of clusters
|
|
// return cached result, if any
|
|
if (isset($this->_clusters)) {
|
|
return $this->_clusters;
|
|
}
|
|
|
|
$langs = array_keys($this->_lang_db);
|
|
|
|
$arr = $this->languageSimilarity();
|
|
|
|
sort($langs);
|
|
|
|
foreach ($langs as $lang) {
|
|
if (!isset($this->_lang_db[$lang])) {
|
|
throw new Text_LanguageDetect_Exception(
|
|
"missing $lang!",
|
|
Text_LanguageDetect_Exception::UNKNOWN_LANGUAGE
|
|
);
|
|
}
|
|
}
|
|
|
|
// http://www.psychstat.missouristate.edu/multibook/mlt04m.html
|
|
foreach ($langs as $old_key => $lang1) {
|
|
$langs[$lang1] = $lang1;
|
|
unset($langs[$old_key]);
|
|
}
|
|
|
|
$result_data = $really_map = array();
|
|
|
|
$i = 0;
|
|
while (count($langs) > 2 && $i++ < 200) {
|
|
$highest_score = -1;
|
|
$highest_key1 = '';
|
|
$highest_key2 = '';
|
|
foreach ($langs as $lang1) {
|
|
foreach ($langs as $lang2) {
|
|
if ($lang1 != $lang2
|
|
&& $arr[$lang1][$lang2] > $highest_score
|
|
) {
|
|
$highest_score = $arr[$lang1][$lang2];
|
|
$highest_key1 = $lang1;
|
|
$highest_key2 = $lang2;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$highest_key1) {
|
|
// should not ever happen
|
|
throw new Text_LanguageDetect_Exception(
|
|
"no highest key? (step: $i)",
|
|
Text_LanguageDetect_Exception::NO_HIGHEST_KEY
|
|
);
|
|
}
|
|
|
|
if ($highest_score == 0) {
|
|
// languages are perfectly dissimilar
|
|
break;
|
|
}
|
|
|
|
// $highest_key1 and $highest_key2 are most similar
|
|
$sum1 = array_sum($arr[$highest_key1]);
|
|
$sum2 = array_sum($arr[$highest_key2]);
|
|
|
|
// use the score for the one that is most similar to the rest of
|
|
// the field as the score for the group
|
|
// todo: could try averaging or "centroid" method instead
|
|
// seems like that might make more sense
|
|
// actually nearest neighbor may be better for binary searching
|
|
|
|
|
|
// for "Complete Linkage"/"furthest neighbor"
|
|
// sign should be <
|
|
// for "Single Linkage"/"nearest neighbor" method
|
|
// should should be >
|
|
// results seem to be pretty much the same with either method
|
|
|
|
// figure out which to delete and which to replace
|
|
if ($sum1 > $sum2) {
|
|
$replaceme = $highest_key1;
|
|
$deleteme = $highest_key2;
|
|
} else {
|
|
$replaceme = $highest_key2;
|
|
$deleteme = $highest_key1;
|
|
}
|
|
|
|
$newkey = $replaceme . ':' . $deleteme;
|
|
|
|
// $replaceme is most similar to remaining languages
|
|
// replace $replaceme with '$newkey', deleting $deleteme
|
|
|
|
// keep a record of which fork is really which language
|
|
$really_lang = $replaceme;
|
|
while (isset($really_map[$really_lang])) {
|
|
$really_lang = $really_map[$really_lang];
|
|
}
|
|
$really_map[$newkey] = $really_lang;
|
|
|
|
|
|
// replace the best fitting key, delete the other
|
|
foreach ($arr as $key1 => $arr2) {
|
|
foreach ($arr2 as $key2 => $value2) {
|
|
if ($key2 == $replaceme) {
|
|
$arr[$key1][$newkey] = $arr[$key1][$key2];
|
|
unset($arr[$key1][$key2]);
|
|
// replacing $arr[$key1][$key2] with $arr[$key1][$newkey]
|
|
}
|
|
|
|
if ($key1 == $replaceme) {
|
|
$arr[$newkey][$key2] = $arr[$key1][$key2];
|
|
unset($arr[$key1][$key2]);
|
|
// replacing $arr[$key1][$key2] with $arr[$newkey][$key2]
|
|
}
|
|
|
|
if ($key1 == $deleteme || $key2 == $deleteme) {
|
|
// deleting $arr[$key1][$key2]
|
|
unset($arr[$key1][$key2]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
unset($langs[$highest_key1]);
|
|
unset($langs[$highest_key2]);
|
|
$langs[$newkey] = $newkey;
|
|
|
|
|
|
// some of these may be overkill
|
|
$result_data[$newkey] = array(
|
|
'newkey' => $newkey,
|
|
'count' => $i,
|
|
'diff' => abs($sum1 - $sum2),
|
|
'score' => $highest_score,
|
|
'bestfit' => $replaceme,
|
|
'otherfit' => $deleteme,
|
|
'really' => $really_lang,
|
|
);
|
|
}
|
|
|
|
$return_val = array(
|
|
'open_forks' => $langs,
|
|
// the top level of clusters
|
|
// clusters that are mutually exclusive
|
|
// or specified by a specific maximum
|
|
|
|
'fork_data' => $result_data,
|
|
// data for each split
|
|
|
|
'name_map' => $really_map,
|
|
// which cluster is really which language
|
|
// using the nearest neighbor technique, the cluster
|
|
// inherits all of the properties of its most-similar member
|
|
// this keeps track
|
|
);
|
|
|
|
|
|
// saves the result in the object
|
|
$this->_clusters = $return_val;
|
|
|
|
return $return_val;
|
|
}
|
|
|
|
|
|
/**
|
|
* Perform an intelligent detection based on clusterLanguages()
|
|
*
|
|
* WARNING: this method is EXPERIMENTAL. It is not recommended for common
|
|
* use, and it may disappear or its functionality may change in future
|
|
* releases without notice.
|
|
*
|
|
* This compares the sample text to top the top level of clusters. If the
|
|
* sample is similar to the cluster it will drop down and compare it to the
|
|
* languages in the cluster, and so on until it hits a leaf node.
|
|
*
|
|
* this should find the language in considerably fewer compares
|
|
* (the equivalent of a binary search), however clusterLanguages() is costly
|
|
* and the loss of accuracy from this technique is significant.
|
|
*
|
|
* This method may need to be 'fuzzier' in order to become more accurate.
|
|
*
|
|
* This function could be more useful if the universe of possible languages
|
|
* was very large, however in such cases some method of Bayesian inference
|
|
* might be more helpful.
|
|
*
|
|
* @param string $str input string
|
|
*
|
|
* @return array language scores (only those compared)
|
|
* @throws Text_LanguageDetect_Exception
|
|
* @see clusterLanguages()
|
|
*/
|
|
public function clusteredSearch($str)
|
|
{
|
|
// input check
|
|
if (!Text_LanguageDetect_Parser::validateString($str)) {
|
|
return array();
|
|
}
|
|
|
|
// clusterLanguages() will return a cached result if possible
|
|
// so it's safe to call it every time
|
|
$result = $this->clusterLanguages();
|
|
|
|
$dendogram_start = $result['open_forks'];
|
|
$dendogram_data = $result['fork_data'];
|
|
$dendogram_alias = $result['name_map'];
|
|
|
|
$sample_obj = new Text_LanguageDetect_Parser($str);
|
|
$sample_obj->prepareTrigram();
|
|
$sample_obj->setPadStart(!$this->_perl_compatible);
|
|
$sample_obj->analyze();
|
|
$sample_result = $sample_obj->getTrigramRanks();
|
|
$sample_count = count($sample_result);
|
|
|
|
// input check
|
|
if ($sample_count == 0) {
|
|
return array();
|
|
}
|
|
|
|
$i = 0; // counts the number of steps
|
|
|
|
foreach ($dendogram_start as $lang) {
|
|
if (isset($dendogram_alias[$lang])) {
|
|
$lang_key = $dendogram_alias[$lang];
|
|
} else {
|
|
$lang_key = $lang;
|
|
}
|
|
|
|
$scores[$lang] = $this->_normalize_score(
|
|
$this->_distance($this->_lang_db[$lang_key], $sample_result),
|
|
$sample_count
|
|
);
|
|
|
|
$i++;
|
|
}
|
|
|
|
if ($this->_perl_compatible) {
|
|
asort($scores);
|
|
} else {
|
|
arsort($scores);
|
|
}
|
|
|
|
$top_score = current($scores);
|
|
$top_key = key($scores);
|
|
|
|
// of starting forks, $top_key is the most similar to the sample
|
|
|
|
$cur_key = $top_key;
|
|
while (isset($dendogram_data[$cur_key])) {
|
|
$lang1 = $dendogram_data[$cur_key]['bestfit'];
|
|
$lang2 = $dendogram_data[$cur_key]['otherfit'];
|
|
foreach (array($lang1, $lang2) as $lang) {
|
|
if (isset($dendogram_alias[$lang])) {
|
|
$lang_key = $dendogram_alias[$lang];
|
|
} else {
|
|
$lang_key = $lang;
|
|
}
|
|
|
|
$scores[$lang] = $this->_normalize_score(
|
|
$this->_distance($this->_lang_db[$lang_key], $sample_result),
|
|
$sample_count
|
|
);
|
|
|
|
//todo: does not need to do same comparison again
|
|
}
|
|
|
|
$i++;
|
|
|
|
if ($scores[$lang1] > $scores[$lang2]) {
|
|
$cur_key = $lang1;
|
|
$loser_key = $lang2;
|
|
} else {
|
|
$cur_key = $lang2;
|
|
$loser_key = $lang1;
|
|
}
|
|
|
|
$diff = $scores[$cur_key] - $scores[$loser_key];
|
|
|
|
// $cur_key ({$dendogram_alias[$cur_key]}) wins
|
|
// over $loser_key ({$dendogram_alias[$loser_key]})
|
|
// with a difference of $diff
|
|
}
|
|
|
|
// found result in $i compares
|
|
|
|
// rather than sorting the result, preserve it so that you can see
|
|
// which paths the algorithm decided to take along the tree
|
|
|
|
// but sometimes the last item is only the second highest
|
|
if (($this->_perl_compatible && (end($scores) > prev($scores)))
|
|
|| (!$this->_perl_compatible && (end($scores) < prev($scores)))
|
|
) {
|
|
$real_last_score = current($scores);
|
|
$real_last_key = key($scores);
|
|
|
|
// swaps the 2nd-to-last item for the last item
|
|
unset($scores[$real_last_key]);
|
|
$scores[$real_last_key] = $real_last_score;
|
|
}
|
|
|
|
|
|
if (!$this->_perl_compatible) {
|
|
$scores = array_reverse($scores, true);
|
|
// second param requires php > 4.0.3
|
|
}
|
|
|
|
return $scores;
|
|
}
|
|
|
|
/**
|
|
* ut8-safe strlen()
|
|
*
|
|
* Returns the numbers of characters (not bytes) in a utf8 string
|
|
*
|
|
* @param string $str string to get the length of
|
|
*
|
|
* @return int number of chars
|
|
*/
|
|
public static function utf8strlen($str)
|
|
{
|
|
// utf8_decode() will convert unknown chars to '?', which is actually
|
|
// ideal for counting.
|
|
|
|
return strlen(utf8_decode($str));
|
|
|
|
// idea stolen from dokuwiki
|
|
}
|
|
|
|
/**
|
|
* Returns the unicode value of a utf8 char
|
|
*
|
|
* @param string $char a utf8 (possibly multi-byte) char
|
|
*
|
|
* @return int unicode value
|
|
* @access protected
|
|
* @link http://en.wikipedia.org/wiki/UTF-8
|
|
*/
|
|
function _utf8char2unicode($char)
|
|
{
|
|
// strlen() here will actually get the binary length of a single char
|
|
switch (strlen($char)) {
|
|
case 1:
|
|
// normal ASCII-7 byte
|
|
// 0xxxxxxx --> 0xxxxxxx
|
|
return ord($char{0});
|
|
|
|
case 2:
|
|
// 2 byte unicode
|
|
// 110zzzzx 10xxxxxx --> 00000zzz zxxxxxxx
|
|
$z = (ord($char{0}) & 0x000001F) << 6;
|
|
$x = (ord($char{1}) & 0x0000003F);
|
|
return ($z | $x);
|
|
|
|
case 3:
|
|
// 3 byte unicode
|
|
// 1110zzzz 10zxxxxx 10xxxxxx --> zzzzzxxx xxxxxxxx
|
|
$z = (ord($char{0}) & 0x0000000F) << 12;
|
|
$x1 = (ord($char{1}) & 0x0000003F) << 6;
|
|
$x2 = (ord($char{2}) & 0x0000003F);
|
|
return ($z | $x1 | $x2);
|
|
|
|
case 4:
|
|
// 4 byte unicode
|
|
// 11110zzz 10zzxxxx 10xxxxxx 10xxxxxx -->
|
|
// 000zzzzz xxxxxxxx xxxxxxxx
|
|
$z1 = (ord($char{0}) & 0x00000007) << 18;
|
|
$z2 = (ord($char{1}) & 0x0000003F) << 12;
|
|
$x1 = (ord($char{2}) & 0x0000003F) << 6;
|
|
$x2 = (ord($char{3}) & 0x0000003F);
|
|
return ($z1 | $z2 | $x1 | $x2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* utf8-safe fast character iterator
|
|
*
|
|
* Will get the next character starting from $counter, which will then be
|
|
* incremented. If a multi-byte char the bytes will be concatenated and
|
|
* $counter will be incremeted by the number of bytes in the char.
|
|
*
|
|
* @param string $str the string being iterated over
|
|
* @param int &$counter the iterator, will increment by reference
|
|
* @param bool $special_convert whether to do special conversions
|
|
*
|
|
* @return char the next (possibly multi-byte) char from $counter
|
|
* @access private
|
|
*/
|
|
static function _next_char($str, &$counter, $special_convert = false)
|
|
{
|
|
$char = $str{$counter++};
|
|
$ord = ord($char);
|
|
|
|
// for a description of the utf8 system see
|
|
// http://www.phpclasses.org/browse/file/5131.html
|
|
|
|
// normal ascii one byte char
|
|
if ($ord <= 127) {
|
|
// special conversions needed for this package
|
|
// (that only apply to regular ascii characters)
|
|
// lower case, and convert all non-alphanumeric characters
|
|
// other than "'" to space
|
|
if ($special_convert && $char != ' ' && $char != "'") {
|
|
if ($ord >= 65 && $ord <= 90) { // A-Z
|
|
$char = chr($ord + 32); // lower case
|
|
} elseif ($ord < 97 || $ord > 122) { // NOT a-z
|
|
$char = ' '; // convert to space
|
|
}
|
|
}
|
|
|
|
return $char;
|
|
|
|
} elseif ($ord >> 5 == 6) { // two-byte char
|
|
// multi-byte chars
|
|
$nextchar = $str{$counter++}; // get next byte
|
|
|
|
// lower-casing of non-ascii characters is still incomplete
|
|
|
|
if ($special_convert) {
|
|
// lower case latin accented characters
|
|
if ($ord == 195) {
|
|
$nextord = ord($nextchar);
|
|
$nextord_adj = $nextord + 64;
|
|
// for a reference, see
|
|
// http://www.ramsch.org/martin/uni/fmi-hp/iso8859-1.html
|
|
|
|
// À - Þ but not ×
|
|
if ($nextord_adj >= 192
|
|
&& $nextord_adj <= 222
|
|
&& $nextord_adj != 215
|
|
) {
|
|
$nextchar = chr($nextord + 32);
|
|
}
|
|
|
|
} elseif ($ord == 208) {
|
|
// lower case cyrillic alphabet
|
|
$nextord = ord($nextchar);
|
|
// if A - Pe
|
|
if ($nextord >= 144 && $nextord <= 159) {
|
|
// lower case
|
|
$nextchar = chr($nextord + 32);
|
|
|
|
} elseif ($nextord >= 160 && $nextord <= 175) {
|
|
// if Er - Ya
|
|
// lower case
|
|
$char = chr(209); // == $ord++
|
|
$nextchar = chr($nextord - 32);
|
|
}
|
|
}
|
|
}
|
|
|
|
// tag on next byte
|
|
return $char . $nextchar;
|
|
} elseif ($ord >> 4 == 14) { // three-byte char
|
|
|
|
// tag on next 2 bytes
|
|
return $char . $str{$counter++} . $str{$counter++};
|
|
|
|
} elseif ($ord >> 3 == 30) { // four-byte char
|
|
|
|
// tag on next 3 bytes
|
|
return $char . $str{$counter++} . $str{$counter++} . $str{$counter++};
|
|
|
|
} else {
|
|
// error?
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts an $language input parameter from the configured mode
|
|
* to the language name that is used internally.
|
|
*
|
|
* Works for strings and arrays.
|
|
*
|
|
* @param string|array $lang A language description ("english"/"en"/"eng")
|
|
* @param boolean $convertKey If $lang is an array, setting $key
|
|
* converts the keys to the language name.
|
|
*
|
|
* @return string|array Language name
|
|
*/
|
|
function _convertFromNameMode($lang, $convertKey = false)
|
|
{
|
|
if ($this->_name_mode == 0) {
|
|
return $lang;
|
|
}
|
|
|
|
if ($this->_name_mode == 2) {
|
|
$method = 'code2ToName';
|
|
} else {
|
|
$method = 'code3ToName';
|
|
}
|
|
|
|
if (is_string($lang)) {
|
|
return (string)Text_LanguageDetect_ISO639::$method($lang);
|
|
}
|
|
|
|
$newlang = array();
|
|
foreach ($lang as $key => $val) {
|
|
if ($convertKey) {
|
|
$newkey = (string)Text_LanguageDetect_ISO639::$method($key);
|
|
$newlang[$newkey] = $val;
|
|
} else {
|
|
$newlang[$key] = (string)Text_LanguageDetect_ISO639::$method($val);
|
|
}
|
|
}
|
|
return $newlang;
|
|
}
|
|
|
|
/**
|
|
* Converts an $language output parameter from the language name that is
|
|
* used internally to the configured mode.
|
|
*
|
|
* Works for strings and arrays.
|
|
*
|
|
* @param string|array $lang A language description ("english"/"en"/"eng")
|
|
* @param boolean $convertKey If $lang is an array, setting $key
|
|
* converts the keys to the language name.
|
|
*
|
|
* @return string|array Language name
|
|
*/
|
|
function _convertToNameMode($lang, $convertKey = false)
|
|
{
|
|
if ($this->_name_mode == 0) {
|
|
return $lang;
|
|
}
|
|
|
|
if ($this->_name_mode == 2) {
|
|
$method = 'nameToCode2';
|
|
} else {
|
|
$method = 'nameToCode3';
|
|
}
|
|
|
|
if (is_string($lang)) {
|
|
return Text_LanguageDetect_ISO639::$method($lang);
|
|
}
|
|
|
|
$newlang = array();
|
|
foreach ($lang as $key => $val) {
|
|
if ($convertKey) {
|
|
$newkey = Text_LanguageDetect_ISO639::$method($key);
|
|
$newlang[$newkey] = $val;
|
|
} else {
|
|
$newlang[$key] = Text_LanguageDetect_ISO639::$method($val);
|
|
}
|
|
}
|
|
return $newlang;
|
|
}
|
|
}
|
|
|
|
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
|
|
|
|
?>
|