Я зыке Python для получения объекта родительского типа, в функцию super необходимо передать класс и экземпляр объекта дочернего класса. Пример класса на языке Python представлен ниже[7].

#создание класса

class A:

a = 3

#функция, которая выводит значение a

def getA(self):

print(self.a)

#создадим дочерний класс

class B(A):

#переопределим функцию getA

def getA(self):

print(“New Function”)

super(B, self).getA()

Данный пример демонстрирует объектно-ориентированное программирование на языке Python. Также в данном языке возможно множественное наследование как в языке C++.

5.1 Разработка модуля распознавания

Программный код функции search_top_ugly представлен ниже.

#функция поиска верхних клеток

def search_top_ugly(self):

b = False #якорь для выхода из двойного цикла

for i in range(0, self.height): #пробегаем по всем элементам масива map_bin

if b:

break

start = 0 #инициализируем начало строки

beetween = 0

dist = 0

count = 0

self.ugols_top = [] #массив координат верхних клеток

for j in range(0, self.width):

if self.map_bin[i][j] == self.map_bin[i][beetween]: #если цвет пикселей совпадает, то идём дальше

pass

else:

time_dist = j - beetween

if time_dist >= dist - int(dist/5) and time_dist <= dist + int(dist/4): #проверяем расстояние между пикселями

count += 1

beetween = j

self.ugols_top.append([j,i],)

else:

count = 0

start = beetween

dist = j - beetween

beetween = j

self.ugols_top = []

self.ugols_top.append([j,i],)

if count == 7:

self.distance_top = dist

b = True

break

Программный код функции search_bottom_ugly совпадает с кодом рассмотренной функции. Отличие только в том, что массивы данных разные и массив map_bin перевернут.

Для нахождения остальных координат клеток разработана функция parsing_mest. Код функции представлен ниже.

#поиск координат неизвестных клеток

def parsing_mest(self):

avg_width = self.ugols_top[3][0] #четвёртую клетку будем считать центральной

for i in range(0,8):

if self.ugols_top[i][0] == self.ugols_bottom[i][0]:

self.tgs.append(-1) #тангентс угла в 0 градусов возьмём равному -1

self.razn.append(0) #расстояние между нижними клетками

else:

width = self.ugols_top[i][0] - self.ugols_bottom[i][0] #длина нижнего катета треугольника

height = abs(self.ugols_bottom[i][1] - self.ugols_top[i][1]) #длина бокового катета треугольника

self.tgs.append(float(abs(width))/float(height)) #тангентс угла

self.razn.append(width) #расстояние между нижними клетками

count = 0

time = self.ugols_top[0][1]

#пробегаем по каждому пикселю в столбце

for i in range(self.ugols_top[0][1], self.height - 1):

#если цвет пикселя не меняется идём дальше

if self.map_bin[i][avg_width] == self.map_bin[i + 1][avg_width]:

pass

else:

#при изменении цвета пикселя, вычисляем среднюю координату Y

count += 1

avg_i = int(i - (i - time)/2)

time = i #значение предыдущей высоты пикселя

for i1 in range(0,len(self.razn)):

if self.tgs[i1] == -1:

self.map_shashki.append([self.ugols_top[i1][0],avg_i]) #добавляем координаты к массив координат шашек map_shashki

else:

if self.razn[i1] < 0:

#вычисление координат на основании геометрических законов

self.map_shashki.append([int(self.ugols_top[i1][0] + self.tgs[i1]*abs(avg_i - self.ugols_top[0][1] )),avg_i] )

else:

#вычисление координат на основании геометрических законов

self.map_shashki.append([self.ugols_top[i1][0] - self.tgs[i1]*abs(avg_i - self.ugols_top[0][1]),avg_i ])

if count == 8: #при количестве клеток в столбце равному восьми, возвращаем положительный результат

return True

if count < 7:

return False

Для получения фотографии с камеры используется стандартный бокс Take Picture.

import time

class MyClass(GeneratedClass):

def __init__(self):

GeneratedClass.__init__(self, False)

self.resolutionMap = {

'160 x 120': 0,

'320 x 240': 1,

'640 x 480': 2,

'1280 x 960': 3

}

self.cameraMap = {

'Top': 0,

'Bottom': 1

}

self.recordFolder = "/home/nao/recordings/cameras/"

def onLoad(self):

self.bIsRunning = False

try:

self.photoCapture = ALProxy( "ALPhotoCapture" )

except Exception as e:

self.photoCapture = None

self.logger.error(e)

def onUnload(self):

pass

def onInput_onStart(self):

