הצגת המקור של הדף "תכנות וזיהוי/אלגורתמים נוספים"

==בעיות בחיתוך אות==
[[File:GetIntoChar.jpg|thumb|חיתוך אלכסוני של אות]]
שיטת הזיהוי [[תכנות וזיהוי/הסברים לתוכנית לזיהוי כתב | באכ"כ]] המוזכרת בפרקים הקודמים ,

מבוססת על חיתוך האות על ידי קווים העוברים דרך התמונה של האות.

קו חותך קו אחר כאשר יש להם נקודה משותפת , כאן בתמונה קו חותך את האות פעם אחת ( בצד הימני התחתון שלה ) ,

אף על פי שהוא היה צריך לחתוך אותה פעמיים (גם בפינה השמאלית עליונה) .

וזה נגרם משום שהקווים מבוססים על נקודות (מלבנים המסודרים באלכסון) ,

ובנקודת החיתוך השמאלית עליונה המלבנים משתלבים ולא עולים זה על זה .

יוצא מכאן שיכולים להיות שני ישרים שונים במישור שלא חותכים זה את זה ולא [[W:ישרים מקבילים|מקבילים]]!
 
כדי לפתור את הבעיה התוכנה עוברת על המערך המכיל את האות הדגומה ,

ומחפש בקווים העוברים באלכסון נקודות הנוגעות זו בזו בפינות

(כלומר לא נמצאות זו מעל זו או זו בצד זו) מרחיבים את הקו במקום הנגיעה,

על ידי הוספת נקודה בצבע האות הצמודה למקום הנגיעה,

כך שבכל מקרה הנקודות ימצאו זו מעל זו או זו בצדי זו .

הנה קטע קו בעייתי :
{| class="wikitable"
|-
| הקו || רקע
|-
| רקע || הקו
|}
התיקון:
{| class="wikitable"
|-
| הקו || הקו
|-
| רקע || הקו
|}

=== מימוש האלגוריתם בפונקציה FillingGapsInC ===
<source lang="cpp">
void  FillingGapsInC(
       int GapsMat[RowsPerPic][ColsPerPic])

{int X,Y,X1,X2,Y1,Y2;
 int W = BrightLevels -1; // יש 8 רמות בהירות מ - 0 עד 7

 for(Y=0;Y<RowsPerPic-1;Y++)
  for(X=0;X<ColsPerPic-1;X++)
  {X1 = GapsMat[X][Y];
   X2 = GapsMat[X+1][Y];
   Y1 = GapsMat[X][Y+1];
   Y2 = GapsMat[X+1][Y+1];
    if (X1==W&&Y2==W&&Y1!=W&&X2!=W)
      GapsMat[X][Y]=0;
    if (X1!=W&&Y2!=W&&Y1==W&&X2==W)
      GapsMat[X+1][Y]=0;
  }
}
</source>

== העדפת המרכז ==
[[File:Diste.jpg|thumb|מרחק d בין נקודה לישר Y]]
בתוכנה קווים העוברים  קרוב למרכז האות

מקבלים ציון גבוה יותר על מספר הפעמים שחתכו את האות

מקווים שחותכים את האות בפינות . כי נראה שהאדם מתרכז

במרכז האות כשהוא מנסה לזהות אותה , את זה אפשר ללמוד [[W: ספר תורה |מספרי תורה]] :

בהם קיימים [[W:תג (גופן)|תגים]] בשולי האותיות , ובכל זאת אות עם תגים ואות ללא תגים

היא אותה אות  .

בתוכנית כל קו שעובר ליד מרכז האות במרחק קטן מחצי אורך (וגם רוחב) המלבן החוסם את האות ,

נחשב לקו העובר קרוב למרכז. כדי לחשב מה מרחק הקו מהמרכז התוכנה משתמשת בנוסחת [[W:מרחק נקודה מישר|מרחק נקודה מישר]].

=== מימוש האלגוריתם בפונקציה IsPassByTheCenterInL  ===
בדיקה אם הישר עובר קרוב למרכז ולכן התוצאות שלו חשובות יותר .

מבוסס על המשוואות מהגאומטריה האנליטית .

*מציאת מרחק נקודה מישר :

נסמן את : פונקציית הערך המוחלט כך :      y=|x|= abs(x)

נסמן את פונקציית השורש הריבועי כך:  <math> y =  \sqrt[2]{x} = sqrt(x)  </math>   

אם נקודת המרכז : ( x1,y1 ) והישר הוא :Ax+By+C=0
 
המרחק הוא = abs(Ax1+By1+C /sqrt(A*A+B*B))

*משוואת ישר על פי שתי נקודות :(x1,y1),(x2,y2) 

משוואת הישר היא  :
Y-y1=[(y2-x1)/(x2-x1)](X-x1)

<source lang="cpp">
#include <windows.h>
#include <math.h> 

bool IsPassByTheCenterInL(
   POINT  Start, POINT  End ,POINT Center)
{ float A,B,C,Mone,Mechane,Delta;
  bool Out = false;
 if (End.x-Start.x==0) return Out;
 A = float(End.y-Start.y)/float(End.x-Start.x) ;
 B = float(-1);
 C = B*A* float(Start.x);
 Mone= A*float(Center.x)+B*float(Center.y)+C;
 Mechane = sqrt(A*A + B*B);
 Delta =Mone /Mechane;
 if (Delta<0) Delta = Delta*B;
 if ( (Delta< float(Center.x) /2.0)&&
      (Delta< float(Center.y) /2.0)  )
   Out = true;
 return Out;
}
</source>

==צרוף תכונות לתכונה אחת ==
[[File:MinOf3Atributes.jpg|thumb|שלושה קווים החותכים את האותיות במשולש הימני]]
בשיטת באכ"ך קו אחד יוצר תכונה כאשר הוא חותך את האות מכיוון מסוים,

והציון ניתן על מספר הפעמים שהוא חתך את האות .

עדיף להוסיף להוסיף עוד סוג של תכונה , כדי שלא יקרה מקרה שאין הבחנה בין שתי אותיות .

בתוכנה מוסיפים עוד סוג של תכונה על ידי חישוב ממוצע הציון של כמה קווים מקבילים על חצי מהמלבן החוסם את האות  ,

זה יכול להיות בחלק העליון של האות ויכול להיות במשולש השמאלי תחתון של המלבן החוסם את האות וכולי.
==עיגול התוצאה ==
נניח שבתשעה מתוך עשרת המופעים של האות הקו (המיצג תכונה) חתך את האות , אם נחשב במספרים שלמים מה הממוצע

לתכונה זו נקבל 0, אם ננסה לחשב את הממוצע במספרים ממשיים (משתנה מסוג Float)  נסבך את החישוב . לכן במקרה

כזה [[W:עיגול (אריתמטיקה)|מעגלים]] את התוצאה למעלה , ואומרים שהממוצע הוא אחד. 

הנה דוגמה מהתוכנה לעיגול כלפי מעלה :
<source lang="cpp">
  if ((Sum % NumVariants)*2 > NumVariants)
       MeanMeanMap[TheFeature][PicRowNum]++ ;
</source>
===הסבר הקוד===
#חילוק שני  משתנים מסוג שלם : Sum  במשתנה NumVariants .
#לא מעניין אותי תוצאת החילוק רק תוצאת השארית (הפעולה % ).
#את השארית הכפל ב - 2.
#אם תוצאת ההכפלה גדולה מהמחלק סימן שהשארית קרובה בגודלה למחלק, ולכן צריך לעגל את התוצאה כלפי מעלה.
#התוצאה שצריך לעגל נמצאת במערך הדו ממדי MeanMeanMap, במקום ( TheFeature, PicRowNum). הגדל את הערך הזה באחד.
== מציאת שורה חדשה בקובץ טקסט==
בתוכנה מגיעים לשורה חדשה בקובץ הטקסט על ידי קריאת כל המשתנים בשורה  , לכן לכל קובץ יש שורות קוד אחרות

למציאת שורה חדשה. לדוגמה הפונקציה NewLinesInC :

<source lang="cpp">
void NewLinesInC(FILE *TheFilePointer,
      int NumLines, int Objects)
{int TheLine,TheAtt;
 int Stam[1];
 for(TheLine=0;TheLine<NumLines;TheLine++)
  for(TheAtt=0;TheAtt<Objects;TheAtt++)
   fscanf(TheFilePointer,"%d",&Stam[0]);
}
</source>
=== קוד לפונקציה NEW_LINE  ===
כך יוצרים פונקציה בשם NEW_LINE (עבור לשורה חדשה) המתאימה לכל קבצי טקסט  בעזרת הפונקציה fscanf
המוזכרת בשורות הקודמות :

<source lang="cpp">
void NEW_LINE (FILE *TheFilePointer
)
{
 MyLine char[MAX_PATH];
fscanf(TheFilePointer,"%[^\n]%*[\n]",&MyLine);
 }
</source>
=== הסברים לפונקציה NEW_LINE  ===
*הפונקציה מקבלת משתנה קלט אחד  מסוג FILE , הוא מצביע לקובץ שנפתח מקודם.
*הפונקציה לא מחזירה משתנה פלט לכן היא פונקציה מסוג void .
*המשתנה הפנימי MyLine הוא מערך תווים, שגודלו( MAX_PATH ) כגודל השורה הארוכה ביותר האפשרית .
* "[n\^]%" אומר לקחת כקלט את כל התווים חוץ משורה חדשה 'n\' .
* "[n\]*%" אומר להתעלם מהתו של שורה חדשה 'n\' . 
==קישור תמונה לתו ==
[[File:CharImageRelation.jpg|thumb|קישור תו  למספר הסודר של העצם]]
[[File:ObjectsLegend.jpg|thumb|הלחצן שמפעיל את המקרא המתאים לכל עצם מספר סידורי]]
[[File:CharsObjectsList.jpg|thumb|רשימה של מספר הסודר של העצם  התו והעצם]]
כדי שהתוכנה תוכל לרשום קובץ טקסט [[W:זיהוי תווים אופטי|המפענח]] את התמונות של האותיות, צריכה להיות בתוכנה תת [[W:מערכת|מערכת]]

המאפשרת לקשור תו  לתמונה של האות, לשם כך בחלון הפקדים (המוגדר [[תכנות וזיהוי/הסברים לתוכנית לזיהוי כתב| בפרקים הקודמים]])

יש רשימה של סימני הטקסט ומתוכם המשתמש בוחר סימן ומקשר אותו למספר הסידורי של תמונת העצם,

הקישור נשמר בתוך [[W:קובץ טקסט|קובץ טקסט]] שיש בו רשימה של שתי עמודות :
#מספר הסודר של תמונת העצם .
#התו.
=== היכן מקלידים ?===
עיין בתמונות בצד שמאל של העמוד : בתמונה הראשונה כתוב "סמן עצם באות" יש שם רשימה של סימנים.

או שבוחרים אחד מהם ובאופן אוטומטי המלבן מתחתיו (עם כותרת "בחר") מקבל את הסימן , או שמקלידים את הסימן במלבן.

במלבן מתחת  (עם כותרת "קשר לעצם #" ) מקלידים את המספר הסידורי של העצם. כדי לדעת מה המספר הסידורי של העצם

עיןן בתמונה השנייה ("עצמים") : המשתמש לוחץ על כפתור "מקרא" ומקבל טבלה עם שתי עמודות:
#מספר הסודר של העצם.
#תמונה של העצם.
אם הוא כבר קישר  כמה עצמים לתווים  הוא מקבל עמודה נוספת המציגה גם את התווים (כמו בתמונה השלישית) .
=== איך יוצרים מקרא לעצמים כטבלה המכילה עמודות של אותיות מספרים ותמונות ?===
יוצרים תמונת מפת סיביות חדשה  ומשתמשים בעיקר בשתי פונקציות ספרייה :

BitBlt המאפשרת לקחת חלק מתמונה אחת ולהדביק על תמונה שנייה
 
([[תכנות וזיהוי/פונקציות לטיפול בתמונות קבצים וחלונות|המוזכרת בפרקים הקודמים]]) המקבלת את המשתנים הללו :
# מצביע לחלק הגרפי של תמונת מפת הסיביות עליה יודבק חלק (או כל התמונה) ממפת סיביות אחרת.
# קואורדינטת הרוחב של הנקודה השמאלית עליונה שם תוצג התמונה.
# קואורדינטת הגובה של הנקודה השמאלית עליונה שם תוצג התמונה.
# רוחב הקטע (המלבן שהוא חלק מהתמונה) המוצג.
# גובה הקטע המוצג.
# מצביע לחלק הגרפי של תמונת מפת הסיביות ממנה יודבק חלק (או כולה) על מפת סיביות אחרת.
# קואורדינטת הרוחב של הנקודה השמאלית עליונה משם נלקח חלק מתמונה (או כל התמונה) .
# קואורדינטת הגובה של הנקודה השמאלית עליונה משם נלקח חלק מתמונה (או כל התמונה) .
# רוחב הקטע שנלקח.
# גובה הקטע שנלקח.
# שיטת עיבוד שתי התמונות בזמן ההדבקה, אצלנו זו הדבקה אחת על השנייה (מציבים את הקבוע SRCCOPY) .
TextOut משמשת לכתיבת טקסט על תמונת מפת סיביות היא מקבלת את המשתנים הללו : (HDC,int,int,LPCSTR,int)
# מצביע לחלק הגרפי של החלון.
# קואורדינטת הרוחב של מיקום הטקסט בתמונה .
# קואורדינטת הגובה.
# הטקסט.
# גודל הטקסט.

=== הסבר הפונקציות של קישור תמונה לתו ===
====תו רחב ====
סתם כך יש 256 תווים בטקסט המוצבים במשתנה מסוג char , אבל בערך 30 הראשונים אי אפשר להקליד אותם ,

נראה ש - 226 זה לא מספיק תווים.

הרעיון היה להשתמש בספריה  wchar.h שם מוגדר המשתנה  wchar_t  שאפשר לטעון אותו ב- 256*256 תווים ,

אבל לא הצלחתי ליצור רשימה שמראה תווי טקסט שונים מהסטנדרט.

==== אלו שגיאות המשתמש יכול לבצע ====   
#הוא יכול לשבץ אותו מספר עצם לשני תווים שונים (אעפ"י שמותר שיהיו אותו מספר עצם לשתי שורות שונות בתמונת העצמים).
#הוא יכול להיכנס לקובץ הטקסט המכיל את מספר העצם מול התו  (הקובץ Refer.txt ) ולהרוס את מבנהו.
#הוא יכול לשבץ מספר עצם שמספרו גדול מכמות העצמים.
#הוא יכול לשבץ מספר עצם הגדול מתחום התווים האפשריים ( לדוגמה  250 ).
#הוא יכול להקליד במקום סימן אחד שתי אותיות.
==== איך מונעים אותו מלעשות טעות ====
בודקים את המשתמש ומזהירים אותו ולא מעדכנים את הקובץ Refer.txt, (עיין בסוף הפונקציה MakeReferenceInG המוזכרת בהמשך).

אלו הבדיקות שעושים :
* כדי שלא ישבץ אותו מספר לשני תווים שונים , אחרי שהוא הקליד מספר בודקים בקובץ  Refer.txt אם המספר נמצא שם.
* אי אפשר למנוע מהמשתמש להרוס את מבנה הקובץ Refer.txt, אבל אחרי שהמשתמש הקליד משהוא בודקים את מבנה הקובץ.
* בודקים אם נעשה שיבוץ של מספר גדול מכמות העצמים, או מתחום התווים האפשריים.
* כדי שלא תוקלד מילה בת שתי אותיות אלא רק תו אחד, בודקים את מספר האותיות שהוקלדו.
==== הפונקציות שעוזרות להזהיר את המשתמש ====
MessageBox(HWND,LPCSTR,LPCSTR,UINT)

הפונקציה יוצרת חלון נוסף בו כתובה אזהרה , היא מקבלת את המשתנים הללו :

(סוג חלון אזהרה,תוכן האזהרה, כותרת האזהרה, חלון האב של חלון האזהרה) MessageBox

===הצגת התוכנה===
<source lang="cpp">
#include <windows.h>
#include <wchar.h>
#include <stdio.h>
#include <stdlib.h> 
#include "MyContR.h"
#include "MyProcs.h"

void ListCharTextInG(HWND hwnd)
{ const int Ascis = 272;
  const int FirstTextChar = 33;
  long listCounter;
  char StBf[2];
 SendDlgItemMessage(hwnd,
      IDC_LETTERS_LIST,
       LB_RESETCONTENT, 0, 0); 
  for(listCounter=FirstTextChar;
        listCounter< Ascis;
        listCounter++)   
     /* שבץ בדלגלג את האותיות האפשריות */
  { wsprintf(StBf,"%c",char(listCounter));
    SendDlgItemMessage(hwnd,IDC_LETTERS_LIST,
             LB_ADDSTRING,0, long(StBf));

  }               
}


void MakeReferenceInG(HWND hwnd)
{FILE *ReferF;
 int TheCompo,MaxxComps;
 int LineN,LiAtt[1]={0};
 char LineC[1]={'?'};
 LPSTR The_Text="  ",StBf;
 LPSTR ReferFileName="Refer.txt";

  bool Beseder=true;
  The_Text = new CHAR;
  StBf = new CHAR;
  ReferF = fopen(ReferFileName,"r");
   if (!ReferF) fopen(ReferFileName,"w");  
  fclose(ReferF);
  MaxxComps=GetDlgItemInt(
        hwnd,IDC_OBJECTS_NUM,
        NULL,FALSE); 
  TheCompo=GetDlgItemInt(
        hwnd,IDC_ELEM_REF,
        NULL,FALSE);
  if (TheCompo < 1 || TheCompo > MaxxComps )
         {MessageBox(NULL,
            "המפתח צריך להיות בתחום כמות העצמים",
            "אזהרה",0);
           SetFocus( GetDlgItem(hwnd,
                       IDC_OBJECTS_NUM));
           Beseder =false;             
          }        
 GetWindowText(
    GetDlgItem( hwnd,IDC_THE_CHAR),
      The_Text,3);
 wsprintf(StBf,"%d",The_Text[1]);
 if (The_Text[1])// סומנו שתי אותיות רציפות
    // במקום לבחור אות אחת
 { MessageBox(NULL,
            "בחר רק אות אחת",
            StBf,0);
           SetFocus( GetDlgItem(hwnd,
                       IDC_THE_CHAR));
           Beseder =false; 
 }
  ReferF = fopen(ReferFileName,"r");
   for(LineN=0;
       fscanf(ReferF,"%d",&LiAtt[0])!= EOF;
       LineN++)
    { if  (TheCompo == LiAtt[0])
         {MessageBox(NULL,
            "אסור שהיה אותו מפתח פעמיים
            ,אם אתה רוצה לשנות
            שנה את הקובץ
            refer.txt
            .בעזרת הפעלתו
            בתפריט הראשי
             בחר קובץ
                אחרים",
            "אזהרה",0);
           SetFocus( GetDlgItem(hwnd,
                       IDC_THE_CHAR));
          Beseder =false;             
          break;}
      if( fscanf(ReferF,"%c",&LineC[0])
         == EOF)
       {  MessageBox(NULL,
            "מבנה הקובץ לא טוב\
            אין בכל שורה תו אחרי מספר שלם",
            "אזהרה",0);
          Beseder =false;
          break;
       }               
    }           
  fclose(ReferF);
  if (Beseder)
  { ReferF = fopen(ReferFileName,"a"); 
           fprintf(ReferF, "%4d     %4s \n",
           TheCompo,           
           The_Text );
    fclose(ReferF);
    SetDlgItemText(hwnd,
           IDC_A_CHAR_SELECTED,"נקשר בהצלחה");
  }
  delete The_Text;
}
</source>

[[קטגוריה:תכנות וזיהוי]]