Bool32 TestFontProtocol(void)
{
#ifdef _USE_LEO_
int32_t name;
int i; //,j;
int nClust;
int numCourier,nC;
FILE *fp;
LeoFieldSetup fs={0};
RecRaster rec;
RecObject ro={0};
LeoPageSetup ps={0};
int jj;
if( _access("c:\\met.ini",0)==-1 )
return FALSE;
nClust=FONGetClustCount();
set_alphabet(alphabet1, alpha_str);
LEOSetPlatform(586);
fs.nStyle = LS_PRINT;
memcpy(fs.AlphaTable,alphabet1,256);
LEOSetupField(&fs);
CTB_unlink("CLUST2");
fp=fopen(".\\clu_met.pro","wt");
for(i=0,nC=numCourier=0;i<nClust;i++)
{
for(jj=0;jj<3;jj++)
{
name=0;
FONGetClusterAsBW(&name,i,jj*25,&rec);
CTB_AddRecRaster("CLUST2", &rec,decode_ASCII_to_[name][0]);
memset(&ro,0,sizeof(RecObject));
memcpy(&ro.recData.recRaster,&rec,REC_MAX_RASTER_SIZE);
ps.nIdPage=-1;
ro.recData.lwStatus=0;
LEOSetupPage(&ps);
fprintf(fp,"Nclu=%d(%d) let=%c tresh=%d%s\n",i,i*3+jj, name, jj,jj?"":"(default)" );
LEORecogPrintChar(&ro);
print_method(fp,&ro.recResults," leo : ",1);
LEORecogPrnMethod( &ro , REC_METHOD_MSK, 1);
print_method(fp,&ro.recResults," msk : ",0);
LEORecogCharDebug( &ro );
print_method(fp,&ro.recResults," evn+3x5 : ",1);
} // end treshold
fprintf(fp,"\n");
} // end clusters
fclose(fp);
#endif
return TRUE;
}
symmetric_printing_device::symmetric_printing_device(ustring alpha_chars)
{
vector<gunichar> help;
ustr_to_vec(alpha_chars, help);
boost::shared_ptr<alphabet<gunichar> > alpha(new alphabet<gunichar>(help));
set_alphabet(alpha);
}
Bool32 RecogLEOcap(RecRaster *Rs,uchar Language,RecVersions *Vs)
{
#ifdef _USE_LEO_
LeoFieldSetup fs={0};
RecObject ro={0};
LeoPageSetup ps={0};
char * alpha;
switch(Language)
{
case PUMA_LANG_RUSSIAN:
alpha = alpha_str_cap;
break;
case PUMA_LANG_ENGLISH:
alpha = alpha_str_lat_cap;
break;
default:
alpha = alpha_str_all_cap;
break;
}
set_alphabet(alphabet1, alpha);
LEOSetPlatform(586);
fs.nStyle = LS_PRINT;
memcpy(fs.AlphaTable,alphabet1,256);
LEOSetupField(&fs);
memset(&ro,0,sizeof(RecObject));
memcpy(&ro.recData.recRaster,Rs,REC_MAX_RASTER_SIZE);
ps.nIdPage=-1;
ro.recData.lwStatus=0;
LEOSetupPage(&ps);
LEORecogPrintChar(&ro);
memcpy(Vs,&ro.recResults,sizeof(RecVersions));
#endif
return TRUE;
}
static DBusMessage *sms_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_sms *sms = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (sms->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (!strcmp(property, "ServiceCenterAddress")) {
const char *value;
struct ofono_phone_number sca;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (strlen(value) == 0 || !valid_phone_number_format(value))
return __ofono_error_invalid_format(msg);
if (sms->driver->sca_set == NULL ||
sms->driver->sca_query == NULL)
return __ofono_error_not_implemented(msg);
string_to_phone_number(value, &sca);
sms->pending = dbus_message_ref(msg);
sms->driver->sca_set(sms, &sca, sca_set_callback, sms);
return NULL;
}
if (!strcmp(property, "Bearer")) {
const char *value;
int bearer;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (sms_bearer_from_string(value, &bearer) != TRUE)
return __ofono_error_invalid_format(msg);
if (sms->driver->bearer_set == NULL ||
sms->driver->bearer_query == NULL)
return __ofono_error_not_implemented(msg);
sms->pending = dbus_message_ref(msg);
sms->driver->bearer_set(sms, bearer, bearer_set_callback, sms);
return NULL;
}
if (!strcmp(property, "UseDeliveryReports")) {
const char *path = __ofono_atom_get_path(sms->atom);
dbus_bool_t value;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
if (sms->use_delivery_reports != (ofono_bool_t) value) {
sms->use_delivery_reports = value;
ofono_dbus_signal_property_changed(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"UseDeliveryReports",
DBUS_TYPE_BOOLEAN, &value);
}
return NULL;
}
if (!strcmp(property, "Alphabet")) {
const char *value;
enum sms_alphabet alphabet;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (!sms_alphabet_from_string(value, &alphabet))
return __ofono_error_invalid_format(msg);
set_alphabet(sms, alphabet);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
void read_regexp_file(
char* filename, // Name of MEME file IN
int* num_motifs, // Number of motifs retrieved OUT
MOTIF_T* motifs // The retrieved motifs - NOT ALLOCATED!
) {
FILE* motif_file; // MEME file containing the motifs.
char motif_name[MAX_MOTIF_ID_LENGTH+1];
char motif_regexp[MAX_MOTIF_WIDTH];
ARRAY_T* these_freqs;
MOTIF_T* m;
int i;
//Set things to the defaults.
*num_motifs = 0;
// Open the given MEME file.
if (open_file(filename, "r", TRUE, "motif", "motifs", &motif_file) == 0)
exit(1);
//Set alphabet - ONLY supports dna.
set_alphabet(verbosity, "ACGT");
while (fscanf(motif_file, "%s\t%s", motif_name, motif_regexp) == 2) {
/*
* Now we:
* 1. Fill in new motif (preallocated)
* 2. Assign name
* 3. Convert regexp into frequency table.
*/
m = &(motifs[*num_motifs]);
set_motif_id(motif_name, m);
m->length = strlen(motif_regexp);
/* Store the alphabet size in the motif. */
m->alph_size = get_alph_size(ALPH_SIZE);
m->ambigs = get_alph_size(AMBIG_SIZE);
/* Allocate memory for the matrix. */
m->freqs = allocate_matrix(m->length, get_alph_size(ALL_SIZE));
//Set motif frequencies here.
for (i=0;i<strlen(motif_regexp);i++) {
switch(toupper(motif_regexp[i])) {
case 'A':
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
break;
case 'C':
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'G':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
break;
case 'T':
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'U':
set_matrix_cell(i,alphabet_index('U',get_alphabet(TRUE)),1,m->freqs);
break;
case 'R': //purines
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
break;
case 'Y': //pyramidines
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'K': //keto
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'M': //amino
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'S': //strong
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'W': //weak
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'B':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'D':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'H':
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'V':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
break;
case 'N':
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
}
}
/* Compute values for ambiguous characters. */
for (i = 0; i < m->length; i++) {
these_freqs = get_matrix_row(i, m->freqs);
fill_in_ambiguous_chars(FALSE, these_freqs);
}
/* Compute and store the motif complexity. */
m->complexity = compute_motif_complexity(m);
//Move our pointer along to do the next motif.
(*num_motifs)++;
}
}
Bool32 RecogLEO_SetAlphabet(char *letters)
{
set_alphabet(alphabet1, letters);
return TRUE;
}
Bool32 RecogLEO(RecRaster *Rs,uchar Language,UniVersions *Us)
{
#ifdef _USE_LEO_
LeoFieldSetup fs={0};
RecObject ro={0};
LeoPageSetup ps={0};
char * alpha;
uchar c, cw;
int32_t i, up=-1;
alpha = alpha_str;
set_alphabet(alphabet1, alpha);
LEOSetPlatform(586);
fs.nStyle = LS_PRINT;
memcpy(fs.AlphaTable,alphabet1,256);
LEOSetupField(&fs);
memset(&ro,0,sizeof(RecObject));
memcpy(&ro.recData.recRaster,Rs,REC_MAX_RASTER_SIZE);
ps.nIdPage=-1;
ro.recData.lwStatus=0;
LEOSetupPage(&ps);
LEORecogPrintChar(&ro);
// memcpy(Vs,&ro.recResults,sizeof(RecVersions));
if( Us->lnAltCnt )
{
c = Us->Alt[0].Liga ;
if( is_upper(c) )
up=1;
else if( is_lower(c) )
up=0;
}
Us->lnAltCnt=ro.recResults.lnAltCnt;
Us->lnAltMax=REC_MAX_VERS;
for(i=0;i<ro.recResults.lnAltCnt;i++)
{
c = stdAnsiToAscii( ro.recResults.Alt[i].Code);
switch( up )
{
case 1: // upper
c=to_upper(c);
break;
case 0: // lower
c=to_lower(c);
break;
default:
break;
}
cw = stdAsciiToAnsi( c );
Us->Alt[i].Code[0]=cw;
Us->Alt[i].Code[1]=0;
Us->Alt[i].Liga=c;
Us->Alt[i].Charset=CSTR_RUSSIAN_CHARSET;
Us->Alt[i].Method =REC_METHOD_LEO;
Us->Alt[i].Prob = ro.recResults.Alt[i].Prob ;
}
#endif
return TRUE;
}
int32_t TestFontClusters(void)
{
#ifdef _USE_LEO_
int32_t name;
int i,j;
int nClust;
int porog=50; // test !!!
int numInvalid;
LeoFieldSetup fs={0};
RecRaster rec;
RecObject ro={0};
LeoPageSetup ps={0};
ClustInfo cluInfo;
uchar addLet,resLet;
#ifdef _SAVE_INVALID_CLU_
FILE *fp;
#endif
curNumFile++;
nClust=FONGetClustCount();
set_alphabet(alphabet1, alpha_str);
#ifdef _SAVE_INVALID_CLU_
fp=fopen("clust.tst","at");
fprintf(fp,"file %d\n",curNumFile);
#endif
LEOSetPlatform(LEOGetCPU());
fs.nStyle = LS_PRINT;
memcpy(fs.AlphaTable,alphabet1,256);
LEOSetupField(&fs);
for(i=0,numInvalid=0;i<nClust;i++)
{
cluInfo.let = 0;
j=FONGetClustInfo(&cluInfo,i+1);
if(j<=0)
continue;
if(cluInfo.attr & CTB_PRINT_ITALIC)
continue;
if(cluInfo.attr & CTB_PRINT_BOLD)
continue;
// now - test only russian ASCII letters
if(cluInfo.let < 128 ||
cluInfo.let >= 176 && cluInfo.let < 224 ||
cluInfo.let > 240
)
continue;
addLet=(cluInfo.let < 144 ? cluInfo.let +32 :
cluInfo.let < 160 ? cluInfo.let +80 :
cluInfo.let < 176 ? cluInfo.let -32 :
cluInfo.let - 80
);
name=0;
FONGetClusterAsBW(&name,i,porog,&rec);
memset(&ro,0,sizeof(RecObject));
memcpy(&ro.recData.recRaster,&rec,sizeof(RecRaster));
ps.nIdPage=-1;
ro.recData.lwStatus=0;
LEOSetupPage(&ps);
LEORecogPrintChar(&ro);
// ничего хорошего по LEO ?
if( ro.recResults.lnAltCnt <= 0 ||
ro.recResults.Alt[0].Prob < 150
)
continue;
for(j=0;j<ro.recResults.lnAltCnt;j++)
{
resLet = stdAnsiToAscii(ro.recResults.Alt[j].Code);
if( resLet == cluInfo.let ||
resLet == addLet )
break;
}
if(j==0)
continue;
{ char *qq;
resLet = stdAnsiToAscii(ro.recResults.Alt[0].Code);
if( !is_lower(resLet) )
resLet = to_lower(resLet);
if( (qq=strchr(hasNearSame,cluInfo.let)) &&
NearSame[qq-(char*)hasNearSame] == resLet
)
continue;
}
// узналось как что-то иное ?
// если совсем не распозналось - бывает ('»' в sten91)
if( j >= ro.recResults.lnAltCnt ||
ro.recResults.Alt[j].Prob < 180 ||
ro.recResults.Alt[j].Prob < 220 &&
ro.recResults.Alt[j].Prob + 25 < ro.recResults.Alt[0].Prob
)
{
FonTestInfo testInfo[MAXCHECKALT];
// проверим
resLet = stdAnsiToAscii(ro.recResults.Alt[0].Code);
j=FONTestChar(&rec,resLet,testInfo,0);
if( j <=0 || testInfo[0].prob <= 215 )
{
resLet=(resLet < 144 ? resLet +32 :
resLet < 160 ? resLet +80 :
resLet < 176 ? resLet -32 :
resLet - 80
);
j=FONTestChar(&rec,resLet,testInfo,0);
}
if( j > 0 && testInfo[0].prob > 215 )
{
numInvalid++;
FONSetClusterInvalid(i+1);
#ifdef _SAVE_INVALID_CLU_
fprintf(fp," invalid %d (%c -> %c(%d))\n",i+1,cluInfo.let,
stdAnsiToAscii(ro.recResults.Alt[0].Code),
ro.recResults.Alt[0].Prob);
#endif
}
} // end if j
} // end clusters
#ifdef _SAVE_INVALID_CLU_
fclose(fp);
#endif
return numInvalid;
#else
return 0;
#endif
}