if( self.bIsRunning ):

return

self.bIsRunning = True

resolution = self.resolutionMap[self.getParameter("Resolution")]

cameraID = self.cameraMap[self.getParameter("Camera")]

fileName = self.getParameter("File Name")

if self.photoCapture:

self.photoCapture.setResolution(resolution)

self.photoCapture.setCameraID(cameraID)

self.photoCapture.setPictureFormat("jpg")

self.photoCapture.takePicture( self.recordFolder, fileName )

self.bIsRunning = False

self.onStopped()

5.2 Разработка модуля обработки данных

Основной функцией модуля обработки данных является функция получения массива хода из сравнения предыдущего состояния поля и текущего.

### преобразование массивов состояний поля в ход

def get_hod(chesses, after_hod):

#если размер не совпадает возвращаем ложь

if len(chesses) != len(after_hod):

return False

hod = False

what = False

#пробегаем по каждой паре координат текущего состояния

for ah in after_hod:

if ah in chesses:

del chesses[chesses.index(ah)] #если есть в предыдущем состоянии удаляем элемент из массива

else: #если нету, то считаем финальной позицией хода

if not hod:

hod = ah

else:

return False

#при размере массива после обработки больше единице возвращаем ложь

if len(chesses) > 1:

return False

#при уданом завершении возвращаем массив хода

return [chesses[0], hod]

К функциям обработки также можно отнести функцию преобразования данных get_chess_coords.

def get_chess_coords(cords):

letters = [u"A",u"B",u"C",u"D",u"E",u"F",u"G",u"H"]

return letters[coords[1]] + str(8 - coords[0])

Функция используется для преобразования числовых координат в координаты, понятные человеку.

5.3 Разработка модуля игры

Модуль игры содержит в себе несколько важных функций.

Программный код функции для проверки правильности хода protect_move представлен ниже.

#проверка правильности хода в игре

def protect_move(self, move):

#проверка наличия шашки в месте старта хода

start = self.get_shashka(move[0], move[2])

#проверка наличия шашки в месте финиша

finish = self.get_shashka(move[1])

if not start or finish:

raise Exception

#проверка на диагональный ход

if abs(move[0][0] - move[1][0]) != abs(move[0][1] - move[1][1]):

raise Exception

#проверка не выходит ли из поля

if move[1][0] > 8 or move[1][0] < 1:

raise Exception

#проверка на правильность хода

if not start.damka:

#если длина хода больше одного шага, то проверяем на количество шашек

if abs(move[0][1] - move[1][1]) == 2:

#получить промежуточную шашку

sh = self.get_beetween_shashka(move[0], move[1])

if start.type_player == sh.type_player:

raise Exception

else:

return

elif abs(move[0][1] - move[1][1]) == 1:

pass

else:

raise Exception

if start.type_player == 'player':

if move[1][1] <= move[0][1]:

raise Exception

else:

if move[1][1] >= move[0][1]:

raise Exception

else:

if abs(move[0][1] - move[1][1]) > 0:

beetween_chess = self.get_beetwen_chess(move[0], move[1])

res = []

print beetween_chess

for cc in self.chess_circle:

if cc.coords() in beetween_chess:

if cc.type_player == move[2]:

raise Exception

else:

res.append(cc)

if len(res) > 1:

raise Exception

else:

raise Exception

return True

Для выполнения всей логики хода игрока используется функция move, которая в самом начале выполняет проверку на правильность хода.

#выполнение хода

def move(self, move):

self.protect_move(move)

shashka1 = self.get_shashka([move[0][0], move[0][1]], move[2])

zafuk = False

for ch in self.chess_circle:

if ch.type_player == move[2]:

if self.i_can_del(ch):

zafuk = ch

if not shashka1.damka:

now_damka = True

if self.size_move(move) == 1:

shashka1.set_coords([move[1][0], move[1][1]])

if shashka1.type_player == 'player' and shashka1.y == 8:

now_damka = False

shashka1.damka = True

if shashka1.type_player == 'pc' and shashka1.y == 1:

now_damka = False

shashka1.damka = True

if zafuk:

return [3,{'shashka':zafuk}]

else:

return [1,{}]

if self.size_move(move) == 2:

beetween_shashka = self.get_beetween_shashka(move[0], move[1])

#взять шашку

self.del_shashka(beetween_shashka)

shashka1.set_coords([move[1][0], move[1][1]])

if shashka1.type_player == 'player' and shashka1.y == 8:

now_damka = False

shashka1.damka = True

if shashka1.type_player == 'pc' and shashka1.y == 1:

