modified: src/padarea.c

	modified:   src/recognize_kanji.c
	modified:   src/recognize_stroke.c
	modified:   src/strokes.txt

diff --git a/src/padarea.c b/src/padarea.c
index 185702f..f07e883 100644 (file)
--- a/src/padarea.c
+++ b/src/padarea.c
@@ -195,10 +195,11 @@ static int kp_padarea_motion_cb(GtkWidget *w, GdkEventMotion *event, gpointer da
     if(self->instroke && state & GDK_BUTTON1_MASK)
     {
        GdkPoint *p0 = (GdkPoint *)g_list_last(self->curstroke)->data;
     if(self->instroke && state & GDK_BUTTON1_MASK)
     {
        GdkPoint *p0 = (GdkPoint *)g_list_last(self->curstroke)->data;

+       if((p0->x == x) && (p0->y == y))
+           return TRUE;

        GdkPoint *pt = g_new(GdkPoint, 1);
        pt->x = x;
        pt->y = y;
        GdkPoint *pt = g_new(GdkPoint, 1);
        pt->x = x;
        pt->y = y;

-

        kp_padarea_draw_line(self, p0, pt);
        self->curstroke = g_list_append(self->curstroke, pt);
     }
        kp_padarea_draw_line(self, p0, pt);
        self->curstroke = g_list_append(self->curstroke, pt);
     }

diff --git a/src/recognize_kanji.c b/src/recognize_kanji.c
index 8579f1d..d9c27bf 100644 (file)
--- a/src/recognize_kanji.c
+++ b/src/recognize_kanji.c
@@ -139,7 +139,7 @@ static gunichar2* find_next_entry(gchar *allkanji, gunichar2 *entry, gint allkan
 
 static gunichar2* pick_kanji(GList *strokes, gchar **sdata, gchar *allkanji, gint allkanjilen)
 {
 
 static gunichar2* pick_kanji(GList *strokes, gchar **sdata, gchar *allkanji, gint allkanjilen)
 {

-    const gint MAX_DISTANCE = g_list_length(strokes) - 1;
+    const gint MAX_COUNT = 25;

     gint datalen = g_strv_length(sdata), i;
     gunichar2 key = 'A' + datalen - 1;
     gunichar2 *entry = (gunichar2*)allkanji;
     gint datalen = g_strv_length(sdata), i;
     gunichar2 key = 'A' + datalen - 1;
     gunichar2 *entry = (gunichar2*)allkanji;


@@ -155,18 +155,23 @@ static gunichar2* pick_kanji(GList *strokes, gchar **sdata, gchar *allkanji, gin
     {
        kanji_result *res = rate_next_kanji(strokes, sdata, entry);
        g_ptr_array_add(arr, res);
     {
        kanji_result *res = rate_next_kanji(strokes, sdata, entry);
        g_ptr_array_add(arr, res);

-       g_ptr_array_sort(arr, (GCompareFunc)kanji_results_compare);
-       for(i = arr->len - 1; i >= 0; i--)
+       entry = find_next_entry(allkanji, entry, allkanjilen, key);
+       if(!entry)
+           break;
+    }
+    g_ptr_array_sort(arr, (GCompareFunc)kanji_results_compare);
+    if(arr->len > MAX_COUNT)
+    {
+       kanji_result *res = g_ptr_array_index(arr, MAX_COUNT-1);
+       gint max_dist = res->dist;
+       for(i = arr->len - 1; i >= MAX_COUNT; i--)

        {
            kanji_result *res = g_ptr_array_index(arr, i);
        {
            kanji_result *res = g_ptr_array_index(arr, i);

-           if(res->dist > MAX_DISTANCE)
+           if(res->dist > max_dist)

                g_ptr_array_remove_index(arr, i);
            else
                break;
        }
                g_ptr_array_remove_index(arr, i);
            else
                break;
        }

-       entry = find_next_entry(allkanji, entry, allkanjilen, key);
-       if(!entry)
-           break;

     }
     gunichar2 *ret = calloc(arr->len + 1, sizeof(gunichar2));
     for(i = 0; i < arr->len; i++)
     }
     gunichar2 *ret = calloc(arr->len + 1, sizeof(gunichar2));
     for(i = 0; i < arr->len; i++)

diff --git a/src/recognize_stroke.c b/src/recognize_stroke.c
index 4ed930f..3c1b7fd 100644 (file)
--- a/src/recognize_stroke.c
+++ b/src/recognize_stroke.c
@@ -95,35 +95,43 @@ static GList* filter_equal_points(GList *s)
  * then remove B */
 static GList* filter_points_by_angle(GList *s)
 {
  * then remove B */
 static GList* filter_points_by_angle(GList *s)
 {

-    const float MIN_MAX_ANGLE = 170*M_PI/180;
-    while(1)
-    {
-       if(g_list_length(s) < 3)
-           return g_list_first(s);
-       GList *pt = 0;
-       if(find_largest_angle(s, &pt) > MIN_MAX_ANGLE)
-           s = g_list_delete_link(s, pt);
-       else
-           break;
-    }

     if(g_list_length(s) < 3)
     if(g_list_length(s) < 3)

-       return g_list_first(s);
+       return s;
+    gchar ch0, ch1;

     GdkPoint *p0, *p, *p2;
     for(s = g_list_next(s); s != g_list_last(s); s = g_list_next(s))
     {
        if(g_list_length(s) < 3)
     GdkPoint *p0, *p, *p2;
     for(s = g_list_next(s); s != g_list_last(s); s = g_list_next(s))
     {
        if(g_list_length(s) < 3)

-           return g_list_first(s);
+           break;

        p0 = (GdkPoint*)g_list_previous(s)->data;
        p = (GdkPoint*)s->data;
        p2 = (GdkPoint*)g_list_next(s)->data;
        p0 = (GdkPoint*)g_list_previous(s)->data;
        p = (GdkPoint*)s->data;
        p2 = (GdkPoint*)g_list_next(s)->data;

-       gchar ch0 = get_stroke_char(p0, p);
-       gchar ch1 = get_stroke_char(p, p2);
+       ch0 = get_stroke_char(p0, p);
+       ch1 = get_stroke_char(p, p2);

        if(ch0 == ch1)
            s = g_list_delete_link(s, s);
     }
     return g_list_first(s);
 }
 
        if(ch0 == ch1)
            s = g_list_delete_link(s, s);
     }
     return g_list_first(s);
 }
 

+static GList* filter_points_by_angle2(GList *s)
+{
+    if(g_list_length(s) < 3)
+       return s;
+    const float MIN_MAX_ANGLE = 170*M_PI/180;
+    while(1)
+    {
+       if(g_list_length(s) < 3)
+           break;
+       GList *pt = 0;
+       if(find_largest_angle(s, &pt) > MIN_MAX_ANGLE)
+           s = g_list_delete_link(s, pt);
+       else
+           break;
+    }
+    return g_list_first(s);
+}
+

 static float find_average_and_smallest_dist(GList *s, GList **pt0, GList **pt1, float *pdmin)
 {
     float d = 0, dt, dmin = -1;
 static float find_average_and_smallest_dist(GList *s, GList **pt0, GList **pt1, float *pdmin)
 {
     float d = 0, dt, dmin = -1;


@@ -150,13 +158,15 @@ static float find_average_and_smallest_dist(GList *s, GList **pt0, GList **pt1,
  * then remove B */
 static GList* filter_points_by_dist(GList *s)
 {
  * then remove B */
 static GList* filter_points_by_dist(GList *s)
 {

-    const float MAX_MIN_DIST = 0.3;
+    if(g_list_length(s) < 3)
+       return s;
+    const float MAX_MIN_DIST = 0.2;

     float d0, dmin;
     GList *pt0 = 0, *pt1 = 0;
     while(1)
     {
        if(g_list_length(s) < 3)
     float d0, dmin;
     GList *pt0 = 0, *pt1 = 0;
     while(1)
     {
        if(g_list_length(s) < 3)

-           return g_list_first(s);
+           break;

        d0 = MAX_MIN_DIST*find_average_and_smallest_dist(s, &pt0, &pt1, &dmin);
        if(dmin < d0)
        {
        d0 = MAX_MIN_DIST*find_average_and_smallest_dist(s, &pt0, &pt1, &dmin);
        if(dmin < d0)
        {


@@ -183,7 +193,7 @@ static GList* filter_points_by_dist(GList *s)
        else
            break;
     }
        else
            break;
     }

-    return s;
+    return g_list_first(s);

 }
 
 gchar *get_stroke_str(GList *s)
 }
 
 gchar *get_stroke_str(GList *s)


@@ -198,7 +208,7 @@ gchar *get_stroke_str(GList *s)
        gchar ch = get_stroke_char(p0, p1);
        if(!ch)
            continue;
        gchar ch = get_stroke_char(p0, p1);
        if(!ch)
            continue;

-       if(ch != prev)
+       if(g_ascii_tolower(ch) != g_ascii_tolower(prev))

        {
            if(len)
                ch = g_ascii_tolower(ch);
        {
            if(len)
                ch = g_ascii_tolower(ch);


@@ -212,9 +222,24 @@ gchar *get_stroke_str(GList *s)
 gchar* recognize_stroke(GList *stroke, GList **out)
 {
     *out = g_list_copy(stroke);
 gchar* recognize_stroke(GList *stroke, GList **out)
 {
     *out = g_list_copy(stroke);

-    *out = filter_equal_points(*out);
-    *out = filter_points_by_angle(*out);
-    *out = filter_points_by_dist(*out);
+    int len1, len2;
+    for(;;)
+    {
+       len1 = g_list_length(*out);
+       //g_printf("len_orig: %d\n", g_list_length(*out));
+       *out = filter_points_by_angle(*out);
+       //g_printf("len_angle_filtered: %d\n", g_list_length(*out));
+       *out = filter_points_by_dist(*out);
+       //g_printf("len_dist_filtered: %d\n", g_list_length(*out));
+       len2 = g_list_length(*out);
+       if(len1 != len2)
+           continue;
+       *out = filter_points_by_angle2(*out);
+       //g_printf("len_angle2_filtered: %d\n", g_list_length(*out));
+       len2 = g_list_length(*out);
+       if(len1 == len2)
+           break;
+    }

     return get_stroke_str(*out);
 }
 
     return get_stroke_str(*out);
 }
 

diff --git a/src/strokes.txt b/src/strokes.txt
index 748c512..9abea7c 100644 (file)
Binary files a/src/strokes.txt and b/src/strokes.txt differ