Глава 3
/** Program from Albert Volos May 2010
* (C) "Распознаватель Текста"
* Автор: Альберт Волос (e-mail: pick4you@yandex.ru)
* http://www.pick4you.narod.ru
*
**/
import java.io.*;
import java.text.*;
import java.lang.*;
import java.util.*;
import javagently.*;
class Filer {
public static Stream open (String filename) throws IOException {
Stream in = new Stream (System.in);
try {
return new Stream(filename, Stream.READ);
}
catch (FileNotFoundException e) {
System.out.println(filename+" does not exist.");
filename = in.readString();
}
throw new FileNotFoundException ();
}
}
//1. clearMatrix()
//2. funCopyDoubleListToMatrix(List<List<Character>> m)
//3. funCopyMatrixToDoubleList(List<List<Character>> m)
//4. funCopyMatrixToMatrix(Matrix m)
//5. funReverseMatrix()
//6. funShowMatrix(Stream fout)
//7. addFields()
//8. copyArayListToMatrix(List<Character> al, int length)
//9. getElement(int x, int y)
//10. getMatrixSizeY()
//11. getMatrixSizeX()
//12. funPustStr()
//13. funTurnMatrixVH()
//14. funTurnMatrixV()
//15. funCleanAboveStr() -очистить пустые строки сверху
//16. funContrast()
//17. funKey()
//18. funShowArrayList(List<Character> als, Stream fout)
class Matrix{
private List<List<Character>> matrix;
private int xSize = 0;
public Matrix() {
this.matrix = new ArrayList<List<Character>>();
}
public void setMatrix(List<List<Character>> matrix) {
this.matrix = matrix;
}
public List<List<Character>> getMatrix() {
return matrix;
}
//1---------------------------------------------------
public void clearMatrix() {
//this.matrix.clear();
matrix.clear();
}
//2---------------------------------------------------
public List<List<Character>> funCopyDoubleListToMatrix(List<List<Character>> m) {
matrix.addAll(m);
return matrix;
}
//3---------------------------------------------------
public List<List<Character>> funCopyMatrixToDoubleList(List<List<Character>> m) {
m.addAll(matrix);
return m;
}
//4---------------------------------------------------
public List<List<Character>> funCopyMatrixToMatrix(Matrix m){
List<List<Character>> temp = new ArrayList<List<Character>>();
m.funCopyMatrixToDoubleList(temp);
matrix.addAll(temp);
return matrix;
}
//5----------------------------------------------------
public void funReverseMatrix() {
Collections.reverse(matrix);
}
//6---------------------------------------------------
public void funShowMatrix(Stream fout) {
for (List<Character> als1: this.getMatrix()) {
for (Character c: als1) {
fout.print(c);
}
fout.println("");
}
}
//7---------------------------------------------------
public void addFields(Character[] cm) {
matrix.add(Arrays.asList(cm));
}
//8---------------------------------------------------
public void copyArayListToMatrix(List<Character> al, int length) {
List<List<Character>> Field = new ArrayList<List<Character>>();
List<Character> Stroka = new ArrayList<Character>();
xSize = length;
for (int i =0; i < al.size(); i++) {
Stroka.add(al.get(i));
if (Stroka.size() == length) {
Field.add(Stroka);
for (int y = 0; y < Field.size(); y++) {
List<Character> Str = new ArrayList<Character>();
for (int x = 0; x < Field.get(0).size(); x++) {
Str.add(Field.get(y).get(x));
}
matrix.add(Str);
}
Stroka.clear();
Field.clear();
}
}
}//end fun
//9---------------------------------------------------
public Character getElement(int x, int y) {
if (x >= 0 && x <= matrix.size() && y >=0 && y <= matrix.get(x).size()) {
return matrix.get(x).get(y);
}
else {
System.out.println("Don't found element.");
return null;
}
}
//10--------------------------
public int getMatrixSizeY() {
return matrix.size();
}
//11---------------------------------------------------
public int getMatrixSizeX() {
int index=0;
for (List<Character> als1: this.getMatrix()) {
for (Character c: als1) {
index++;
}
break;
}
return index;
}
//12---------------------------------------------------
public List<Character> funPustStr() {
//Определяем эталон пустой строки
List<Character> charVecPustStr = new ArrayList<Character>(); //вектор для строки
List<Character> charVecCh = new ArrayList<Character>();
List<Character> charVecCh1 = new ArrayList<Character>();
charVecCh1.add(new Character('0'));
int kol_Null = 0;
for(int y = 0; y < 1; y++){
for(int x = (this.getMatrixSizeX() - 1); x > 1; x--){
charVecCh.add(this.getElement(y,x));
if(charVecCh.equals(charVecCh1)){
kol_Null++;
charVecCh.clear();
continue;
}
else{
for(int i = 0; i< xSize - kol_Null;i++)
charVecPustStr.add(new Character('F'));
//System.out.println("kol_Null " + kol_Null);
for(int q=0;q<kol_Null;q++){
charVecPustStr.add(new Character('0'));
}
kol_Null = 0;
charVecCh.clear();
break;
}
}
}
return charVecPustStr;
}//end fun
//13---------------------------------------------------
public void funTurnMatrixVH(){
Matrix m = new Matrix();
m.setMatrix(new ArrayList<List<Character>>());
List<Character> charFieldVert = new ArrayList<Character>(); //вектор для строки
for (int x = 0; x < this.getMatrixSizeX(); x++) {
for (int y = 0; y < this.getMatrixSizeY(); y++) {
charFieldVert.add(this.getElement(y,x));
}
}
int temp = this.getMatrixSizeY();
//После того, как перевернули букву и положили ее набок сохраним
//результат в объекте Matrix
this.clearMatrix();
this.copyArayListToMatrix(charFieldVert, temp);
}//end fun
//14-----------------------
public void funTurnMatrixV(){
Matrix FieldTemp = new Matrix();
FieldTemp.setMatrix(new ArrayList<List<Character>>());
this.funReverseMatrix();
FieldTemp.funCopyMatrixToMatrix(this);
this.clearMatrix();
this.funCopyMatrixToMatrix(FieldTemp);
}
//15-------------------------------------------
public void funCleanAboveStr(){
List<Character> Stroka = new ArrayList<Character>();
//Эталон пустой строки
List<Character> PustStroka = new ArrayList<Character>();
for(int i = 0; i < this.getMatrixSizeX();i++){
PustStroka.add(new Character('F'));
}
Matrix m = new Matrix();
m.setMatrix(new ArrayList<List<Character>>());
m.funCopyMatrixToMatrix(this);
this.clearMatrix();
boolean bul = false;
for (List<Character> als1: m.getMatrix()) {
for (Character c: als1) {
Stroka.add(c);
}
if(Stroka.equals(PustStroka)){
if(bul==true){
this.copyArayListToMatrix(Stroka, Stroka.size());
Stroka.clear();
}
else{
Stroka.clear();
}
}
else{
bul=true;
this.copyArayListToMatrix(Stroka, Stroka.size());
Stroka.clear();
}//end if..else
}//end for
}//end fun
//16-------------------------------------------------
public void funContrast(){
List<Character> Bukva = new ArrayList<Character>();
List<Character> Stroka = new ArrayList<Character>(); //вектор для строки
List<Character> BukvaT = new ArrayList<Character>();
BukvaT.add(new Character('F'));
for (int y = 0; y < this.getMatrixSizeY(); y++) {
for (int x = 0; x < this.getMatrixSizeX(); x++) {
Bukva.add(this.getElement(y,x));
if(Bukva.equals(BukvaT)){
Stroka.add(new Character('F'));
}
else {
Stroka.add(new Character('0'));
}
Bukva.clear();
}
}
int temp = this.getMatrixSizeX();
this.clearMatrix();
this.copyArayListToMatrix(Stroka, temp);
}//end fun
//16a-------------------------------------------------
public void funContrast2(Matrix m){
List<Character> Bukva = new ArrayList<Character>();
List<Character> Stroka = new ArrayList<Character>(); //вектор для строки
List<Character> BukvaT = new ArrayList<Character>();
BukvaT.add(new Character('F'));
for (int y = 0; y < this.getMatrixSizeY(); y++) {
for (int x = 0; x < this.getMatrixSizeX(); x++) {
Bukva.add(this.getElement(y,x));
if(Bukva.equals(BukvaT)){
Stroka.add(new Character('F'));
}
else {
Stroka.add(new Character('0'));
}
Bukva.clear();
}
}
int temp = this.getMatrixSizeX();
System.out.println(temp);
//this.clearMatrix();
m.copyArayListToMatrix(Stroka, temp);
}//end fun
//17-------------------------------------------------
public String funKey(){
String kluch = "";
String strTemp = "";
String strTemp2 = "";
for(int y = 0; y < this.getMatrixSizeY(); y++){
for(int x = 0; x < this.getMatrixSizeX() ; x++){
strTemp = strTemp + this.getElement(y,x);
}//end for
//сравним две строки
if(strTemp.equals(strTemp2)){//если равны, то новая итерация
strTemp = "";
continue;
}
strTemp2 = strTemp;//не равны, присвоим
char temp1 = '0';
boolean flag = false;
for(int i=0;i < strTemp2.length();i++){
char temp2 = strTemp2.charAt(i);
if(flag==false){//первый символ в ключ
temp1=temp2;
kluch = kluch + temp1;
flag=true;
}
if(temp1 == temp2){
continue;
}
temp1=temp2;
kluch = kluch+temp1;
}//end for
kluch = kluch + "_";
strTemp = "";
}//end for
return kluch;
}//end fun
//18---------------------------------------------------
public void funShowArrayList(List<Character> als, Stream fout) {
for (Character c: als) {
fout.print(c);
}
fout.println("");
}//end fun
//19---------------------------------------------------
public void funShowArrayList2(List<String> als, Stream fout) {
for (String c: als) {
fout.println(c);
}
}//end fun
//19a---------------------------------------------------
public void funShowArrayList3(String s, Stream fout) {
fout.println(s);
}//end fun
//20---------------------------------------------------
public void funType(Stream to, Stream to2, Stream to3, Stream to4,
List<String> strListKeyVert, List<String> strListKeyHoriz, List<String> strListAlfabet){
String temp = "";
String kluchVer = "";
String kluchHor = "";
//Очистим букву с четырех строн
this.funTurnMatrixVH(); //повернем набок
this.funCleanAboveStr();//очистим сверху
this.funTurnMatrixV(); //перевернем
this.funCleanAboveStr();//снова очистим сверху
this.funTurnMatrixV(); //перевернем в первоначальное положение
this.funContrast();
this.funShowMatrix(to4);//выведем Б-К в файл для контроля
to4.println("");
//ключ горизонтальный
kluchHor = this.funKey();
to3.println(kluchHor);
this.funTurnMatrixVH(); //повернем набок
//ключ вертикальный
kluchVer = this.funKey();
to2.println(kluchVer);
String ssVert = "";
for(int xV = 0; xV < strListKeyVert.size() ; xV++){
String strV = strListKeyVert.get(xV);
if(kluchVer.equals(strV)){
ssVert = strListAlfabet.get(xV);
break;
}
strV = "";
}
String ssHoriz = "";
for(int xH = 0; xH < strListKeyHoriz.size() ; xH++){
String strH = strListKeyHoriz.get(xH);
if(kluchHor.equals(strH)){
ssHoriz = strListAlfabet.get(xH);
break;
}
}
if( ssVert.equals(ssHoriz)){
to.print(ssHoriz);
}
else{
to.print(ssVert);
}
}//end fun
}//end class
/////////////////////////////////////////
//////////////// MAIN ////////
/////////////////////////////////////////
class TextMatrix {
public static void main(String args[]) throws Exception {
InputStream f = new FileInputStream("bukva.bmp");
int size = 0;
size = f.available();
//System.out.println("size: " + size);
int n = size;
byte b[] = new byte[n];
if (f.read(b) != n) {
System.err.println("couldn't read " + n + " bytes.");
}
else{
//System.out.println("Ok " + n + " bytes.");
}
Vector v = new Vector(size);
for(int i =0; i<size;i++){
v.addElement(new Byte(b[i]));
}
//System.out.println("Vector size: " + v.size());
f.close(); //
//---- "KeyDataHoriz.txt" ----------------------
Stream fin = new Stream (System.in);
fin = Filer.open("KeyDataHoriz.txt");
List<String> strListKeyHoriz = new ArrayList<String>();//список для гориз ключа
String s = "";
try {
while(true){
s = fin.readLine();
if (s==null) throw new EOFException();
strListKeyHoriz.add(s);
}
}catch (EOFException e) {}
fin.close(); //
//Matrix Temp = new Matrix();
//Temp.setMatrix(new ArrayList<List<Character>>());
//Stream fout4 = new Stream ("ShowFile.txt",Stream.WRITE);
//Temp.funShowArrayList2(strListKeyHoriz,fout4);//выведем вертик ключ
//-- "KeyDataVert.txt" --------------------------
Stream fin2 = new Stream (System.in);
fin2 = Filer.open("KeyDataVert.txt");
List<String> strListKeyVert = new ArrayList<String>();//список для гориз ключа
String s2 = "";
try {
while(true){
s2 = fin2.readLine();
if (s2==null) throw new EOFException();
strListKeyVert.add(s2);
}
}catch (EOFException e) {}
fin2.close(); //
//Matrix Temp = new Matrix();
//Temp.setMatrix(new ArrayList<List<Character>>());
//Stream fout4 = new Stream ("ShowFile.txt",Stream.WRITE);
//Temp.funShowArrayList2(strListKeyVert,fout4);//выведем вертик ключ
//----- "Alfabet.txt" -----------------------------
Stream fin3 = new Stream (System.in);
fin3 = Filer.open("Alfabet.txt");
List<String> strListAlfabet = new ArrayList<String>();//список для гориз ключа
String s3 = "";
try {
while(true){
s3 = fin3.readLine();
if (s3==null) throw new EOFException();
strListAlfabet.add(s3);
}
}catch (EOFException e) {}
fin3.close(); //
//////////////////////////////////////////////////////////////
int temp = 0;
int temp_l = 0;
int temp_h = 0;
int size_file = 0; //размер исходного bmp-файла (2-й, 3-й байты)
int chislo_str = 0; //размер картинки в байтах (34-й, 35-й байты)
int size_card = 0; //количество строк в картинке (22-й, 23-й байты)
int dlina_str_1 = 0; //длина строки в выходном файле
Byte I_temp;
Byte I_temp_h;
Byte I_temp_l;
//Считаем префикс графического файла
//--------------------------------
I_temp_l =(Byte) v.elementAt(2);
temp_l = I_temp_l.intValue();
if(temp_l<0)
temp_l = 256+temp_l;
I_temp_h =(Byte) v.elementAt(3);
temp_h = I_temp_h.intValue();
if(temp_h<0)
temp_h = 256+temp_h;
temp_h = 256*temp_h;
size_file = temp_h+temp_l;
I_temp_l = (Byte)v.elementAt(22);
temp_l = I_temp_l.intValue();
if(temp_l<0)
temp_l = 256+temp_l;
I_temp_h = (Byte)v.elementAt(23);
temp_h = I_temp_h.intValue();
if(temp_h<0)
temp_h = 256+temp_h;
temp_h = 256*temp_h;
chislo_str = temp_h+temp_l;
I_temp_l = (Byte)v.elementAt(34);
temp_l = I_temp_l.intValue();
if(temp_l<0)
temp_l = 256+temp_l;
I_temp_h = (Byte)v.elementAt(35);
temp_h = I_temp_h.intValue();
if(temp_h<0)
temp_h = 256+temp_h;
temp_h = 256*temp_h;
size_card = temp_h+temp_l;
dlina_str_1 = size_card/chislo_str;
//-------------------------------------------------
//System.out.println("size_file " + size_file);
//System.out.println("chislo_str " + chislo_str);
//System.out.println("size_card " + size_card);
//System.out.println("dlina_str_1 " + dlina_str_1);
Stream to1 = new Stream ("TextOut.txt",Stream.WRITE);
Stream to2 = new Stream ("KeyDataVertOut.txt",Stream.WRITE);
Stream to3 = new Stream ("KeyDataHorizOut.txt",Stream.WRITE);
Stream to4 = new Stream ("Matrix.out",Stream.WRITE);
List al = new ArrayList(); //список для строки
//Поместим в новый список 16-ричное представление bmp-файла
//----------------------------
for(int i=54;i < size_file;i++){
I_temp =(Byte) v.elementAt(i);
temp = I_temp.intValue();
if(temp<0)
temp = 256+temp;
int iTemp = temp;
char first_ch = ' ';
char second_ch = ' ';
Filter ob = new Filter(iTemp, first_ch, second_ch);
ob.funFilter(ob);
Character ch_f = new Character(ob.first_val);
Character ch_s = new Character(ob.second_val);
al.add(ch_f);
al.add(ch_s);
}//end for
//Теперь в одномерном списке al полная картинка без префикса.
/////////////////////////////////////////////////
//////////////ПОЛНАЯ КАРТИНКА в Field ///////////
/////////////////////////////////////////////////
int dlina_str = dlina_str_1*2;
//Поместим КАРТИНКУ в МАТРИЦУ
Matrix FieldNew = new Matrix();
FieldNew.setMatrix(new ArrayList<List<Character>>());
FieldNew.copyArayListToMatrix(al, dlina_str);
//РЕВЕРСИРУЕМ КАРТИНКУ
FieldNew.funReverseMatrix();
//В двумерном векторе FieldNew полная правильная картинка
//Определяем эталон пустой строки
List charVecPustStr = new ArrayList();//список для строки
charVecPustStr.addAll(FieldNew.funPustStr());
//---------------------------------------------------
List CharStroka = new ArrayList();//список для строки
//Поместим С-К в объект Matrix
Matrix Field_Str = new Matrix();
Field_Str.setMatrix(new ArrayList<List<Character>>());
int control = 0;
int chisloStrKartinka = 0;
int chisloPustoStr = 0;
///////////////////////////////////////////////////////////////
////////////// СТРОКА-КАРТИНКА в Field_Str ///////////////////
///////////////////////////////////////////////////////////////
for (int y = 0; y < FieldNew.getMatrixSizeY(); y++) {
for (int x = 0; x < FieldNew.getMatrixSizeX(); x++) {
CharStroka.add(FieldNew.getElement(y,x));
}
if(charVecPustStr.equals(CharStroka)){//пустая строка
if(control == 2 ){
//положим пустую строку в СТРОКУ-КАРТИНКУ сверху тела
Field_Str.copyArayListToMatrix(CharStroka, dlina_str);
CharStroka.clear();
}
if(control>2){//Сейчас в Field_Str находится С-К
control=0;
to1.println("");
//В этом блоке надо обработать С-К которая находится в Field_Str
//и затем стереть ее оттуда
//ОБРАБАТЫВАЕМ ЗДЕСЬ С-К
//Поставим С-К ВЕРТИКАЛЬНО
Field_Str.funTurnMatrixVH();
/////////////////////////////////////////////////
//////////////ВЫДЕЛИМ Б-К в Field_Bukva /////////
/////////////////////////////////////////////////
//Определяем эталон пустой строки
List<Character> charVecPustStr2 = new ArrayList<Character>();//список для строки
charVecPustStr2.addAll(Field_Str.funPustStr()); //В charVecPustStr - эталон пустой строки
int chislo_str_v_bukve_cart = 0;
int chislo_str_v_bukve_cart1 = 0;
int chislo_str_v_bukve_cart2 = 0;
int int_Probel = 0;
int int_ProbelControl = 0;
String Str;
List<Character> Stroka2 = new ArrayList<Character>();//список для строки
Matrix Field_Bukva = new Matrix();
Field_Bukva.setMatrix(new ArrayList<List<Character>>());
Matrix Container1 = new Matrix(); // двумерный вектор
Container1.setMatrix(new ArrayList<List<Character>>());
Matrix Container2 = new Matrix(); // двумерный вектор
Container2.setMatrix(new ArrayList<List<Character>>());
Matrix Container3 = new Matrix(); // двумерный вектор
Container3.setMatrix(new ArrayList<List<Character>>());
boolean bul_Load = false;
boolean bul_Cont1 = false;
boolean bul_Cont2 = false;
boolean bul_Cont3 = false;
boolean Marka2 = false;
boolean Marka = false;
/////////////////////////////////////////////////////
////////////// БУКВА-КАРТИНКА в Field_Bukva ///////
/////////////////////////////////////////////////////
for (List<Character> als1: Field_Str.getMatrix()) {
for (Character c: als1) {
Stroka2.add(c);
}
if(charVecPustStr2.equals(Stroka2)){//пустая строка
//////////////////////////////////////////////////////////////////////////
//
//0
if(bul_Load == true && chislo_str_v_bukve_cart < 7){//конец С-К
Field_Bukva.clearMatrix();
bul_Load = false;
//chislo_str_v_bukve_cart = 0;
Marka = true;
}
//
//1
if(bul_Load == true && bul_Cont3 == false && bul_Cont2 == false){
Container3.funCopyMatrixToMatrix(Field_Bukva);
bul_Cont3 = true;
Field_Bukva.clearMatrix();
bul_Cont1 = false;
bul_Load = false;
//chislo_str_v_bukve_cart = 0;
Marka2=true;
Marka = true;
}
//
//2
if(bul_Load == true && bul_Cont3 == true && bul_Cont2 == false ){
if(chislo_str_v_bukve_cart > 18){//Это буква?
Container2.funCopyMatrixToMatrix(Field_Bukva);
bul_Cont2 = true;
Field_Bukva.clearMatrix();
//Положили букву в Container2
//Здесь надо выгрузить из Container3
//Затем перегрузить из Container2 в Container3
//Очистить Container2
//736
Container3.funType(to1,to2,to3,to4,strListKeyVert,strListKeyHoriz,strListAlfabet);// Обработать Container3
Container3.clearMatrix();
bul_Cont3 = false;
Container3.funCopyMatrixToMatrix(Container2);
bul_Cont3 = true;
Container2.clearMatrix();
bul_Cont2 = false;
bul_Load = false;
//chislo_str_v_bukve_cart = 0;
Marka = true;
}
else{//Это буква Ы
Container3.funCopyMatrixToMatrix(Field_Bukva);
bul_Cont3 = true;
Field_Bukva.clearMatrix();
Container2.clearMatrix();
//Здесь надо выгрузить из Container3
Container3.funType(to1,to2,to3,to4,strListKeyVert,strListKeyHoriz,strListAlfabet);// Обработать Container3
Container3.clearMatrix();
bul_Load = false;
//chislo_str_v_bukve_cart = 0;
Marka = true;
}
}
//
//3
if(bul_Load == true && bul_Cont3 == true && bul_Cont2 == true){
if(chislo_str_v_bukve_cart > 18){//Это буква?
//699
Container3.funType(to1,to2,to3,to4,strListKeyVert,
strListKeyHoriz,strListAlfabet);// Обработать Container3
Container3.clearMatrix();
bul_Cont3 = false;
Container3.funCopyMatrixToMatrix(Container2);
bul_Cont3 = true;
Container2.clearMatrix();
bul_Cont2 = false;
Container2.funCopyMatrixToMatrix(Field_Bukva);
bul_Cont2 = true;
Field_Bukva.clearMatrix();
bul_Cont1 = false;
bul_Load = false;
//chislo_str_v_bukve_cart = 0;
Marka = true;
}
else{
Container2.funCopyMatrixToMatrix(Field_Bukva);
bul_Cont2 = true;
Field_Bukva.clearMatrix();
bul_Cont1 = false;
Container3.funType(to1,to2,to3,to4,strListKeyVert,
strListKeyHoriz,strListAlfabet);// Обработать Container3
Container3.clearMatrix();
bul_Cont3 = false;
//729
Container2.funType(to1,to2,to3,to4,strListKeyVert,
strListKeyHoriz,strListAlfabet);// Обработать Container3
Container2.clearMatrix();
bul_Cont2 = false;
bul_Load = false;
//chislo_str_v_bukve_cart = 0;
Marka = true;
}
}
//4
int_Probel++;
if(Marka2==true && int_Probel==19){
Marka2=false;
//743
Container3.funType(to1,to2,to3,to4,strListKeyVert,
strListKeyHoriz,strListAlfabet);// Обработать Container3
Container3.clearMatrix();
bul_Cont3 = false;
}
if(Marka==true){
chislo_str_v_bukve_cart2 = chislo_str_v_bukve_cart1;
chislo_str_v_bukve_cart1 = chislo_str_v_bukve_cart;
if(chislo_str_v_bukve_cart1 > 67 && chislo_str_v_bukve_cart2 > 67){
to1.print(" ");
}
Marka=false;
}
if(int_ProbelControl==66 ){
chislo_str_v_bukve_cart2 = chislo_str_v_bukve_cart1;
chislo_str_v_bukve_cart1 = chislo_str_v_bukve_cart;
to1.print(" ");
//if(chislo_str_v_bukve_cart1 == 60
//&& chislo_str_v_bukve_cart2 == 60){to1.print(" ");}
//Marka=false;
int_ProbelControl=0;
}
if(int_Probel%72==0){
to1.print(" ");
}
chislo_str_v_bukve_cart = 0;
Stroka2.clear();
/////////////////////////////////////////////////////////////////////////////////
}
else{//Строка не пуста. Загружаем короткую строку (вертикальная С-К)
if(int_Probel>0)
int_ProbelControl = int_Probel;
int_Probel=0;
chislo_str_v_bukve_cart++;
bul_Load = true;
Field_Bukva.copyArayListToMatrix(Stroka2, Stroka2.size());
Stroka2.clear();
}//end if..else пустая/не пустая строка
}//end for КОНЕЦ ЦИКЛ ОБРАБОТКИ БУКВ
Field_Str.clearMatrix();//очистка Field_Str здесь обязательна
}//end if(control>2)
CharStroka.clear();
}//////////////////////////////////////////////
else{//строка не пуста
control++;
//Добавить строку в Field_StrNew
Field_Str.copyArayListToMatrix(CharStroka, dlina_str);
CharStroka.clear();
}//end if..else строка пуста/не пуста
//-------------------------------------------------------------------------
}//end for
to1.close();
to2.close();
to3.close();
to4.close();
}
}
public int getMatrixSizeX() {
int index=0;
for (List als1: this.getMatrix()) {
for (Character c: als1) {
index++;
}
break;
}
return index;
}
Программа находится:
D:\Ency_Языки_Программир\Ency_Java\Распознавание образов\Программы01_07\Программы07\Prog23>
Назад |
Начало урока |
Вверх |
Вперед
Содержание