now_damka = False

shashka1.damka = True

can_del = self.i_can_del(shashka1)

if can_del:

self.last_place = shashka1

if can_del & now_damka:

return [2,{'last':self.last_place}]

else:

return [1, {}]

else:

beetween_chess = self.get_beetwen_chess(move[0], move[1])

count = 0

b = False

for n in self.chess_circle:

if n.coords() in beetween_chess:

del self.chess_circle[count]

self.last_place = move[1]

b = True

break

count += 1

s = self.get_shashka(move[0])

s.set_coords(move[1])

can_del = self.i_can_del(s)

if b:

self.last_place = shashka1

return [2,{'last':self.last_place}]

else:

if zafuk:

return [1, {'shashka':zafuk}]

return [1,{}]

Для проверки шашки на возможность взять шашку противника разработана функция i_can_del.

#проверка могу ли взять шашку противника

def i_can_del(self, shashka):

global POS_AND_COORDS

global ii

result = False

if shashka.type_player == 'pc':

vrag = 'player'

else:

vrag = 'pc'

if not shashka.damka:

for p in POS_AND_COORDS.keys():

#для обычной шашки

sosed = ii.get_sosed(shashka, p, vrag)

if sosed:

finish = ii.get_sosed(sosed, p)

print sosed.coords()

if finish:

print finish.coords()

in_field = shashka.in_field([sosed.coords()[0]+POS_AND_COORDS[p][0], sosed.coords()[1]+POS_AND_COORDS[p][1]])

if finish or not in_field:

continue

else:

return True

else:

time_pos = shashka.coords()

for item in POS_AND_COORDS.items():

time_pos = shashka.coords()

sh = shashka

while True:

time_pos = [time_pos[0] + item[1][0], time_pos[1]+ item[1][1]]

if shashka.in_field(time_pos):

sh = ii.get_shashka(time_pos, vrag)

sh_i = ii.get_shashka(time_pos, shashka.type_player)

if sh_i:

break

if sh:

sh_sosed = ii.get_sosed(sh, item[0])

if sh_sosed:

break

else:

return True

else:

continue

else:

break

return False

5.4 Разработка модуля выбора хода

Правила выбора хода основываются на стратегии игры рассмотренной ранее. Рассмотрим функции в порядке их использования, исходя из стратегии и правил игры.

В первую очередь необходимо выполнить атаку. Поиск пешек способных атаковать и получение хода выполняется в функции smart_attack.

#проверить возможность атаки противника и атаковать)

def smart_attack(self, sh = None):

time_finish_del = False

if sh:

time_shashki = [sh,]

else:

time_shashki = self.shashki

time_shashki.sort(key = lambda x: 0 if x.damka else 1)

for shashka in time_shashki:

print shashka.damka

if shashka.type_player == 'pc':

for p in self.POS_AND_COORDS.keys():

#для обычной шашки

if not shashka.damka:

sosed = self.get_sosed(shashka, p, 'player')

if sosed:

finish = self.get_sosed(sosed, p)

if finish:

continue

else:

#проверим возможно ли взять мою шашку, если ДА, то валим оттуда)))

#создаём виртуальную шашку и присваимваем ей координаты нашего finish

if not self.get_sosed_coords(sosed, p):

continue

finish = Shashka(self.get_sosed_coords(sosed, p)[0],self.get_sosed_coords(sosed, p)[1],'pc')

time_x = shashka.x

time_y = shashka.y

shashka.set_coords(finish.coords())

status_del = self.protect_del_me(shashka)

if not status_del:

shashka.set_coords([time_x, time_y])

shashka.podstrahovka = 0

return [[shashka.coords()[0], shashka.coords()[1]], [finish.coords()[0], finish.coords()[1]]]

else:

shashka.set_coords([time_x, time_y])

time_finish_del = [[shashka.coords()[0], shashka.coords()[1]], [finish.coords()[0], finish.coords()[1]]]

else:

time_pos = shashka.coords()

for item in self.POS_AND_COORDS.items():

time_pos = shashka.coords()

sh = shashka

while True:

time_pos = [time_pos[0] + item[1][0], time_pos[1]+ item[1][1]]

print time_pos

if shashka.in_field(time_pos):

sh = self.get_shashka(time_pos, 'player')

sh_pc = self.get_shashka(time_pos, 'pc')

if sh:

sh_sosed = self.get_sosed(sh, item[0])

if sh_sosed:

break

else:

sh_coords = self.get_sosed_coords(sh, item[0])

if sh_coords:

