def _find(self, column, threshold):
# 记录所有可能出现的feature,以供后边统计字典中该feature出现的次数
# find all the feature , prepare for calculating the count that the feature appears
column_list = self.raw_data[:, column]
pre_dict = {}
end_dict = {}
start = time.clock()
for i in range(self.row_number):
for j in range(i + 1, self.row_number):
pre_pattern = PatternHelper.find_pre_common_str(
column_list[i], column_list[j])
end_pattern = PatternHelper.find_end_common_str(
column_list[i], column_list[j])
if pre_pattern != '':
DictHelper.increase_dic_key(pre_dict, pre_pattern)
self.cell_pre_patterns[i][column].append(pre_pattern)
self.cell_pre_patterns[j][column].append(pre_pattern)
if end_pattern != '':
DictHelper.increase_dic_key(end_dict, end_pattern)
self.cell_end_patterns[i][column].append(end_pattern)
self.cell_end_patterns[j][column].append(end_pattern)
print("find1 : {0}".format(time.clock() - start))
pre_list = [
key for key, value in pre_dict.items() if value > threshold
]
end_list = [
key for key, value in end_dict.items() if value > threshold
]
return pre_list, end_list
def update_probability_dict(dict_file, new_dict_file_list):
probability_dict = StoreHelper.load_data(dict_file, {})
for dict_file in new_dict_file_list:
new_dict = StoreHelper.load_data(dict_file, {})
print("Get %s with records: %i" % (dict_file, len(new_dict)))
DictHelper.update_dict(probability_dict, new_dict)
StoreHelper.store_data(probability_dict, dict_file)
def split_dict():
phase_dict = StoreHelper.load_data("phase_dict.dat", {})
phase_dict_single = {}
phase_dict_double = {}
for key, value in phase_dict.items():
if '_' in key:
phase_dict_double[key] = value
else:
phase_dict_single[key] = value
StoreHelper.save_file(DictHelper.get_sorted_list(phase_dict_single), 'phase_dict_single.txt')
StoreHelper.save_file(DictHelper.get_sorted_list(phase_dict_double), 'phase_dict_double.txt')
def score_column_candidate(self, column, recover_list, small_pattern_list):
score_dict = {}
for candidate in recover_list[column]:
candidate_small_pattern = self.train.get_small_pattern(
candidate, column)
for j in range(self.column_number_test):
if len(recover_list[j]) == 1 and self.train.vote_for_column(
column, candidate_small_pattern, j,
small_pattern_list[j]): # can be a judge
DictHelper.increase_dic_key(score_dict, candidate)
return score_dict
def merge_dict():
profile_dict_list = StoreHelper.load_data(
'../resource/convert_profile.dat', [])
merged_list = []
for profile_dict in profile_dict_list:
merged_dict = {}
for feature in profile_dict:
for key in profile_dict[feature]:
DictHelper.increase_dic_key(merged_dict, key)
merged_list.append(merged_dict)
StoreHelper.store_data(merged_list, '../resource/merged_profile.dat')
StoreHelper.save_file(merged_list, '../resource/merged_profile.txt')
def generate_probability_dict(file_content_list):
# statistics single word and continue two words
single_word_dict = {}
two_word_dict = {}
for file_content in file_content_list:
for line in file_content.splitlines():
word_list = SegmentHelper.segment_text(line)
if len(word_list) == 1:
DictHelper.increase_dic_key(single_word_dict, word_list[0])
else:
for i in range(len(word_list) - 1):
DictHelper.increase_dic_key(single_word_dict,
word_list[i])
DictHelper.increase_dic_key(
two_word_dict,
"%s %s" % (word_list[i], word_list[i + 1]))
DictHelper.increase_dic_key(single_word_dict,
word_list[-1])
# compute two word probability
prob_a_b_dict = {}
for words, count in two_word_dict.items():
word_a, word_b = words.split(' ')
pro_a_b = two_word_dict[words] * 1.0 / single_word_dict[word_b]
pro_b_a = two_word_dict[words] * 1.0 / single_word_dict[word_a]
prob_a_b_dict[words] = max(pro_a_b, pro_b_a)
return prob_a_b_dict
def _add_and_remove(self, words_dict):
for words, count in words_dict.items():
if words in self.phrase_dict:
if self.phrase_dict[words] < count:
DictHelper.increase_dic_key(
self.phrase_dict, words,
count - self.phrase_dict[words])
self._count_down_single_word(
words, count - self.phrase_dict[words])
elif self.phrase_dict[words] > count:
print(
"Warning: phrase match times little than origin split: %s"
% words)
else:
DictHelper.increase_dic_key(self.phrase_dict, words, count)
self._count_down_single_word(words, count)
def sorted_data_by_row(csv_columns, data_list, sort_data_row, escape_first):
# step 1, parameters check
if sort_data_row >= len(data_list):
print ("Sort row large than the data row!")
return
# step 2, construct data structure
new_csv_column = csv_columns[: escape_first]
new_data_list = [row[: escape_first] for row in data_list]
data_dict = {}
# For each column
for column in range(escape_first, len(csv_columns)):
# Get the column data for each rwo
data_column = [data_list[row][column] for row in range(len(data_list))]
key_for_sort = float(data_list[sort_data_row][column])
while key_for_sort in data_dict:
key_for_sort += random.randint(0, 100) * 0.000000001
data_dict[key_for_sort] = (csv_columns[column], data_column)
# step 3, sorted by key
sorted_list = DictHelper.get_sorted_list(data_dict, sorted_by_key=True)
print (sorted_list)
for key_for_sort, csv_data in sorted_list:
new_csv_column.append(csv_data[0])
for row in range(len(new_data_list)):
new_data_list[row].append(csv_data[1][row])
return new_csv_column, new_data_list
def get_combine_company_dict(store_data_file):
company_dict = {}
for tab in range(2):
header, raw_data = ExcelHelper.read_excel('../resource/us_list_company2.xlsx', tab)
row, column = raw_data.shape
for i in range(row):
company_name = SegmentHelper.normalize(str(raw_data[i][0]).strip())
if len(company_name) > 0:
DictHelper.increase_dic_key(company_dict, raw_data[i][0])
df = pd.read_csv('../resource/us_list_company_1.csv')
name_serial = df['Name']
for i in range(df.shape[0]):
company_name = SegmentHelper.normalize(name_serial[i])
if len(company_name) > 0:
DictHelper.increase_dic_key(company_dict, name_serial[i])
StoreHelper.store_data(company_dict, store_data_file)
def get_dict_pattern(context, _dict, convert=True):
match_result = {}
for key in _dict.keys():
key_split = key.split(' ')
if len(key_split) >= 3 and key_split[1] == '...':
match_times = len(
re.findall(
re.escape(key_split[0]) + r'( \w+){0,5} ' +
re.escape(' '.join(key_split[2:])), context))
else:
key = key.strip()
match_times = len(
re.findall(r'\b' + re.escape(key) + r'\b', context))
if match_times > 0:
if convert is True and type(_dict[key]) is not int:
DictHelper.increase_dic_key(match_result, _dict[key],
match_times)
else:
DictHelper.increase_dic_key(match_result, key, match_times)
return match_result
def print_label(label, index_list, cluster_number=None):
if cluster_number is None:
label_dict = DictHelper.dict_from_count_list(label)
print("\t".join([str(i) for i in label]))
print(label_dict)
print("max cluster number: %i" % max(label_dict))
print("min cluster number: %i" % min(label_dict))
position_tag = {}
for i in range(len(label)):
DictHelper.append_dic_key(position_tag, label[i],
int(index_list[i]))
for key, value in position_tag.items():
print("%s: %s" % (key, value))
StoreHelper.store_data(position_tag, 'position_tag.dat')
StoreHelper.save_file(position_tag, 'position_tag.txt')
else:
length = len(label)
clusters = [[str(j) for j in range(length) if label[j] == i]
for i in range(cluster_number)]
for i in range(len(clusters)):
print("Cluster %i has %i position, position: %s" %
(i, len(clusters[i]), str(clusters[i])))
def _get_working_year_words(self, year_convert_file=None):
year_list = TextHelper.get_years_pattern(self.raw_position)
if len(year_list) == 0:
default_year_requirement = "[0]"
self.new_words_list.append(default_year_requirement)
year_list = [default_year_requirement]
elif year_convert_file is not None:
year_convert_dict = StoreHelper.load_data(year_convert_file, {})
year_list = [
year_convert_dict[item] for item in year_list
if item in year_convert_dict
]
return DictHelper.dict_from_count_list(year_list)
def convert(self, skill_dict, discipline_dict, education_dict,
responsibility_dict, year_convert_file):
year_phase_dict = self._get_working_year_words(year_convert_file)
skill_phase_dict = self._get_skill_words(skill_dict)
discipline_phase_dict = self._get_discipline_words(discipline_dict)
education_phase_dict = self._get_education_words(education_dict)
responsibility_phase_dict = self._get_responsibility_words(
responsibility_dict)
self._add_and_remove(year_phase_dict)
self._add_and_remove(skill_phase_dict)
self._add_and_remove(discipline_phase_dict)
self._add_and_remove(education_phase_dict)
self._add_and_remove(responsibility_phase_dict)
for word in self.new_words_list:
DictHelper.increase_dic_key(self.phrase_dict, word)
result_dict = {
"education": education_phase_dict.keys(),
"major": discipline_phase_dict.keys(),
"skills": skill_phase_dict.keys(),
"working-year": year_phase_dict.keys(),
"responsibility": responsibility_phase_dict.keys()
}
return result_dict
def convert_university(profile, convert_dict, debug=False):
university_list = profile['university']
if len(university_list) == 0:
return None
university_list = [
SegmentHelper.normalize(university)
for university in university_list
]
for university in university_list:
convert_name = DictHelper.find_in_key(convert_dict, university)
if convert_name is not None:
if debug:
print("%s ==> %s" % (university, convert_name))
return convert_dict[convert_name]
return university_list[0]
def init(self):
Logger.instance().log_debug("PostPhotoScene.init");
self._config_filename = scene_manager.SceneManager.instance().get_postphoto_scene_filename();
#Validate the configuration.
config_info = config_validation.validate("PostPhotoScene",
self._config_filename,
PostPhotoScene._REQUIRED_KEYS);
self._config_contents = DictHelper(config_info);
#Init the UI.
self._init_static_sprites();
self._init_photo_sprite();
self._init_frame_sprite();
self._init_buttons();
def init(self):
Logger.instance().log_debug("CameraScene.init");
self._config_filename = scene_manager.SceneManager.instance().get_camera_scene_filename();
#Validate the configuration.
config_dict = config_validation.validate("CameraScene",
self._config_filename,
CameraScene._REQUIRED_KEYS);
self._config_contents = DictHelper(config_dict);
#Init the UI.
self._init_static_sprites();
self._init_camera_sprite();
self._init_frame_sprite();
self._init_buttons();
self._init_countdown_sprite();
def _get_full_relation(self, column1, column2, row):
# for pre pattern
cell1_patterns = self.cell_pre_patterns[row][column1]
cell2_patterns = self.cell_pre_patterns[row][column2]
for pattern1 in cell1_patterns:
for pattern2 in cell2_patterns:
DictHelper.increase_dic_key(
self.pre_pattern_relation[column1][column2],
pattern1 + "|" + pattern2)
DictHelper.increase_dic_key(
self.pre_pattern_relation[column2][column1],
pattern2 + "|" + pattern1)
# for end pattern
cell1_patterns = self.cell_end_patterns[row][column1]
cell2_patterns = self.cell_end_patterns[row][column2]
for pattern1 in cell1_patterns:
for pattern2 in cell2_patterns:
DictHelper.increase_dic_key(
self.end_pattern_relation[column1][column2],
pattern1 + "|" + pattern2)
DictHelper.increase_dic_key(
self.end_pattern_relation[column2][column1],
pattern2 + "|" + pattern1)
def __init__(self, raw_position, word_list=[]):
self.raw_position = raw_position.lower()
self.word_list = word_list
self.phrase_dict = DictHelper.dict_from_count_list(self.word_list)
self.new_words_list = []
def _count_down_single_word(self, words, decrease_value=1):
word_list = [word for word in words.split(' ') if len(word) > 0]
for word in word_list:
DictHelper.decrease_dic_key(self.phrase_dict, word, decrease_value)
def convert_2(self, probability_dict):
year_phase_list = self._get_working_year_words()
phrase_list = self._remove_conjunction_segment(probability_dict)
phrase_list.extend(year_phase_list)
return DictHelper.dict_from_count_list(phrase_list)
def _collect_words_dict(self):
result_dict = {}
for _dict in self.blob_dict_list:
for key in _dict.keys():
DictHelper.increase_dic_key(result_dict, key)
return result_dict
url_list.extend(
CrawlHelper.extract_job_id_list(
CrawlHelper.get_web_source(web_url)))
return url_list
@staticmethod
def get_all_job_post(url_file, post_file):
post_info_list = []
for url in StoreHelper.load_data(url_file, {}):
web_content = CrawlHelper.get_web_source(url)
post_info_list.append((url, web_content))
StoreHelper.store_data(post_info_list, post_file)
if __name__ == '__main__':
raw_dict = DictHelper.load_dict_from_excel(
"../resource/linkedin_geography.xlsx")
us_geography = DictHelper.generate_geography_dic(raw_dict, 'na.us', 1)
print(us_geography)
continue_failed = 0
escape = 2
for key, value in us_geography.items():
if escape > 0:
escape -= 1
continue
status = CrawlHelper.crawl_post_information(
"../data/%s.ids.dat" % key.encode('utf-8'),
"../data/post/%s.dat" % key.encode('utf-8'))
if status is False:
continue_failed += 1
if continue_failed >= 2:
print("Program exit! Maybe robot identified!")
def get_frequency_dict(content):
words_list = []
for line in content.splitlines():
words_list.extend(
SegmentHelper.lemmatization(SegmentHelper.segment_text(line)))
return DictHelper.dict_from_count_list(words_list)
class CameraScene(BaseScene):
############################################################################
## Constants ##
############################################################################
#Required Keys.
_KEY_CAMERA_PLACEHOLDER_SPRITE = "camera_placeholder";
_KEY_CAMERA_FRAME_SPRITE = "camera_frame";
_KEY_TAKEPHOTO_BUTTON = "take_photo";
_KEY_STATIC_SPRITES = "static_sprites";
_KEY_COUNTDOWN_SPRITES = "countdown";
_REQUIRED_KEYS = [
_KEY_CAMERA_PLACEHOLDER_SPRITE,
_KEY_CAMERA_FRAME_SPRITE,
_KEY_TAKEPHOTO_BUTTON,
_KEY_STATIC_SPRITES,
_KEY_COUNTDOWN_SPRITES,
];
#How much time each countdown step will take (in ms).
_COUNTDOWN_CLOCK_TIME = 10;
#Layers.
_LAYER_INDEX_STATIC_SPRITE = 1;
_LAYER_INDEX_CAMERA_SPRITE = 2;
_LAYER_INDEX_FRAME_SPRITE = 3;
_LAYER_INDEX_PHOTO_BUTTON = 4;
_LAYER_INDEX_COUNTDOWN_SPRITE = 5;
############################################################################
## CTOR ##
############################################################################
def __init__(self):
BaseScene.__init__(self);
## iVars ##
#Filenames and Content.
self._config_filename = None;
self._config_contents = None;
#UI Elements.
self._countdown_sprite = None;
self._camera_sprite = None;
self._frame_sprite = None;
self._take_photo_button = None;
#Countdown clock.
self._countdown_clock = BasicClock(CameraScene._COUNTDOWN_CLOCK_TIME,
self._on_countdown_timer_tick);
self._camera_sprite_size = None;
############################################################################
## Overriden Methods ##
############################################################################
def start(self):
Logger.instance().log_debug("CameraScene.start");
def end(self):
Logger.instance().log_debug("CameraScene.end");
############################################################################
## Init ##
############################################################################
def init(self):
Logger.instance().log_debug("CameraScene.init");
self._config_filename = scene_manager.SceneManager.instance().get_camera_scene_filename();
#Validate the configuration.
config_dict = config_validation.validate("CameraScene",
self._config_filename,
CameraScene._REQUIRED_KEYS);
self._config_contents = DictHelper(config_dict);
#Init the UI.
self._init_static_sprites();
self._init_camera_sprite();
self._init_frame_sprite();
self._init_buttons();
self._init_countdown_sprite();
def _init_static_sprites(self):
sprite_list = self._config_contents.value_or_die(CameraScene._KEY_STATIC_SPRITES);
for info in sprite_list:
#Create the sprite.
sprite = Sprite();
#Set the sprite properties.
sprite.load_image (info["image" ]);
sprite.set_position(info["position"]);
self._background_sprite = sprite;
#Add to scene.
self.add(sprite, layer = CameraScene._LAYER_INDEX_STATIC_SPRITE);
def _init_camera_sprite(self):
#Initialize the sprite.
self._camera_sprite = Sprite();
#Get the info.
info = self._config_contents.value_or_die(CameraScene._KEY_CAMERA_PLACEHOLDER_SPRITE);
#Set the sprite properties.
self._camera_sprite.load_image (info["image" ]);
self._camera_sprite.set_position(info["position"]);
#Add to scene.
self.add(self._camera_sprite,
layer = CameraScene._LAYER_INDEX_CAMERA_SPRITE);
self._camera_sprite_size = self._camera_sprite.get_size();
def _init_frame_sprite(self):
#Get the info.
info = self._config_contents.value_or_die(CameraScene._KEY_CAMERA_FRAME_SPRITE);
#Don't need the frame...
if(info == False):
return;
#Init the sprite.
self._frame_sprite = Sprite();
#Set the sprite properties.
self._frame_sprite.load_image(info["image"]);
self._frame_sprite.set_position(info["position"]);
#Frame isn't same size of camera image, so scale it.
if(self._frame_sprite.get_size() != self._camera_sprite_size):
frame_image = self._frame_sprite.image;
scaled_image = pygame.transform.scale(frame_image,
self._camera_sprite_size);
self._frame_sprite.update_image(scaled_image);
#Add to scene.
self.add(self._frame_sprite,
layer = CameraScene._LAYER_INDEX_FRAME_SPRITE);
def _init_buttons(self):
#Initialize the button.
self._take_photo_button = Button();
#Get the info.
info = self._config_contents.value_or_die(CameraScene._KEY_TAKEPHOTO_BUTTON);
#Set the button properties.
self._take_photo_button.load_images(info["normal_image"],
info["pressed_image"]);
self._take_photo_button.set_position(info["position"]);
self._take_photo_button.set_click_callback(self._on_take_photo_button_pressed);
#Add to scene.
self.add(self._take_photo_button,
layer = CameraScene._LAYER_INDEX_PHOTO_BUTTON);
def _init_countdown_sprite(self):
#Initialize the Sprite.
self._countdown_sprite = Sprite();
#Get the info.
info = self._config_contents.value_or_die(CameraScene._KEY_COUNTDOWN_SPRITES);
#Set the sprite properties.
self._countdown_sprite.set_position(info["position"]);
self._countdown_sprite.load_image(info["sprites"][0]);
#Countdown is hidden by default.
############################################################################
## Update / Draw / Handle Events Methods ##
############################################################################
def update(self, dt):
self._countdown_clock.update(dt);
img = Camera.instance().get_frame(scale_to = self._camera_sprite_size);
self._camera_sprite.update_image(img);
def handle_events(self, event):
self._take_photo_button.handle_events(event);
############################################################################
## Button Callbacks ##
############################################################################
def _on_take_photo_button_pressed(self):
#Set the UI Elements visibility.
self.remove(self._take_photo_button);
self.add(self._countdown_sprite,
layer = CameraScene._LAYER_INDEX_COUNTDOWN_SPRITE);
#Start the countdown...
self._countdown_clock.start();
############################################################################
## Timer Callbacks ##
############################################################################
def _on_countdown_timer_tick(self):
#Get the info.
info = self._config_contents.value_or_die(CameraScene._KEY_COUNTDOWN_SPRITES);
sprites_list = info["sprites"];
index = self._countdown_clock.get_ticks_count();
#Check if have more countdown images to show...
if(index < len(sprites_list)):
self._countdown_sprite.load_image(sprites_list[index]);
else:
#Reset the image to the first frame and inform that
#the countdown is done.
self._countdown_sprite.load_image(sprites_list[0]);
self._countdown_timer_finished();
############################################################################
## Other Methods ##
############################################################################
def _countdown_timer_finished(self):
#Set the UI Elements visibility.
self.remove(self._countdown_sprite);
self.add(self._take_photo_button,
layer = CameraScene._LAYER_INDEX_PHOTO_BUTTON);
#Stop the countdown...
self._countdown_clock.stop();
#Call the Camera to grab a photo.
Camera.instance().take_photo();
#Go to another scene.
scene_mgr = scene_manager.SceneManager;
scene_mgr.instance().scene_is_complete(scene_mgr.SCENE_NAME_POSTPHOTO);
class PostPhotoScene(BaseScene):
############################################################################
## Constants ##
############################################################################
#Required Keys.
_KEY_PHOTO_PLACEHOLDER_SPRITE = "photo_placeholder";
_KEY_PHOTO_FRAME_SPRITE = "photo_frame";
_KEY_STATIC_SPRITES = "static_sprites";
_KEY_ACCEPT_BUTTON = "accept_button";
_KEY_REJECT_BUTTON = "reject_button";
_REQUIRED_KEYS = [
_KEY_PHOTO_PLACEHOLDER_SPRITE,
_KEY_PHOTO_FRAME_SPRITE,
_KEY_STATIC_SPRITES,
_KEY_ACCEPT_BUTTON,
_KEY_REJECT_BUTTON,
];
#Layers.
_LAYER_INDEX_STATIC_SPRITE = 1;
_LAYER_INDEX_CAMERA_SPRITE = 2;
_LAYER_INDEX_FRAME_SPRITE = 3;
_LAYER_INDEX_BUTTONS = 4;
############################################################################
## CTOR ##
############################################################################
def __init__(self):
BaseScene.__init__(self);
## iVars ##
#Filenames and Content.
self._config_filename = None;
self._config_contents = None;
#UI Elements.
self._accept_button = None;
self._reject_button = None;
self._photo_sprite = None;
self._frame_sprite = None;
############################################################################
## Overriden Methods ##
############################################################################
def start(self):
Logger.instance().log_debug("PostPhotoScene.start");
#Update the placeholder image to the last photo taken by camera.
placeholder_size = self._photo_sprite.get_size();
last_photo = Camera.instance().get_last_photo(scale_to = placeholder_size);
self._photo_sprite.update_image(last_photo);
def end(self):
Logger.instance().log_debug("PostPhotoScene.end");
############################################################################
## Init ##
############################################################################
def init(self):
Logger.instance().log_debug("PostPhotoScene.init");
self._config_filename = scene_manager.SceneManager.instance().get_postphoto_scene_filename();
#Validate the configuration.
config_info = config_validation.validate("PostPhotoScene",
self._config_filename,
PostPhotoScene._REQUIRED_KEYS);
self._config_contents = DictHelper(config_info);
#Init the UI.
self._init_static_sprites();
self._init_photo_sprite();
self._init_frame_sprite();
self._init_buttons();
def _init_static_sprites(self):
sprite_list = self._config_contents.value_or_die(PostPhotoScene._KEY_STATIC_SPRITES);
for info in sprite_list:
#Create the sprite.
sprite = Sprite();
#Set the sprite properties.
sprite.load_image (info["image" ]);
sprite.set_position(info["position"]);
#Add to scene.
self.add(sprite, layer = PostPhotoScene._LAYER_INDEX_STATIC_SPRITE);
def _init_photo_sprite(self):
#Get the info.
info = self._config_contents.value_or_die(PostPhotoScene._KEY_PHOTO_PLACEHOLDER_SPRITE);
#Create the sprite.
self._photo_sprite = Sprite();
#Set the sprite properties.
self._photo_sprite.load_image (info["image" ]);
self._photo_sprite.set_position(info["position"]);
#Add to scene.
self.add(self._photo_sprite,
layer = PostPhotoScene._LAYER_INDEX_CAMERA_SPRITE);
def _init_frame_sprite(self):
#Get the info.
info = self._config_contents.value_or_die(PostPhotoScene._KEY_PHOTO_FRAME_SPRITE);
#Don't need the frame...
if(info == False):
return;
#Init the sprite.
self._frame_sprite = Sprite();
#Set the sprite properties.
self._frame_sprite.load_image (info["image" ]);
self._frame_sprite.set_position(info["position"]);
#Frame isn't same size of camera image, so scale it.
photo_sprite_size = self._photo_sprite.get_size();
if(self._frame_sprite.get_size() != photo_sprite_size):
frame_image = self._frame_sprite.image;
scaled_image = pygame.transform.scale(frame_image,
photo_sprite_size);
self._frame_sprite.update_image(scaled_image);
#Add to scene.
self.add(self._frame_sprite,
layer = PostPhotoScene._LAYER_INDEX_FRAME_SPRITE);
def _init_buttons(self):
## Initialize the Accept and Reject Buttons. ##
#Get the infos.
accept_info = self._config_contents.value_or_die(PostPhotoScene._KEY_ACCEPT_BUTTON);
reject_info = self._config_contents.value_or_die(PostPhotoScene._KEY_REJECT_BUTTON);
#Initialize the buttons.
self._accept_button = self._create_button_helper(accept_info,
self._on_accept_button_pressed);
self._reject_button = self._create_button_helper(reject_info,
self._on_reject_button_pressed);
def _create_button_helper(self, info, callback):
button = Button();
#Images.
button.load_images(info["normal_image"],
info["pressed_image"]);
#Position.
button.set_position(info["position"]);
#Callback.
button.set_click_callback(callback);
#Add to scene.
self.add(button, layer = PostPhotoScene._LAYER_INDEX_BUTTONS);
return button;
############################################################################
## Update / Draw / Handle Events ##
############################################################################
def handle_events(self, event):
#Those buttons are *always* present.
self._accept_button.handle_events(event);
self._reject_button.handle_events(event);
############################################################################
## Button Callbacks ##
############################################################################
def _on_accept_button_pressed(self):
self._save_photo_on_disk();
#Change to other scene.
self._change_scene(scene_manager.SceneManager.SCENE_NAME_DONE);
def _on_reject_button_pressed(self):
self._change_scene(scene_manager.SceneManager.SCENE_NAME_CAMERA);
############################################################################
## Helper Methods ##
############################################################################
def _change_scene(self, scene_name):
scene_manager.SceneManager.instance().scene_is_complete(target_scene_name=scene_name);
def _save_photo_on_disk(self):
#Save the photo on disk...
filesystem.save_photo(Camera.instance().get_last_photo(),
use_another_thread = True);
