static void freeClasses(ef_class_info* c, u1 count) {
u1 i = 0;
for(; i < count; ++i) {
free(c[i].supers);
free(c[i].interfaces);
freeFields(c[i].fields, c[i].export_fields_count);
free(c[i].fields);
free(c[i].methods);
}
}
const char* ocr_semantic_match(filtro_gestos_in_imagen_t* dibujo, pack_init_t* packInit)
{
char *devolver = 0;
int size,i;
char buffer[128];
char* text;
size=0;
if(dibujo && packInit){
fields_t* fields= limits(dibujo);
constellation_t* constelacion= makeConstellation(fields,dibujo);
for(i=0; i<constelacion->m_top; i++){
buffer[size]= match_constallation(packInit->dataBase,constelacion->m_list[i]);
if(i<constelacion->m_top-1 && fields->espacios[i]){size++; buffer[size]=' ';}
size++;
}
buffer[size]='\0';
freeFields(fields);
text= /*strdup(*/buffer/*)*/;
if(strcmp(text,"")){
char total[128]="";
int cont,k,a,i;
char word[128]=""; cont=k=a=0;
for(i=0; i<=size; i++){
if(text[i]==' '){
word[cont]='\0';
strcat(total,strcat(MatchDicc(word,cont,k,packInit,constelacion)," "));
word[0]='\0'; k=a; cont=0;}
else if(i==size){
word[cont]='\0';
strcat(total,strcat(MatchDicc(word,cont,k,packInit,constelacion)," "));
}
else {word[cont]=text[i]; a++; cont++;}
}
//free(dibujo->m_imagen);
//free(dibujo);
//freeConstellation(constelacion);
//return strdup(total);
devolver = strdup(total);
}
/*free(dibujo->m_imagen);
free(dibujo);*/
freeConstellation(constelacion);
}
/* free(dibujo->m_imagen);
free(dibujo);
freeConstellation(constelacion);*/
return devolver;
}
export_file* read_export_file(const char* filename) {
char* data = NULL;
export_file* ef = NULL;
unsigned int length = 0;
unsigned int position = 0;
u2 indexCP = 0;
u1 indexClass = 0;
printf("Starting to read the export file: %s\n", filename);
data = readFile(filename, &length);
if(data == NULL)
return NULL;
if(length == 0) {
fprintf(stderr, "No data to parse\n");
free(data);
return NULL;
}
ef = (export_file*)malloc(sizeof(export_file));
if(ef == NULL)
return NULL;
if((position + 8) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
free(ef);
free(data);
return NULL;
}
ef->magic = bigEndianToLittleEndianU32(data);
position += 4;
ef->minor_version = data[position++];
ef->major_version = data[position++];
ef->constant_pool_count = bigEndianToLittleEndianU16(data + position);
position += 2;
if(ef->constant_pool_count < 1) {
fprintf(stderr, "The constant pool is empty. There should be at least one element.\n");
free(ef);
free(data);
return NULL;
}
/*printf("Constant pool count: %u\n", ef->constant_pool_count);*/
ef->constant_pool = (ef_cp_info*)malloc(sizeof(ef_cp_info) * ef->constant_pool_count);
if(ef->constant_pool == NULL) {
perror("parseExportFile");
free(ef);
free(data);
return NULL;
}
for(; indexCP < ef->constant_pool_count; ++indexCP) {
if((position + 1) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].tag = data[position++];
switch(ef->constant_pool[indexCP].tag) {
case EF_CONSTANT_PACKAGE:
if((position + 6) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Package.flags = data[position++];
ef->constant_pool[indexCP].CONSTANT_Package.name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->constant_pool[indexCP].CONSTANT_Package.minor_version = data[position++];
ef->constant_pool[indexCP].CONSTANT_Package.major_version = data[position++];
ef->constant_pool[indexCP].CONSTANT_Package.aid_length = data[position++];
if((position + ef->constant_pool[indexCP].CONSTANT_Package.aid_length) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Package.aid = (u1*)malloc(sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Package.aid_length);
if(ef->constant_pool[indexCP].CONSTANT_Package.aid == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
memcpy(ef->constant_pool[indexCP].CONSTANT_Package.aid, data + position, sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Package.aid_length);
position += ef->constant_pool[indexCP].CONSTANT_Package.aid_length;
break;
case EF_CONSTANT_CLASSREF:
if((position + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Classref.name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
break;
case EF_CONSTANT_INTEGER:
if((position + 4) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Integer.bytes = bigEndianToLittleEndianU32(data + position);
position += 4;
break;
case EF_CONSTANT_UTF8:
if((position + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Utf8.length = bigEndianToLittleEndianU16(data + position);
position += 2;
if((position + ef->constant_pool[indexCP].CONSTANT_Utf8.length) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Utf8.bytes = (u1*)malloc(sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Utf8.length);
if(ef->constant_pool[indexCP].CONSTANT_Utf8.bytes == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
memcpy(ef->constant_pool[indexCP].CONSTANT_Utf8.bytes, data + position, sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Utf8.length);
position += ef->constant_pool[indexCP].CONSTANT_Utf8.length;
/*printf("\tIndex %u: %.*s\n", indexCP, ef->constant_pool[indexCP].CONSTANT_Utf8.length, ef->constant_pool[indexCP].CONSTANT_Utf8.bytes);*/
break;
default:
fprintf(stderr, "The tag %u is not supported.\n", ef->constant_pool[indexCP].tag);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
}
if((position + 3) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->this_package = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->export_class_count = data[position++];
/*printf("class count: %u\n", ef->export_class_count);*/
if(ef->export_class_count == 0) {
ef->classes = NULL;
return ef;
}
ef->classes = (ef_class_info*)malloc(sizeof(ef_class_info) * ef->export_class_count);
if(ef->classes == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
for(; indexClass < ef->export_class_count; ++indexClass) {
u2 index = 0;
if((position + 7) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].token = data[position++];
ef->classes[indexClass].access_flags = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].export_supers_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("Class %u\n\tSupers count:%u\n", indexClass, ef->classes[indexClass].export_supers_count);*/
if(ef->classes[indexClass].export_supers_count > 0) {
if((position + (2 * ef->classes[indexClass].export_supers_count) + 1) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].supers = (u2*)malloc(sizeof(u2) * ef->classes[indexClass].export_supers_count);
if(ef->classes[indexClass].supers == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(; index < ef->classes[indexClass].export_supers_count; ++index) {
ef->classes[indexClass].supers[index] = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
if((position + 1) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].supers = NULL;
}
ef->classes[indexClass].export_interfaces_count = data[position++];
/*printf("\tInterfaces count: %u\n", ef->classes[indexClass].export_interfaces_count);*/
if(ef->classes[indexClass].export_interfaces_count > 0) {
if((position + (2 * ef->classes[indexClass].export_interfaces_count) + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].interfaces = (u2*)malloc(sizeof(u2) * ef->classes[indexClass].export_interfaces_count);
if(ef->classes[indexClass].interfaces == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(index = 0; index < ef->classes[indexClass].export_interfaces_count; ++index) {
ef->classes[indexClass].interfaces[index] = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
ef->classes[indexClass].interfaces = NULL;
}
ef->classes[indexClass].export_fields_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("\tFields count: %u\n", ef->classes[indexClass].export_fields_count);*/
if(ef->classes[indexClass].export_fields_count > 0) {
ef->classes[indexClass].fields = (ef_field_info*)malloc(sizeof(ef_field_info) * ef->classes[indexClass].export_fields_count);
if(ef->classes[indexClass].fields == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(index = 0; index < ef->classes[indexClass].export_fields_count; ++index) {
u2 indexAttribute = 0;
if((position + 9) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, index);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].fields[index].token = data[position++];
ef->classes[indexClass].fields[index].access_flags = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].descriptor_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].attributes_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("\tField %u\n\t\tAttributes count: %u\n", index, ef->classes[indexClass].fields[index].attributes_count);*/
if(ef->classes[indexClass].fields[index].attributes_count > 0) {
if((position + (8 * ef->classes[indexClass].fields[index].attributes_count) + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, index);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].fields[index].attributes = (ef_attribute_info*)malloc(sizeof(ef_attribute_info) * ef->classes[indexClass].fields[index].attributes_count);
if(ef->classes[indexClass].fields[index].attributes == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, index);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(; indexAttribute < ef->classes[indexClass].fields[index].attributes_count; ++indexAttribute) {
ef->classes[indexClass].fields[index].attributes[indexAttribute].attribute_name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].attributes[indexAttribute].attribute_length = bigEndianToLittleEndianU32(data + position);
position += 4;
ef->classes[indexClass].fields[index].attributes[indexAttribute].constantvalue_index = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
ef->classes[indexClass].fields[index].attributes = NULL;
}
}
} else {
ef->classes[indexClass].fields = NULL;
}
ef->classes[indexClass].export_methods_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("\tMethods count: %u\n",ef->classes[indexClass].export_methods_count);*/
if(ef->classes[indexClass].export_methods_count > 0) {
if((position + (7 * ef->classes[indexClass].export_methods_count)) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, ef->classes[indexClass].export_fields_count);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].methods = (ef_method_info*)malloc(sizeof(ef_method_info) * ef->classes[indexClass].export_methods_count);
if(ef->classes[indexClass].methods == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, ef->classes[indexClass].export_fields_count);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(index = 0; index < ef->classes[indexClass].export_methods_count; ++index) {
ef->classes[indexClass].methods[index].token = data[position++];
ef->classes[indexClass].methods[index].access_flags = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].methods[index].name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].methods[index].descriptor_index = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
ef->classes[indexClass].methods = NULL;
}
}
return ef;
}
struct svm_model* svm_load_model_string(char *modelString){
/* redefinition from svm.cpp */
char *svm_type_table[]={"c_svc","nu_svc","one_class","epsilon_svr","nu_svr",NULL};
char *kernel_type_table[]={"linear","polynomial","rbf","sigmoid",NULL};
struct svm_model *model;
char **lines, **fields;
int i,j,k,l,m;
char *key, *value, *field;
char c;
int dataStart, elements;
int isColon;
struct svm_node *x_space=NULL;
model = (struct svm_model*)space(sizeof(struct svm_model));
model->rho = NULL;
model->probA = NULL;
model->probB = NULL;
model->label = NULL;
model->nSV = NULL;
/* Read header until support vectors start */
lines=splitLines(modelString);
i=0;
while (strcmp(lines[i],"SV")!=0){
fields=splitFields(lines[i]);
key=fields[0];
if(strcmp(key,"svm_type")==0){
value=fields[1];
for(j=0;svm_type_table[j];j++){
if(strcmp(svm_type_table[j],value)==0){
model->param.svm_type=j;
break;
}
}
if(svm_type_table[i] == NULL){
fprintf(stderr,"unknown svm type.\n");
free(model->rho);
free(model->label);
free(model->nSV);
free(model);
return NULL;
}
} else
if(strcmp(key,"kernel_type")==0){
value=fields[1];
for(j=0;kernel_type_table[j];j++){
if(strcmp(kernel_type_table[j],value)==0){
model->param.kernel_type=j;
break;
}
}
if(kernel_type_table[i] == NULL){
fprintf(stderr,"unknown kernel type.\n");
free(model->rho);
free(model->label);
free(model->nSV);
free(model);
return NULL;
}
} else
if (strcmp(key,"gamma")==0){
value=fields[1];
sscanf(value,"%lf",&model->param.gamma);
}
if (strcmp(key,"degree")==0){
value=fields[1];
sscanf(value,"%lf",&model->param.degree);
} else
if (strcmp(key,"coef0")==0){
value=fields[1];
sscanf(value,"%lf",&model->param.coef0);
} else
if (strcmp(key,"nr_class")==0){
value=fields[1];
sscanf(value,"%d",&model->nr_class);
} else
if (strcmp(key,"total_sv")==0){
value=fields[1];
sscanf(value,"%d",&model->l);
} else
if (strcmp(key,"rho")==0){
int n = model->nr_class * (model->nr_class-1)/2;
model->rho = (double*)space(sizeof(double)*n);
for(j=0;j<n;j++){
sscanf(fields[j+1],"%lf",&model->rho[j]);
}
} else
if (strcmp(key,"nr_sv")==0){
int n = model->nr_class;
model->nSV = (int*)space(sizeof(int)*n);
for(j=0;j<n;j++){
sscanf(fields[j+1],"%d",&model->nSV[j]);
}
} else
if (strcmp(key,"label")==0){
int n = model->nr_class;
model->label = (int*)space(sizeof(int)*n);
for(j=0;j<n;j++){
sscanf(fields[j+1],"%d",&model->label[j]);
}
} else
if (strcmp(key,"probA")==0){
int n = model->nr_class * (model->nr_class-1)/2;
model->probA = (double*)space(sizeof(double)*n);
for(j=0;j<n;j++){
sscanf(fields[j+1],"%lf",&model->probA[j]);
}
} else
if (strcmp(key,"probB")==0){
int n = model->nr_class * (model->nr_class-1)/2;
model->probB = (double*)space(sizeof(double)*n);
for(j=0;j<n;j++){
sscanf(fields[j+1],"%lf",&model->probB[j]);
}
}
i++;
freeFields(fields);
}
dataStart=i+1;
elements=0;
/* Count number of nodes (by counting colons) in advance to allocate
memory in one block */
while (lines[i]!=NULL){
j=0;
while ((c=lines[i][j])!='\0'){
if (c==':'){
elements++;
}
j++;
}
elements++;
i++;
}
/* allocate memory for SVs and coefficients */
m = model->nr_class - 1;
l = model->l;
model->sv_coef = (double**)space(sizeof(double*)*m);
for(i=0;i<m;i++){
model->sv_coef[i] = (double*)space(sizeof(double)*l);
}
model->SV = (struct svm_node**)space(sizeof(struct svm_node*)*l);
if(l>0){
x_space = (struct svm_node*)space(sizeof(struct svm_node)*(elements));
}
/* parse support vector data */
j=0;
for(i=0;i<l;i++){
fields=splitFields(lines[dataStart+i]);
model->SV[i] = &x_space[j];
k=0;
while ((field=fields[k])!=NULL){
if (k<m){
sscanf(fields[k],"%lf",&model->sv_coef[k][i]);
} else {
sscanf(fields[k],"%d:%lf",&(x_space[j].index),&(x_space[j].value));
j++;
}
k++;
}
x_space[j++].index = -1;
freeFields(fields);
}
freeFields(lines);
model->free_sv = 1;
return(model);
}