del_coords = [sh.x, sh.y, sh.damka]

sh.x = 100

sh.y = 100

sh.damka = False

time_coords = sh_coords

while True:

if time_coords:

time_sh = Shashka(time_coords[0], time_coords[1], 'pc')

if not self.protect_del_me(time_sh):

sh.x = del_coords[0]

sh.y = del_coords[1]

sh.damka = del_coords[2]

return [[shashka.x, shashka.y],[time_coords[0], time_coords[1]]]

else:

time_finish_del = [[shashka.x, shashka.y],[sh_coords[0], sh_coords[1]]]

time_coords = self.get_sosed_coords(time_sh, item[0])

if self.get_shashka(time_coords, 'pc') or self.get_shashka(time_coords, 'player'):

break

else:

break

sh.x = del_coords[0]

sh.y = del_coords[1]

sh.damka = del_coords[2]

else:

break

else:

if sh_pc:

break

else:

break

return time_finish_del

Функция smart_attack выполняется в первую очередь, так как при невыполнении одного из существующих ходов на удаление шашки противника шашке игрока присваивается статус “фука” и производится удаление шашки с игрального поля. Вторым этапом является выполнение функции protect_del_shashki.

#проверка пешек на возможность их взять

def protect_del_shashki(self):

for shashka in self.shashki:

if shashka.type_player == 'pc':

pos_del = self.protect_del_me(shashka)

if pos_del:

simple_move = self.search_simple_move(shashka)

if simple_move:

return simple_move

hod = self.podstrahovka(shashka, pos_del)

if hod:

return hod

return False

В рассмотренной функции используется функция podstrahovka. Для страховки шашки, на которую возможна атака. Данная функция применяется в том случае, если шашка не может уйти от удара.

#страховка другой шашкой

def podstrahovka(self,shashka, p):

time_podstr = False

pos = self.parallel_pos(p)

for shashka1 in self.shashki:

if shashka1.type_player == 'pc':

coords = self.get_sosed_coords(shashka, pos)

if coords and shashka1.y != 8:

for p1 in ['lu', 'ru']:

if self.get_sosed_coords(shashka1, p1) == coords:

time_x = shashka1.x

time_y = shashka1.y

shashka1.set_coords(coords)

if not self.protect_del_me(shashka1):

shashka1.set_coords([time_x, time_y])

shashka1.podstrahovka = 0

return [[shashka1.x, shashka1.y], [coords[0], coords[1]]]

shashka1.set_coords([time_x, time_y])

else:

continue

return False

6. Экспериментальное тестирование и отладка програмных модулей

После разработки программного комплекса данный продукт, перед вводом в эксплуатацию, должен быть протестирован.

Отладка программного средства - это процесс отслеживания и исправления ошибок в программе при её выполнении. Тестирование программы - это выполнения процесса программы с определёнными входными данными при известном выходном результате. Такие данные называются тестовыми. Процесс отладки состоит из трёх этапов. Три этапа представлены на рисунке 6.1

Рисунок 6.1 - Схема этапов отладки программы

6.1 Тестирование программного комплекса

Тестирование разработанного продукта проходило в несколько этапов. На первом этапе тестирования исследуется модуль распознавания.

Шахматная доска располагается перед роботом. Положение доски должно быть прямое, для точного распознавания. Пример расположении доски перед роботом представлен на рисунке 6.2



Рисунок 6.2 - Пример положения доски перед роботом.

Процесс распознавания запускался несколько раз, до получения точного и положительного результата. Положительным результатом считается точное определение координат клеток доски.

Модуль игры, как и модуль принятия решений тестировался на персональном компьютере. Для более легкого тестирования программы при помощи библиотеки Pillow создано Desktop приложение. Данное программное обеспечение позволяет пользователю играть в шашки на обычном персональном компьютере. В модуль игры передаётся ход, преобразованный из координат мыши, места клика. Один клик - выбор пеши, второй клик - место перемещения.

Модуль ИИ, получая информацию о шашках на шахматном поле совершает ход. Программа для тестирования отображает поле после каждого хода, сделанного игроком или модулем принятия решений.

6.2 Поиск ошибок

В процессе тестирования были обнаружены некоторые ошибки. Ошибки являются как программными, которые исправляются редактированием программного кода, так и логическими, которые исправляются незначительным изменением внешних условий.

В процессе распознавания обнаружены следующие ошибки:

1) неверное распознавание последней строки шахматной доски;

2) неверное распознавание всего поля;

3) некорректная бинаризация изображения.

В процессе тестирования игры:

1) возможность выполнить любой ход после взятия шашки противника;

