def selection(self, best_selection=True, destruction=False):
individual_indices = np.random.choice(range(len(self.population)),
size=4,
replace=False)
fitness_values = [
self.population[ind].score for ind in individual_indices
]
if best_selection:
worst1 = individual_indices[fitness_values.index(
max(fitness_values[0], fitness_values[1]))]
worst2 = individual_indices[fitness_values.index(
max(fitness_values[2], fitness_values[3]))]
if destruction and (len(
np.where(
(self.population[worst1].schedule -
self.population[worst2].schedule) == 0)[0]) / float(
self.population[worst1].schedule.size)) > 0.75:
self.population[worst1] = Timetable(self.data,
self.compactness_ini)
self.population[worst2] = Timetable(self.data,
self.compactness_ini)
return (individual_indices[fitness_values.index(
min(fitness_values[0], fitness_values[1]))],
individual_indices[fitness_values.index(
min(fitness_values[2], fitness_values[3]))])
else:
return (individual_indices[fitness_values.index(
max(fitness_values[0], fitness_values[1]))],
individual_indices[fitness_values.index(
max(fitness_values[2], fitness_values[3]))])
def set_changes():
def get_day_specialized(day):
if len(day) == 0:
return -1
day = day[0].upper() + day[1:-1].lower()
for i in range(len(config.day_names)):
if config.day_names[i][:-1] == day:
return i
return 7
def set_changes_sub(lesson_ch, cl_ind):
if cl_ind == -1:
return
tt_t.changes.has_changes[cl_ind] = True
tmp = [sub_ch[:sub_ch.find("</p>")] for sub_ch in lesson_ch.split("<p>") if len(sub_ch) >= 2]
tt_t.changes.changes.append(TClasses.Changes.ChangesCell(cl_ind, tmp))
tt_t.changes.ch_ind[cl_ind] = len(tt_t.changes.changes) - 1
changes_raw = get_changes_raw()
tt_t.changes = TClasses.Changes(len(tt_t.classes))
temp = changes_raw[changes_raw.find("НА ") + len("НА "):]
tt_t.changes.change_day = get_day_specialized(temp[:temp.find(' ') - 1])
changes_raw = changes_raw[changes_raw.find("</h3>") + len("</h3>"):].replace(" —", "-")
for les_ch in [s for s in changes_raw.split("<h6>") if len(s) != 0]:
if "</h6>" in les_ch:
set_changes_sub(les_ch[les_ch.find("<p>"):],
Timetable.bin_search_crutch(tt_t.classes, les_ch[:les_ch.index('</h6>')]))
else:
print("Error occupied while setting changes:", les_ch)
def random_timetable(teachers, audiences, subjects, specialities):
current_timetable = []
for speciality in specialities:
days_in_week = []
for day in day_of_week:
lessons_in_day = []
num_of_lessons = random.choice(range(1, 7))
for numb in range(num_of_lessons):
num_of_lesson = random.choice(range(1, 7))
type_of_lesson = random.choice(l_or_p)
subject = random.choice(subjects)
teacher = random.choice(teachers)
audience = random.choice(audiences)
if type_of_lesson == 'practice':
group = random.choice([1, 2])
lesson = Lesson(num_of_lesson, type_of_lesson, subject,
teacher, audience, group)
else:
lesson = Lesson(num_of_lesson, type_of_lesson, subject,
teacher, audience)
lessons_in_day.append(lesson)
current_day = Day(day, lessons_in_day)
days_in_week.append(current_day)
current_week = Week(speciality, days_in_week)
current_timetable.append(current_week)
timetable = Timetable(current_timetable)
return timetable
def set_class_lesson_sub(lesson_data, group, cl_ind):
if ' ' not in lesson_data:
if lesson_data == "Физкультура":
room = defaults[0]
else:
room = defaults[1]
subject = lesson_data
else:
arr = lesson_data.split(" ")
room = Timetable.bin_search_crutch(tt_t.rooms, arr[1], False)
if room == -1:
room = defaults[2]
subject = arr[0]
return TClasses.TTDay.TTLesson.TTLClass.TTCell(cl_ind, room, defaults[3], subject, group)
def __init__(self, *args, **kwargs):
super().__init__(task_each_event=True, *args, **kwargs)
config_path = "timetable_config.json"
assert os.path.exists(
config_path), f"Config file {config_path} not found."
with open(config_path, "r") as timetable_file:
timetables_json = json.load(timetable_file)
self._admins = timetables_json["admins"]
self._timetables = {
timetable.pop("peer_id"): Timetable(timetable)
for timetable in timetables_json["timetables"]
}
self._timetable_work_flg = False
def t_update(timetable, full=True, fast=False):
try:
tt_t = Timetable(True)
def get_token():
m_token = IO.InternetIO.get("http://lyceum.urfu.ru/n/?p=tmtbl", fast=fast)
if m_token is None:
raise Exception("No internet connection")
m_token = m_token[m_token.find("<script>var tmToken=\"") + len("<script>var tmToken=\""):]
return m_token[:m_token.find("\"</script>")]
token = get_token()
def set_base():
def extract_by_str(string, sort_by_ind=False):
ans = []
a = string.split("</option>")[:-1]
for ss in a:
d_i = ss[ss.find("value='") + len("value='"):]
ans.append(TClass(d_i[: d_i.find("'")], ss[ss.rfind(">") + 1:], sort_by_ind))
ans.sort()
return ans
page = IO.InternetIO.get("http://lyceum.urfu.ru/n/?p=tmtbl", fast=fast)
if page is None:
raise Exception("No internet connection")
arr = page[page.find("<div class=\"tmtbl\""): page.find("<script>var tmToken=")].split("tmtbl")
tt_t.classes = extract_by_str(arr[3])
tt_t.teachers = extract_by_str(arr[4])
tt_t.rooms = extract_by_str(arr[5])
tt_t.rooms += [TClass('F', "Каф. ин. яз"), TClass('Hz', 'ACCESS DENIED')]
tt_t.rooms.sort()
tt_t.days = extract_by_str(arr[6], True)
tt_t.set_tt_base(len(tt_t.classes))
set_base()
defaults = [Timetable.bin_search_crutch(tt_t.rooms, 'S', False),
Timetable.bin_search_crutch(tt_t.rooms, 'F', False),
Timetable.bin_search_crutch(tt_t.rooms, 'Hz', False),
Timetable.bin_search_crutch(tt_t.teachers, "Сотрудник И. С.")]
def set_class(class_ind, day_ind):
def set_class_lesson(class_ind_int, d_ind, les_data):
def set_class_lesson_sub(lesson_data, group, cl_ind):
if ' ' not in lesson_data:
if lesson_data == "Физкультура":
room = defaults[0]
else:
room = defaults[1]
subject = lesson_data
else:
arr = lesson_data.split(" ")
room = Timetable.bin_search_crutch(tt_t.rooms, arr[1], False)
if room == -1:
room = defaults[2]
subject = arr[0]
return TClasses.TTDay.TTLesson.TTLClass.TTCell(cl_ind, room, defaults[3], subject, group)
if les_data.rfind("<td>") == -1:
return
les_num = int(les_data[len("<td>"):len("<td>") + 1]) - 1
if les_data.find("width") == -1:
temp = set_class_lesson_sub(les_data[les_data.index("<td colspan=2>") + len("<td colspan=2>"):
les_data.index("</td></tr>")], 0, class_ind_int)
tt_t.all[d_ind].day[les_num].lesson[class_ind_int].group.append(temp)
else:
aaa = les_data.split("<td width=47%>")[1:]
for i in range(len(aaa)):
l_data = aaa[i][:aaa[i].index("</td>")]
if "×" not in l_data:
temp = set_class_lesson_sub(l_data, i + 1, class_ind_int)
tt_t.all[d_ind].day[les_num].lesson[class_ind_int].group.append(temp)
ans = IO.InternetIO.get(config.base_url + token + "&tmrType=0&tmrClass=" + tt_t.classes[class_ind].ind +
"&tmrTeach=0&tmrRoom=0&tmrDay=" + str(day_ind + 1), fast=fast)
if ans is None:
raise Exception("No internet connection")
if ans == "Err\n":
raise Exception("update failed", class_ind, day_ind, ans)
for les in ans[ans.index("<tr>") + len("<tr>"):].split("<tr>"):
set_class_lesson(class_ind, day_ind, les)
def set_teacher(teacher_ind):
def set_teacher_day(day_info, teach_ind):
def set_teacher_day_sub(l_data, t_ind, d_ind):
c = l_data[l_data.rfind("</td>") - 1]
if c == ';':
return
group = int(c) if c.isdecimal() else 0
l_data = l_data[:l_data.rfind("<td>") - len("</td>")]
if '<td>' not in l_data:
return
les_num = int(l_data[len("<td>"): len("<td>") + 1]) - 1
m_arr = l_data[l_data.find("</td>") + len("</td><td>"):].split("</td><td>")
subject = m_arr[0]
for cl_ in range(len(tt_t.classes)):
if m_arr[1] == tt_t.classes[cl_].name:
class_ind = cl_
break
else:
class_ind = -1 # TODO: add binary search
group_i = 1 if group == 2 and len(tt_t.all[d_ind].day[les_num].lesson[class_ind].group) != 1 else 0
if d_ind < 0 or les_num < 0 or group_i < 0 or d_ind >= len(tt_t.all) or \
les_num >= len(tt_t.all[d_ind].day) or \
class_ind >= len(tt_t.all[d_ind].day[les_num].lesson) or \
group_i >= len(tt_t.all[d_ind].day[les_num].lesson[class_ind].group):
# От создателя if'а с 64 условиями в 1 строке
print("Хьюстон, у нас проблемы", d_ind, les_num, group_i, t_ind)
t_cell = tt_t.all[d_ind].day[les_num].lesson[class_ind].group[group_i]
t_cell.teacher_ind = t_ind
if subject not in t_cell.subject:
t_cell.subject.append(subject)
tt_t.all[d_ind].day[les_num].lesson[class_ind].group[group_i] = t_cell
arr = day_info.split("<tr>")
day_ind = timetable.bin_search_crutch(tt_t.days, arr[0][:arr[0].find("</h3>")], True)
for arr_sub in arr[1:]:
set_teacher_day_sub(arr_sub, teach_ind, day_ind)
ans = IO.InternetIO.get(config.base_url + token + "&tmrType=1&tmrClass=&tmrTeach=" +
tt_t.teachers[teacher_ind].ind + "&tmrRoom=0&tmrDay=0", fast=fast)
if ans is None:
raise Exception("No internet connection")
if ans == "Err\n":
raise Exception("Fail while updating teachers\n", teacher_ind, ans)
if "Уроков не найдено" in ans:
return
ans = ans[ans.index("<h3>") + len("<h3>"): ans.index("<details><summary>")]
for sub_s in ans.split("<h3>"):
set_teacher_day(sub_s, teacher_ind)
def get_changes_raw():
ans = IO.InternetIO.get(config.base_url + token + "&tmrType=1&tmrClass=&tmrTeach=" + tt_t.teachers[0].ind +
"&tmrRoom=0&tmrDay=0", fast=fast)
if ans is None:
raise Exception("No internet connection")
if ans == "Err\n":
raise Exception("Fail while updating teachers\n", 0, ans)
return ans[ans.find("</summary>") + len("</summary>"):]
def set_changes():
def get_day_specialized(day):
if len(day) == 0:
return -1
day = day[0].upper() + day[1:-1].lower()
for i in range(len(config.day_names)):
if config.day_names[i][:-1] == day:
return i
return 7
def set_changes_sub(lesson_ch, cl_ind):
if cl_ind == -1:
return
tt_t.changes.has_changes[cl_ind] = True
tmp = [sub_ch[:sub_ch.find("</p>")] for sub_ch in lesson_ch.split("<p>") if len(sub_ch) >= 2]
tt_t.changes.changes.append(TClasses.Changes.ChangesCell(cl_ind, tmp))
tt_t.changes.ch_ind[cl_ind] = len(tt_t.changes.changes) - 1
changes_raw = get_changes_raw()
tt_t.changes = TClasses.Changes(len(tt_t.classes))
temp = changes_raw[changes_raw.find("НА ") + len("НА "):]
tt_t.changes.change_day = get_day_specialized(temp[:temp.find(' ') - 1])
changes_raw = changes_raw[changes_raw.find("</h3>") + len("</h3>"):].replace(" —", "-")
for les_ch in [s for s in changes_raw.split("<h6>") if len(s) != 0]:
if "</h6>" in les_ch:
set_changes_sub(les_ch[les_ch.find("<p>"):],
Timetable.bin_search_crutch(tt_t.classes, les_ch[:les_ch.index('</h6>')]))
else:
print("Error occupied while setting changes:", les_ch)
if full:
for cl in range(len(tt_t.classes)):
for d in range(len(tt_t.days)):
set_class(cl, d)
for t in range(len(tt_t.teachers)):
set_teacher(t)
tt_t.free_rooms.set(tt_t)
set_changes()
timetable.changes = tt_t.changes
if full:
timetable.free_rooms = tt_t.free_rooms
timetable.all = tt_t.all
timetable.t_n = [t.name for t in tt_t.teachers]
timetable.c_n = [c.name for c in tt_t.classes]
timetable.d_n = [d.name for d in tt_t.days]
timetable.r_n = [r.name for r in tt_t.rooms]
timetable.r_i = [r.ind for r in tt_t.rooms]
timetable.trap = timetable.r_i.index('Hz')
return True
except BaseException as e:
logging.error(e, exc_info=True)
return False
def parse(self, input):
words = input.lower().split(' ')
if words[0] == 'help':
print(self.__doc__)
elif words[0] == 'exit':
self.memory_handler.save_all_data()
sys.exit()
elif words[0] == 'add':
if words[1] == 'driver':
new_driver = Driver()
name = self.get_user_input('driver name')
new_driver.set_name(name)
surname = self.get_user_input('driver surname')
new_driver.set_surname(surname)
self.memory_handler.save_driver(new_driver)
elif words[1] == 'car':
new_car = Car()
manufacturer = self.get_user_input('car manufacturer')
new_car.set_manufacturer(manufacturer)
model = self.get_user_input('car model')
new_car.set_model(model)
color = self.get_user_input('car color')
new_car.set_color(color)
plate = self.get_user_input('car license plate')
new_car.set_plate(plate)
body = self.get_user_input('car body type', required=False)
new_car.set_body(body)
fuel = self.get_user_input('car fuel type', required=False)
new_car.set_fuel(fuel)
card = self.get_user_input('car fuel card number', required=False)
new_car.set_card(card)
pin = self.get_user_input('car fuel card pin number', required=False)
new_car.set_pin(pin)
self.memory_handler.save_car(new_car)
elif words[1] == 'timetable':
new_timetable = Timetable()
owner = self.get_user_input('timetable owner')
owner = owner.split()
if len(owner) == 2:
driver = self.memory_handler.get_driver(owner[0], owner[1])
else:
driver = self.memory_handler.get_driver(owner[0])
# TODO: what if there are multiple drivers returned?
if not driver:
print('Could not find driver!')
return
for day in range(7):
start_time = self.get_user_input('beginning of shift for day ' + str(day), required=False)
if start_time:
end_time = self.get_user_input('end of shift')
new_timetable.set_preferences(day, (int(start_time), int(end_time)))
driver[0].set_timetable(new_timetable)
elif words[0] == 'get':
if words[1] == 'car':
plate = self.get_user_input('car license plate')
car = self.memory_handler.get_car_by_plate(plate)
print(car)
elif words[1] == 'driver':
surname = self.get_user_input('driver surname and name')
surname = surname.split()
if len(surname) == 2:
driver = self.memory_handler.get_driver(surname[0], surname[1])
else:
driver = self.memory_handler.get_driver(surname[0])
print(driver)
elif words[1] == 'cars':
print(self.memory_handler.get_cars())
elif words[1] == 'drivers':
print(self.memory_handler.get_drivers())
elif words[1] == 'solution':
solve(self.memory_handler)
cars = self.memory_handler.get_cars()
for car in cars:
print(car.timetable)
else:
print('Could not understand input')
def dlgOKPressed(self):
# 環境設定画面のＯＫボタンを押したとき
self.dlg.setVisible(False)
layers = self.iface.legendInterface().layers()
lTimeTable = layers[self.dlg.cmbTimetable.currentIndex()-1]
lTransit = layers[self.dlg.cmbTransit.currentIndex()-1]
if not lTimeTable.isValid():
self.myprint ("Layer failed to load!")
return
if not lTransit.isValid():
self.myprint ("Layer failed to load!")
return
self.timetable = None
from Timetable import Timetable
self.timetable = Timetable(self)
from CATDB import CATDB
self.cat_db = CATDB(self)
# 時刻表の設定
for f in lTimeTable.getFeatures ():
# self.myprint("add_timetable %d, %d, %f" % (
# f[self.dlg.cmbRouteid.currentText()], \
# f[self.dlg.cmbCat.currentText()], \
# f[self.dlg.cmbTime.currentText()] ))
catName = ""
if self.dlg.cmbCatName.currentIndex() <> 0:
catName = f[self.dlg.cmbCatName.currentText()]
routeName = ""
if self.dlg.cmbRouteName.currentIndex() <> 0:
routeName = f[self.dlg.cmbRouteName.currentText()]
ptn = re.compile('(\d+):(\d+)')
m = ptn.match(f[self.dlg.cmbTime.currentText()])
if m:
tmp_time = (float(m.group(1))*60+float(m.group(2))) /1440.0
# 深夜１２時～２時までは２４時から２６時に変換
if tmp_time < 0.083333: tmp_time = tmp_time+1
else:
QMessageBox.information(None, "DEBUG:", "set time correctly")
self.timetable.add_timetable( \
f[self.dlg.cmbRouteid.currentText()], \
f[self.dlg.cmbCat.currentText()], \
tmp_time, \
routeName)
self.cat_db.add_cat(f[self.dlg.cmbCat.currentText()], \
f.geometry().asPoint().x(), \
f.geometry().asPoint().y(), \
catName)
# 乗り換え表の設定
for f in lTransit.getFeatures ():
ptn = re.compile('(\d+):(\d+)')
m = ptn.match(f[self.dlg.cmbTime2.currentText()])
if m:
tmp_time = (float(m.group(1))*60+float(m.group(2))) /1440.0
else:
QMessageBox.information(None, "DEBUG:", "set time correctly")
self.timetable.set_transit( \
f[self.dlg.cmbFromcat.currentText()], \
f[self.dlg.cmbTocat.currentText()], \
tmp_time)
self.myprint(QCoreApplication.translate('code', "Timetable, Transit table set")+u"\n")
self.i_cmbTimetable = self.dlg.cmbTimetable.currentIndex()
self.i_cmbRouteid = self.dlg.cmbRouteid.currentIndex()
self.i_cmbCat = self.dlg.cmbCat.currentIndex()
self.i_cmbTime = self.dlg.cmbTime.currentIndex()
self.i_cmbCatName = self.dlg.cmbCatName.currentIndex()
self.i_cmbRouteName = self.dlg.cmbRouteName.currentIndex()
self.i_cmbTransit = self.dlg.cmbTransit.currentIndex()
self.i_cmbFromcat = self.dlg.cmbFromcat.currentIndex()
self.i_cmbTocat = self.dlg.cmbTocat.currentIndex()
self.i_cmbTime2 = self.dlg.cmbTime2.currentIndex()
self.i_cmbOrigin = self.dlg.cmbOrigin.currentIndex()
self.i_cmbIdOrig = self.dlg.cmbIdOrig.currentIndex()
self.i_cmbDestination = self.dlg.cmbDestination.currentIndex()
self.i_cmbIdDest = self.dlg.cmbIdDest.currentIndex()
class PublicTransportFinder:
def __init__(self, iface):
self.iface = iface
self.lock = threading.Lock()
self.calc = None
self.cat_db = None
self.timetable = None
self.thread = None
self.worker = None
def initGui(self):
# initialize locale
locale = QSettings().value('locale/userLocale')
if not locale: locale = 'en'
else: locale = locale[0:2]
locale_path = os.path.join(
os.path.dirname(__file__),
'i18n',
'PublicTransportFinder_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
path = os.path.dirname( os.path.abspath( __file__ ) )
self.dock = uic.loadUi( os.path.join( path, "Dock.ui" ) )
self.dlg = uic.loadUi( os.path.join( path, "Dialog.ui" ) )
self.log = uic.loadUi( os.path.join( path, "Log.ui" ) )
self.iface.addDockWidget( Qt.LeftDockWidgetArea, self.dock )
self.clickTool = QgsMapToolEmitPoint(self.iface.mapCanvas())
QObject.connect(self.dock.btnConf,SIGNAL("clicked()"),self.dockConfPressed)
QObject.connect(self.dlg.btnOK,SIGNAL("clicked()"),self.dlgOKPressed)
QObject.connect(self.dock.btnCalc,SIGNAL("clicked()"),self.dockCalcPressed)
QObject.connect(self.dock.btnOrigin,SIGNAL("clicked()"),self.dockOriginClicked)
QObject.connect(self.dock.btnDestination,SIGNAL("clicked()"),self.dockDestinationClicked)
# QObject.connect(self.iface.mapCanvas(), SIGNAL('layersChanged()'), self.update_layers)
QObject.connect(self.dlg.cmbTimetable,SIGNAL("currentIndexChanged(int)"),self.cmbTimetableChanged)
QObject.connect(self.dlg.cmbTransit,SIGNAL("currentIndexChanged(int)"),self.cmbTransitChanged)
QObject.connect(self.dlg.cmbOrigin,SIGNAL("currentIndexChanged(int)"),self.cmbOriginChanged)
QObject.connect(self.dlg.cmbDestination,SIGNAL("currentIndexChanged(int)"),self.cmbDestinationChanged)
self.i_cmbTimetable = 0
self.i_cmbRouteid = 0
self.i_cmbCat = 0
self.i_cmbTime = 0
self.i_cmbCatName = 0
self.i_cmbRouteName = 0
self.i_cmbTransit = 0
self.i_cmbFromcat = 0
self.i_cmbTocat = 0
self.i_cmbTime2 = 0
self.i_cmbOrigin = 0
self.i_cmbIdOrig = 0
self.i_cmbDestination = 0
self.i_cmbIdDest = 0
# add to plugins toolbar
try:
self.action = QAction("Toggle visibility", self.iface.mainWindow())
self.action.triggered.connect(self.toggleDock)
self.iface.addPluginToMenu("&PublicTransportFinder", self.action)
except:
pass # OK for testing
def unload(self):
"""unload the plugin"""
self.iface.removeDockWidget(self.dock)
self.iface.removePluginMenu("PublicTransportFinder", self.action)
def toggleDock(self):
self.dock.setVisible(not self.dock.isVisible())
# self.update_layers()
def dockOriginClicked(self):
QObject.connect(self.clickTool, \
SIGNAL("canvasClicked(const QgsPoint &, Qt::MouseButton)"), \
self.handleMouseDownOrig)
self.iface.mapCanvas().setMapTool(self.clickTool)
def dockDestinationClicked(self):
QObject.connect(self.clickTool, \
SIGNAL("canvasClicked(const QgsPoint &, Qt::MouseButton)"), \
self.handleMouseDownDest)
self.iface.mapCanvas().setMapTool(self.clickTool)
def handleMouseDownOrig(self, point, button):
self.dock.qleOrigin.clear()
self.dock.qleOrigin.insert( str(point.x()) + "," +str(point.y()) )
QObject.disconnect(self.clickTool, \
SIGNAL("canvasClicked(const QgsPoint &, Qt::MouseButton)"), \
self.handleMouseDownOrig)
self.iface.mapCanvas().unsetMapTool(self.clickTool)
def handleMouseDownDest(self, point, button):
self.dock.qleDestination.clear()
self.dock.qleDestination.insert( str(point.x()) + "," +str(point.y()) )
QObject.disconnect(self.clickTool, \
SIGNAL("canvasClicked(const QgsPoint &, Qt::MouseButton)"), \
self.handleMouseDownDest)
self.iface.mapCanvas().unsetMapTool(self.clickTool)
def dockConfPressed(self):
self.dlg.setVisible(True)
self.dlg.raise_()
self.dlg.cmbTimetable.clear()
self.dlg.cmbTransit.clear()
self.dlg.cmbOrigin.clear()
self.dlg.cmbDestination.clear()
layers = self.iface.legendInterface().layers()
layer_list = [QCoreApplication.translate('code', "Select an Item...")]
for layer in layers:
# if isinstance(layer, QgsVectorLayer) or \
# isinstance(layer, QgsRasterLayer):
layer_list.append(layer.name())
self.dlg.cmbTimetable.addItems(layer_list)
self.dlg.cmbTransit.addItems(layer_list)
layer_list = [QCoreApplication.translate('code', "One by One")]
for layer in layers: layer_list.append(layer.name())
self.dlg.cmbOrigin.addItems(layer_list)
self.dlg.cmbDestination.addItems(layer_list)
if self.i_cmbTimetable == 0 and u"Timetable" in layer_list:
self.i_cmbTimetable = layer_list.index(u"Timetable")
if self.i_cmbTransit==0 and u"Transit" in layer_list:
self.i_cmbTransit=layer_list.index(u"Transit")
if self.i_cmbOrigin == 0 and u"Origin" in layer_list:
self.i_cmbOrigin = layer_list.index(u"Origin")
if self.i_cmbDestination == 0 and u"Destination" in layer_list:
self.i_cmbDestination = layer_list.index(u"Destination")
self.dlg.cmbTimetable.setCurrentIndex(self.i_cmbTimetable)
self.dlg.cmbRouteid.setCurrentIndex(self.i_cmbRouteid)
self.dlg.cmbCat.setCurrentIndex(self.i_cmbCat)
self.dlg.cmbTime.setCurrentIndex(self.i_cmbTime)
self.dlg.cmbCatName.setCurrentIndex(self.i_cmbCatName)
self.dlg.cmbRouteName.setCurrentIndex(self.i_cmbRouteName)
self.dlg.cmbTransit.setCurrentIndex(self.i_cmbTransit)
self.dlg.cmbFromcat.setCurrentIndex(self.i_cmbFromcat)
self.dlg.cmbTocat.setCurrentIndex(self.i_cmbTocat)
self.dlg.cmbTime2.setCurrentIndex(self.i_cmbTime2)
self.dlg.cmbOrigin.setCurrentIndex(self.i_cmbOrigin)
self.dlg.cmbIdOrig.setCurrentIndex(self.i_cmbIdOrig)
self.dlg.cmbDestination.setCurrentIndex(self.i_cmbDestination)
self.dlg.cmbIdDest.setCurrentIndex(self.i_cmbIdDest)
def cmbTimetableChanged(self):
if self.dlg.cmbTimetable.currentIndex() == 0:
return
layers = self.iface.legendInterface().layers()
lTimeTable = layers[self.dlg.cmbTimetable.currentIndex()-1]
self.dlg.cmbRouteid.clear()
self.dlg.cmbCat.clear()
self.dlg.cmbTime.clear()
self.dlg.cmbCatName.clear()
self.dlg.cmbRouteName.clear()
flist = [QCoreApplication.translate('code', "Select an Item...")]
for f in lTimeTable.pendingFields():
flist.append(f.name())
self.dlg.cmbRouteid.addItems(flist)
self.dlg.cmbCat.addItems(flist)
self.dlg.cmbTime.addItems(flist)
self.dlg.cmbCatName.addItems(flist)
self.dlg.cmbRouteName.addItems(flist)
if self.i_cmbRouteid == 0 and u"route_id" in flist:
self.i_cmbRouteid = flist.index(u"route_id")
if self.i_cmbCat == 0 and u"cat" in flist:
self.i_cmbCat = flist.index(u"cat")
if self.i_cmbTime == 0 and u"time" in flist:
self.i_cmbTime = flist.index(u"time")
if self.i_cmbCatName == 0 and u"cat_name" in flist:
self.i_cmbCatName = flist.index(u"cat_name")
if self.i_cmbRouteName == 0 and u"route_name" in flist:
self.i_cmbRouteName = flist.index(u"route_name")
def cmbTransitChanged(self):
if self.dlg.cmbTransit.currentIndex() == 0:
return
layers = self.iface.legendInterface().layers()
lTransit = layers[self.dlg.cmbTransit.currentIndex()-1]
self.dlg.cmbFromcat.clear()
self.dlg.cmbTocat.clear()
self.dlg.cmbTime2.clear()
flist = [QCoreApplication.translate('code', "Select an Item...")]
for f in lTransit.pendingFields():
flist.append(f.name())
self.dlg.cmbFromcat.addItems(flist)
self.dlg.cmbTocat.addItems(flist)
self.dlg.cmbTime2.addItems(flist)
if self.i_cmbFromcat == 0 and u"from_cat" in flist:
self.i_cmbFromcat = flist.index(u"from_cat")
if self.i_cmbTocat == 0 and u"to_cat" in flist:
self.i_cmbTocat = flist.index(u"to_cat")
if self.i_cmbTime2 == 0 and u"time" in flist:
self.i_cmbTime2 = flist.index(u"time")
def cmbOriginChanged(self):
if self.dlg.cmbOrigin.currentIndex() == 0:
self.dlg.cmbIdOrig.clear()
return
layers = self.iface.legendInterface().layers()
lOrigin = layers[self.dlg.cmbOrigin.currentIndex()-1]
self.dlg.cmbIdOrig.clear()
flist = [QCoreApplication.translate('code', "Select an Item...")]
if lOrigin <> None:
for f in lOrigin.pendingFields():
flist.append(f.name())
self.dlg.cmbIdOrig.addItems(flist)
if self.i_cmbIdOrig == 0 and u"id" in flist:
self.i_cmbIdOrig = flist.index(u"id")
def cmbDestinationChanged(self):
if self.dlg.cmbDestination.currentIndex() == 0:
self.dlg.cmbIdDest.clear()
return
layers = self.iface.legendInterface().layers()
lDestination = layers[self.dlg.cmbDestination.currentIndex()-1]
self.dlg.cmbIdDest.clear()
flist = [QCoreApplication.translate('code', "Select an Item...")]
for f in lDestination.pendingFields():
flist.append(f.name())
self.dlg.cmbIdDest.addItems(flist)
if self.i_cmbIdDest == 0 and u"id" in flist:
self.i_cmbIdDest = flist.index(u"id")
def dlgOKPressed(self):
# 環境設定画面のＯＫボタンを押したとき
self.dlg.setVisible(False)
layers = self.iface.legendInterface().layers()
lTimeTable = layers[self.dlg.cmbTimetable.currentIndex()-1]
lTransit = layers[self.dlg.cmbTransit.currentIndex()-1]
if not lTimeTable.isValid():
self.myprint ("Layer failed to load!")
return
if not lTransit.isValid():
self.myprint ("Layer failed to load!")
return
self.timetable = None
from Timetable import Timetable
self.timetable = Timetable(self)
from CATDB import CATDB
self.cat_db = CATDB(self)
# 時刻表の設定
for f in lTimeTable.getFeatures ():
# self.myprint("add_timetable %d, %d, %f" % (
# f[self.dlg.cmbRouteid.currentText()], \
# f[self.dlg.cmbCat.currentText()], \
# f[self.dlg.cmbTime.currentText()] ))
catName = ""
if self.dlg.cmbCatName.currentIndex() <> 0:
catName = f[self.dlg.cmbCatName.currentText()]
routeName = ""
if self.dlg.cmbRouteName.currentIndex() <> 0:
routeName = f[self.dlg.cmbRouteName.currentText()]
ptn = re.compile('(\d+):(\d+)')
m = ptn.match(f[self.dlg.cmbTime.currentText()])
if m:
tmp_time = (float(m.group(1))*60+float(m.group(2))) /1440.0
# 深夜１２時～２時までは２４時から２６時に変換
if tmp_time < 0.083333: tmp_time = tmp_time+1
else:
QMessageBox.information(None, "DEBUG:", "set time correctly")
self.timetable.add_timetable( \
f[self.dlg.cmbRouteid.currentText()], \
f[self.dlg.cmbCat.currentText()], \
tmp_time, \
routeName)
self.cat_db.add_cat(f[self.dlg.cmbCat.currentText()], \
f.geometry().asPoint().x(), \
f.geometry().asPoint().y(), \
catName)
# 乗り換え表の設定
for f in lTransit.getFeatures ():
ptn = re.compile('(\d+):(\d+)')
m = ptn.match(f[self.dlg.cmbTime2.currentText()])
if m:
tmp_time = (float(m.group(1))*60+float(m.group(2))) /1440.0
else:
QMessageBox.information(None, "DEBUG:", "set time correctly")
self.timetable.set_transit( \
f[self.dlg.cmbFromcat.currentText()], \
f[self.dlg.cmbTocat.currentText()], \
tmp_time)
self.myprint(QCoreApplication.translate('code', "Timetable, Transit table set")+u"\n")
self.i_cmbTimetable = self.dlg.cmbTimetable.currentIndex()
self.i_cmbRouteid = self.dlg.cmbRouteid.currentIndex()
self.i_cmbCat = self.dlg.cmbCat.currentIndex()
self.i_cmbTime = self.dlg.cmbTime.currentIndex()
self.i_cmbCatName = self.dlg.cmbCatName.currentIndex()
self.i_cmbRouteName = self.dlg.cmbRouteName.currentIndex()
self.i_cmbTransit = self.dlg.cmbTransit.currentIndex()
self.i_cmbFromcat = self.dlg.cmbFromcat.currentIndex()
self.i_cmbTocat = self.dlg.cmbTocat.currentIndex()
self.i_cmbTime2 = self.dlg.cmbTime2.currentIndex()
self.i_cmbOrigin = self.dlg.cmbOrigin.currentIndex()
self.i_cmbIdOrig = self.dlg.cmbIdOrig.currentIndex()
self.i_cmbDestination = self.dlg.cmbDestination.currentIndex()
self.i_cmbIdDest = self.dlg.cmbIdDest.currentIndex()
def dockCalcPressed(self):
self.log.setVisible(True)
self.log.raise_()
if self.timetable == None:
self.dockConfPressed()
return
orig_list = []
dest_list = []
if self.dlg.cmbOrigin.currentIndex() <> 0:
layers = self.iface.legendInterface().layers()
lOrigin = layers[self.dlg.cmbOrigin.currentIndex()-1]
if not lOrigin.isValid():
self.myprint ("Layer failed to load!")
return
for f in lOrigin.getFeatures():
orig_list.append((f[self.dlg.cmbIdOrig.currentText()],f.geometry().asPoint().x(), f.geometry().asPoint().y()))
else:
ptn = re.compile('([+-]?\d+\.?\d*) *?, *?([+-]?\d+\.?\d*)')
m = ptn.match(self.dock.qleOrigin.text())
if m:
orig_list.append((0, float(m.group(1)),float(m.group(2))))
else:
QMessageBox.information(None, "DEBUG:", "set origin correctly")
if self.dlg.cmbDestination.currentIndex() <> 0:
layers = self.iface.legendInterface().layers()
lDestination = layers[self.dlg.cmbDestination.currentIndex()-1]
if not lDestination.isValid():
self.myprint ("Layer failed to load!")
return
for f in lDestination.getFeatures():
dest_list.append((f[self.dlg.cmbIdDest.currentText()],f.geometry().asPoint().x(), f.geometry().asPoint().y()))
else:
ptn = re.compile('([+-]?\d+\.?\d*) *?, *?([+-]?\d+\.?\d*)')
m = ptn.match(self.dock.qleDestination.text())
if m:
dest_list.append((0, float(m.group(1)),float(m.group(2))))
else:
QMessageBox.information(None, "DEBUG:", "set destination correctly")
ptn = re.compile('(\d+):(\d+)')
m = ptn.match(self.dock.qleStartTime.text())
if m:
start_time = (float(m.group(1))*60+float(m.group(2))) /1440.0
else:
QMessageBox.information(None, "DEBUG:", "set start/arrive time correctly")
from CalculatorManager import CalculatorManager
worker = self.worker = CalculatorManager(self)
thread = self.thread = QtCore.QThread()
worker.moveToThread(thread)
thread.started.connect(worker.run)
for o in orig_list:
for d in dest_list:
worker.qi.put((o[0], d[0] \
,self.timetable \
,self.cat_db
,int(self.dock.qleSearchdirection.text()) \
,300 \
,o[1] ,o[2] ,d[1] ,d[2] \
, start_time))
worker.myprintsignal.connect(self.myprint)
thread.start()
#worker.run()
#self.myprint("started")
def myprint(self,txt):
self.log.ptxResult.appendPlainText(txt)
#!/usr/bin/python
import sys
from Timetable import Timetable
if len(sys.argv) < 2:
print "Usage : ", sys.argv[0], " sourceFile [filter]"
sys.exit()
else:
sourceFile = sys.argv[1]
if len(sys.argv) < 3:
catFilter = ''
else:
catFilter = sys.argv[2]
# MAIN
timetable = Timetable(sourceFile, catFilter)
timetable.parse()
def genetic_simulation(self):
init_time = time.time()
iteration = 0
score_list = [individual.score for individual in self.population]
best_individual = score_list.index(min(score_list))
self.best_individual = self.population[best_individual]
print "Best score after initialization: ", self.best_individual.score
while ((time.time() - init_time) < self.data["run_time"]):
# Select 4 individuals randomly and return best of pairs
p1, p2 = self.selection(destruction=True)
self.population[p1].fill_unscheduled()
self.population[p2].fill_unscheduled()
self.population[p1].room_hill_climb()
self.population[p2].room_hill_climb()
if (time.time() - init_time) / float(
self.data["run_time"]) > 0.90 and iteration % 100 == 0:
self.population[p1].room_hill_climb(
room2swap=self.population[p1].schedule.shape[0] / 3,
rndtry=2)
self.population[p2].room_hill_climb(
room2swap=self.population[p2].schedule.shape[0] / 3,
rndtry=2)
if (len(
np.where((self.population[p1].schedule -
self.population[p2].schedule) == 0)[0]) /
float(self.population[p1].schedule.size)) > 0.75:
best_scores = [
self.population[p1].score, self.population[p2].score
]
parents = [p1, p2]
o1 = copy.deepcopy(self.population[parents[best_scores.index(
max(best_scores))]])
o2 = Timetable(self.data, self.compactness_ini)
else:
o1, o2 = self.recombination(self.population[p1],
self.population[p2])
o1_prime, o2_prime = self.mutation((o1, o2))
# Select 4 individuals and return worst of pairs
w1, w2 = self.selection(best_selection=False)
self.population[w1] = o1_prime
self.population[w2] = o2_prime
iteration += 1
score_list = [individual.score for individual in self.population]
best_individual = score_list.index(min(score_list))
self.scores_per_iteration.append(
self.population[best_individual].score)
score_list = [individual.score for individual in self.population]
best_individual = score_list.index(min(score_list))
self.best_individual = self.population[best_individual]
print self.best_individual.score
self.best_individual.room_hill_climb(
room2swap=self.population[p2].schedule.shape[0], rndtry=10)
print self.best_individual.score
# Score after hill climber
self.scores_per_iteration.append(
self.population[best_individual].score)
print "Best score: ", self.best_individual.score
self.generations = iteration
print 'Iterations: ', iteration
def initialize_population(self):
for i in xrange(self.population_size):
Individual = Timetable(self.data, self.compactness_ini)
self.population.append(Individual)
from Timetable import Timetable
# Импортирование класса 'Subject' из файла 'Subject'
from Subject import Subject
# Импортирование класса 'Teacher' из файла 'Teacher'
from Teacher import Teacher
# Импортирование модуля 'pickle' для сериализации и десериализации объектов
import pickle
if __name__ == '__main__':
# Создание объекта класса MainPojo
Mp = MainPojo()
# Передача значения 'Timetable' в метод 'get_Timetable'
Mp.get_Timetable = "Timetable"
# Создание объекта класса Timetable
Tt = Timetable()
# Передача значения 'Subject' в метод 'get_subject' класса 'Timetable'
Tt.get_subject = "Subject"
# Передача значения 'Teacher' в метод 'get_teacher' класса 'Timetable'
Tt.get_teacher = "Teacher"
# Создание объекта класса Subject
Su = Subject()
# Передача значения 'TPR' в метод 'get_name_sub' класса 'Subject'
Su.get_name_sub = 'TPR'
# Передача значения 'Monday' в метод 'get_day' класса 'Subject'
Su.get_day = 'Monday'
# Передача значения 'D-514' в метод 'get_audience' класса 'Subject'
Su.get_audience = 'D-514'
# Создание объекта класса Teacher
def reset_timetable(self):
self.timetable = Timetable()