2) неверное получение объекта шашки противника, к которой применяется правило “фука”.

При тестировании завершённого продукта были выявлены ошибки:

1) неверное преобразование числовых координат на доске в логический формат, используемый для передачи информации о совершаемых ходах;

2) строка, которая используется для передачи информации, имеет значение None;

3) ошибка сохранения логов;

4) возврат неправильного статуса игры.

6.3 Редактирование и исправление ошибок

Во время выполнения распознавания возможно неверное определение положения последней строки. Последним этапом алгоритма определения координат клеток является нахождение координат не угловых ячеек. Указатель, перемещающийся по пикселям ведёт поиск смены цветов областей. Последняя область, если клетка является белой, оканчивается черной границей шахматной доски. С двух сторон чёрной линии белый цвет, поэтому при получении изображения с камеры линия засветляется и программа не может её распознать. Также в процессе распознавания может возникнуть ситуация с неверным определением положения всего поля. Суть алгоритма нахождения клеток шахматной доски заключается в том, чтобы найти чередование белых и тёмных областей с одинаковым интервалом в количестве не менее восьми элементов. Только при идеальном прямом расположении доски и правильном положении робота интервал будет одинаковым, следовательно, для увеличения вероятности распознавания необходимо вводится погрешность интервала, т.е. допустимое значение интервала, в сравнении с первым интервалом. Чем больше погрешность, тем меньше точность, но больше вероятность распознавания доски.

При преобразовании изображения могут возникнуть проблемы с бинаризацией, что затруднит дальнейшую работу. В результате падения солнечных лучей чёрные клетки при бинаризации могут иметь белый цвет. Это приводит к получению ошибочных исходных данных.

Возможность выполнить любой ход после взятия шашки противника является багом алгоритма модуля игры. При взятии шашки противника модуль игры разрешает пользователю выполнить ход любой шашкой. По официальным правилам игры, продолжение хода можно производить только той же шашкой, которой было выполнено взятие. Неверное получение объекта шашки противника, к которой применяется правило “фука”. При выполнении правила фука система возвращает неверный объект, к которому применяется это правило. Во время получения хода игрока возможно неверное преобразование числовых координат на доске в логический формат, используемый для передачи информации о совершаемых ходах. При преобразовании полученного объекта хода от модуля принятия решений, данный объект передаётся в функцию преобразования данных в логический формат. Результат функции был неверным. Это связано с ошибочным определением положений номера столбца в ходе и номером строки. По завершению выполнения и обработки хода роботом строка, которая используется для передачи информации, имеет значение None. При получении результирующей строки конкатенировались строки юникода и стандартной кодировки. В результате данного конфликта переменной say_text присваивается значение None. Ошибка сохранения логов. В процессе игры модуль игры сохраняет все ходы, совершённые роботом и сохраняет их в файл logs.txt. При сохранении выдаёт ошибку с сообщением о том, что файл не найден. Ошибка невернойдиректории. Пример логов представлен на рисунке 6.3.



Рисунок 6.3 - Пример файла логов.

На финальном этапе выполнения хода возникали проблемы с получением неверного статуса игры. В процессе игры система возвращает неверный статус. После того как ИИ выполнит взятие шашки с возможным продолжением система оповещает пользователя о том, что он может продолжать ход. Данная ошибка связана с использованием одной переменной для сохранения результата. После хода игрока результат возвращается в переменную result. После этого конструкцией if сравнивается статус и выполняется определённое действие. Ход бота после статуса игры равному единице также сохраняется в переменной result. После выполнения сравнивается статус хода робота.

Данные ошибки могут иметь несколько решений. Выбирается самое оптимальное из них. Отладочная информация представлена в таблице 6.1

Таблица 6.1 - Таблица ошибок

Ошибка	Способы исправления
Неверное распознавание последней строки шахматной доски.	1) увеличение толщины линии границы шахматной доски. 2) увеличение разрешение фотографии
	Оптимальный первый способ
Неверное распознавание всего поля.	1) уменьшение погрешности time_dist >= dist - int(dist/6) and time_dist <= dist + int(dist/6)
Некорректная бинаризация изображения	(S > (((255 + self.factor) // 2) * 3)) Изменение значение factor = 100
Возможность выполнить любой ход после взятия шашки противника	Возврат в статусе объекта шашки, которой может выполниться продолжение.
Неверное получение объекта шашки противника, к которой применяется правило “фука”	Возврат в статусе шашки, к которой применяется правило “фука”
Неверное преобразование числовых координат на доске в логический формат, используемый для передачи информации о совершаемых ходах	def get_chess_coords(coords): letters = [u"A",u"B",u"C",u"D",u"E",u"F",u"G",u"H"] return letters[coords[1]] + str(8 - coords[0])
Строка, которая используется для передачи информации, имеет значение None	Перевод всех строк в стандартную кодировку.
Ошибка сохранения логов	Прописать правильный путь для сохранения логов f = open(`/home/nao/logs/logs.txt', `a')
Возврат неправильного статуса игры	Сохранение статуса игры при ходе робота в переменную result1

После исправления найденных данных ошибок система полностью функционирует. Но для того, чтобы выявить все ошибки, требуется большое время тестирования или введение альфа-версии продукта в эксплуатацию.

7. Оценка качества разработанного продукта

Качество программного продукта -- это сочетание характеристик, способных удовлетворить всем требования пользователя. Все показатели качества программного продукта не могут иметь максимальные значения, так как они являются противоречивыми. Улучшение одних приводят к ухудшению других качеств. Для удовлетворительной оценки достаточно того, чтобы разрабатываемое ПО полностью функционировало и было пригодно для использования.

Оценки качества можно разделить на несколько видов:

1) единичный показатель качества - характеризует одно из свойств программы;

2) комплексный показатель качества - содержит в себе оценку нескольких свойств программы;

3) определяющий показатель качества - приоритетный показатель, по которому оценивается заключительная оценка продукта;

4) базовый показатель качества - значение показателя, которое является эталоном при сравнении показателей качества;

5) регламентирующий показатель качества - устанавливается нормативным документом, спецификацией или техническим заданием.

Одной из оценок качества ПО является оценка показателя эффективности. Данный показатель характеризует способность продукта эффективно выполнять поставленные перед ним задачи.

Показатели эффективности делятся на несколько видов и представлены в виде иерархической структуры. Структура представлена на рисунке 7.1

Функциональные показатели работоспособности - дают оценку способности программного продукта преобразовывать исходные данные в необходимый результат.



Рисунок 7.1 - Иерархическая структура показателей эффективности

Рассмотрим данные показатели более подробно:

1) показатель назначения - оценивает соответствие разработанного продукта описанным в техническом задании функциям;

2) точность - оценивается разницей между полученным результатом и истинным;

3) надежность - способность объекта сохранять состояние работоспособности и выполнять поставленные задачи на протяжении определённого промежутка времени;

4) устойчивость к искажающим воздействиям - программный комплекс можно назвать устойчивым, если, не смотря на внешнее и внутреннее воздействие продолжает выполнять функции и поставленные задачи, а входные данные преобразуются во входные без искажений или с незначительными искажениями;

5) рациональность - выполнение программы не приводит к использованию лишних и ресурсов. Такую программу можно назвать оптимизированной;

6) время ответа - данный показатель характеризует скорость работы программного комплекса и является значением времени преобразования данных.

Эксплуатационные показатели - оценивают способность программного комплекса выполнять задачи, связанные с планированием и функционированием за разные промежутки времени. Рассмотри показатели:

1) удобство усвоения - является оценкой и результатом работы подробной и полной документации;

2) простота обслуживания - данное свойство программы обеспечивается лучшей автоматизацией выполнения функций;

3) приспособленность к анализу полученных данных - реализуется за счёт написания модуля или дополнительной программы для анализа полученных данных путём сравнения с истинным значением или путём анализа статистика предыдущих результатов;

4) модифицируемость - оценивается возможность модификации программы, с учётом уже потраченных и свободных ресурсов системы.

Срок службы - продолжительность времени эксплуатации программного средства, начиная от выпуска программы или возвращения продукта в эксплуатацию после ремонта, до предельного состояния.

Универсальность - способность программного комплекса работать не только в системе, на которой тестировался и разрабатывался продукт, но и в другой с другими техническими характеристиками.

Время ввода в эксплантацию - изменяется в широком диапазоне в зависимости от сложности программы и её способности к решению задач.

Алгоритм оценки содержит в себе несколько пунктов, описанных ниже:

1) определение набора показателей;

2) описание сущности показателей;

3) определить экспертную оценку (щ_i) для каждого показателя;

4) определение конкретной экспериментальной оценки (r_i) для показателей;

5) вычисление качества программного комплекса (Q) по формуле;

6) отображение полученных данных в виде гистограммы.

Для определения веса показателя, необходимо соблюдать закон, при котором сумма весов показателей равна единице. Закон выражен формулой



где n - число показателей;

- вес показателя.

При определении экспериментальных оценок качества ПО, необходимо воспользоваться таблицей интервалов оценок. Интервалы оценок и их описания представлены в таблице 7.1

Таблица 7.1 - Описание оценок программного средства

Значение оценки	Описание
0 - 0,49	Свойство присутствует, но качество плохое
0,5 - 0,9	Свойство в программном средстве присутствует, обладает удовлетворительным качеством
0,91 - 1	Свойство в программном средстве присутствует, обладает высоким качеством

Оценки разрабатываемого программного комплекса представлены в таблице 7.2

Таблица 7.2 - Оценки показателей качества программного комплекса

Показатели качества	Сущность показателя	Экспертная оценка(вес оценки)	Экспериментальная оценка
Надежность	Свойство программы непрерывно сохранять работоспособность	0.15	0,95
Эффективность	Характеризует эффективность использования ПС	0.05	0,7
Время ответа	Характеризует то, насколько быстро программа отвечает на воздействие	0.2	0,85
Универсальность	Свойство программы работать не только в той системе, в которой она должна работать, но и в любой другой	0,1	0,99
Точность	Характеризует степень точности, с которой программа выполняет расчеты	0.2	0,91
Показатель назначения	Характеризует способность программы выполнять назначенные функции	0.15	0,88
Удобство усвоения	Характеризует степень усваиваемости программы пользователем	0,05	0,98
Время введения в эксплуатацию	Характеризует время, через которое программа будет введена в эксплуатацию	0,05	0,99

Качество разработанного программного комплекса вычисляется по формуле, представленной ниже:

где r_i - экспериментальная оценка показателя;

щ_i - вес показателя качества;

n - число показателей.

В результате вычислений было получено следующее значение показателя качества ПО.

На основе экспертных оценок построим гистограмму распределения оценок. Гистограмма представлена на рисунке 7.2



Рисунок 7.2 - Гистограмма распределения оценок по интервалам

Заключение

В результате процесса разработки программного комплекса поставленная задача была полностью реализована.

Были исследованы модели реализации интеллектуальных игр в системе человек-робот. Основной задачей являлась исследование способов реализации модуля принятия решений. Робот способен принимать решения на основе расчётов всех возможных ходов с выбором оптимальных и стратегий, на которые запрограммирована система.

Выбрана и проанализирована архитектура, на которой строился программный комплекс. В качестве машины был выбран антропоморфный робот Nao Evolution V5. Разработки велись на языке Python в среде программирования Choreographe с подключением модулей по работе с изображениями Pillow, а также с используем библиотеки NAOqi.

Для реализации интеллектуальной игры человек-робот были разработаны определённые структуры данных. Такая оптимизация необходима для ускорения работы программы и сокращения использованных ресурсов. Для работы с библиотекой NAOqi использовалась документация с официального сайта. Логика игра разрабатывалась на основе правил игры “русские шашки” с полем восемь на восемь клеток.

Основной задачей при написании программы являлась разработка алгоритмов функций. Были реализованы функции распознавания, функции игры и функции модуля принятия решений. После разработки алгоритмы подвергались оптимизации в целях ускорения программы. Также для понимания алгоритмов были разработаны блок-схемы основных функций.

В процессе разработки программных модулей и реализации алгоритмов, представленных в предыдущей части, использовался текстовый редактор Sublime и среда разработки Choreographe.

Экспертное тестирование проводилось несколькими независимым программистами и таксировщиками. В процессе тестирования ошибок не обнаружено. Система работает исправно. Исключительные ситуации такие как, нехватка шашек на доске или неправильно-выполненный ход полностью прослеживается программой, а робот оповещает игрока об ошибке.

На финальном этапе разработки проводилось качество разработанного ПО. В результате вычислений и исследования значение оценки качества составило . Гистограмма распределения оценок, говорит о приоритете оценок лучшего качества и отсутствии удовлетворительных оценок.

За период разработки был получен опыт по программированию антропоморфных роботов из серии Nao Evolution компании Aldebaran Technologies. Улучшены навыки написания программ на языке Python. Были получены новые знания по работе с изображениями и их обработке.

Система интеллектуальной игры “человек-робот” имеет открытый исходный код и полностью модифицируема, что даёт возможность для дальнейших улучшений и обновлений программного комплекса.

Основная польза от разработанного проекта - это получение опыта в программировании роботов и исследования науки о принятии решений. В наше время роботы и искусственный интеллект, задачей которого является делать рациональный и осмысленный выбор в разных областях жизни, занимают предстоящую позицию, поэтому уже сейчас необходимо готовить специалистов по обеспечению роботов.

Машины активно внедряются в нашу жизнь и уже сейчас несут огромную пользу человечеству. К сожалению, пока искусственный интеллект находится на уровне нейронных сетей, что и является началом и основанием для мыслящего и обучаемого робота.

Роботы способные размышлять и анализировать при учёте их вычислительной мощности будут двигать прогресс с невероятной скоростью и приведут человечество на новый этап жизни.

Список использованных источников

1) ИНТУИТ Интеллектуальные системы [Электронный ресурс]: лекция - Режим доступа: http://www.intuit.ru/studies/courses/46/46/lecture/1368

2) Петросян, Л. А. Теория игр: учебное пособие для университетов / Л. А. Петросян, Н.А. Зенкевич, Е.А Семина. - Москва: Книжный дом «Университет», 1998 - 304 с.

3) Об ИИ в интеллектуальных играх [Электронный ресурс]: статья на Habr - Режим доступа: https://habrahabr.ru/post/143552/

4) NAO Software 1.14.5 documentation [Электронный реурс]: офиц. сайт - Режим доступа: http://doc.aldebaran.com/1-14/index.html

5) Softbank Robotics | Humanoid robotics [Электронный ресурс]: офиц. сайт - Режим доступа: https://www.ald.softbankrobotics.com/en

6) Python - официальный сайт [Электронный ресурс]: офиц. сайт - Режим доступа: https://www.python.org

7) Лутц, М. Изучаем Python. 4-е издание: книга / М. Лутц. - Москва: Символ-Плюс, 2011. - 300 с.

8) Лутц, М. Python. Карманный справочник: книга / М. Лутц. - Москва: Вильямс, 2016. - 320 с.

9) Играемся с изображениями в Python [Электронный ресурс]: статья на habr - Режим доступа: https://habrahabr.ru/post/163663/

10) Как я шашки писал [Электронный ресурс]: статья на Habr - Режим доступа: https://habrahabr.ru/post/227911/

11) Pillow -Documentation [Электронный ресурс]: офиц. сайт - Режим доступа: http://pillow.readthedocs.io/en/4.1.x/

12) The ImageDraw Module [Электронный ресурс]: офиц. сайт - Режим доступа: http://www.effbot.org/imagingbook/imagedraw.htm

Приложение

(рекомендуемое)

Руководство пользователя

Для использования данного программного средства, необходимо иметь разработанный проект choreographe на компакт-диске, флэш-накопителе или на самом ПК.

Запуск разработанного программного комплекса начинается со старта среды разработки Choreographe. Окно ПО представлено на рисунке П.1.

Рисунок П.1 - Среда разработки Choreographe.

Для включения робота Nao Evolution V5 нажать один раз на кнопку, расположенную на груди робота. Система начнёт загрузку. Об этом будут сигнализировать световые индикаторы на корпусе.

После того как робот загрузиться будет произведён характерный звуковой сигнал. Следующим этапом настройки является подключение робота к ПК

Произвести соединение программы и робота по средствам Wi-Fi или Ethernet соединение. Для соединения робота необходимо, нажать на кнопку, скриншот которой представлен на рисунке П.2.



Рисунок П.2 - Кнопка соединения с роботом.

Если вы планируете подключить робот через канал связи Wi-Fi, то сначала необходимо подключить робота через Ethernet соединение для ввода пароля от Wi-Fi. При следующих сеансах робот автоматически будет подключаться к Wi-Fi сети.

Меняем позицию робота в положение сидя. Перед роботом размещаем шахматную доску. Пример положения робота представлен на рисунке П.3.

Рисунок П.3 - Пример игровой позиции робота.

Шахматная доска должна располагаться прямо перед роботом, чтобы верхняя и нижняя граница игры были параллельны и не искажались при получении снимка.

После этого импортируем проект и запускаем его, нажав на кнопку, представленную на рисунке П.4.

Рисунок П.4 - Кнопка запуска импортированного проекта.

Робот начёт распознавание и оповестит вас о том, что он готов играть. После этого можно расставлять шашки на игральной доске.

Для начала игры, необходимо выполнить ход и дать команду роботу Nao “Твой ход”. После этой команды, в зависимости от статуса игры, робот выполнить действие и оповестит вас об этом.

Если робот выполнит ход, надо совершить перемещение его шашки и убрать взятые им шашки с доски. Если данное действие не будет выполнено, робот оповестит вас о том, что выполнен неверный ход.

Игра завершается при условии, что у одного из игроков не останется шашек на поле.

Размещено на Allbest.ru