def init_recognizer(self,recognizer='zinnia'):
recognizers = Recognizer.get_available_recognizers()
print "Available recognizers", recognizers,type(recognizers)
for temp in recognizers :
pprint.pprint(temp)
recognizer_name = recognizer
if not recognizer_name in recognizers:
raise Exception, "Not an available recognizer"
recognizer_klass = recognizers[recognizer_name]
self.recognizer = recognizer_klass()
models = recognizer_klass.get_available_models()
for model in models :
print type(model),model
for model in models :
print type(model),model
print "++++"
for r_name, model_name, meta in Recognizer.get_all_available_models() :
print r_name
print model_name
print meta
print "\nAvailable models", models,type(models)
print (models['Simplified Chinese']['shortname'])
model = "Simplified Chinese"
if not model in models:
raise Exception, "Not an available model"
print self.recognizer.set_model(model)
def post(self):
xmlFile = request.files['file']
recognizer = "zinnia"
model = "Japanese"
char = Character()
char.read(xmlFile)
writing = char.get_writing()
recognizers = Recognizer.get_available_recognizers()
if not recognizer in recognizers:
raise TegakiRecognizeError, "Not an available recognizer."
recognizer_klass = recognizers[recognizer]
recognizer = recognizer_klass()
models = recognizer_klass.get_available_models()
if not model in models:
raise TegakiRecognizeError, "Not an available model."
recognizer.set_model(model)
return {'data': recognizer.recognize(writing)}
def init_recog(self):
self.candidates = None
r_name, model_name, meta = Recognizer.get_all_available_models()[1]
klass = Recognizer.get_available_recognizers()[r_name]
self._recognizer = klass()
self._recognizer.set_model(meta["name"])
self._writing = Writing()
def choice_setmodel(self,nr):
mcount = len(Recognizer.get_all_available_models())
if (nr==mcount) and self.faking:
self.set_decorated(not self.get_decorated())
return
elif nr>mcount:
return
r_name, model_name, meta = Recognizer.get_all_available_models()[nr]
klass = Recognizer.get_available_recognizers()[r_name]
self._recognizer = klass()
self._recognizer.set_model(meta["name"])
self._writing = Writing()
def set_selected_model(self, i):
try:
r_name, model_name, meta = Recognizer.get_all_available_models()[i]
klass = Recognizer.get_available_recognizers()[r_name]
self._recognizer = klass()
self._recognizer.set_model(meta["name"])
self._models_button.set_label(meta["shortname"])
# a hack to retain the model id the button
self._models_button.selected_model = i
self._ready = True
except IndexError:
self._ready = False
def recognize_submit(request):
if settings.DEBUG:
xml = request.REQUEST['xml'] #if testing we want to be able to pass stuff in with GET request
else:
xml = request.POST['xml']
char = character.Character()
char.read_string(xml)
klass = Recognizer.get_available_recognizers()['zinnia']
rec = klass()
rec.set_model('Simplified Chinese')
writing = char.get_writing()
#writing = writing.copy()
results = rec.recognize(writing)
return HttpResponse(u"%s" % jsonify_results(results))
def set_selected_model(self, i):
try:
r_name, model_name, meta = Recognizer.get_all_available_models()[i]
klass = Recognizer.get_available_recognizers()[r_name]
self._recognizer = klass()
self._recognizer.set_model(meta["name"])
self._models_button.set_label(meta["shortname"])
# a hack to retain the model id the button
self._models_button.selected_model = i
self._ready = True
except IndexError:
self._ready = False
def setDictionary(self, recognizerSettings={}):
#self.clear_strokes()
#initialize the default dictionary and a simple recognizer
if recognizerType == 'tomoe' \
and 'tomoe' in recognizerSettings \
and 'dictionary' in recognizerSettings['tomoe']:
tomoeDict = Dict("XML",
filename=recognizerSettings['tomoe']['dictionary'])
self.recognizer = Recognizer('Simple',
dictionary=tomoeDict)
# will encapsulate stroke data
if not self.writing:
self.writing = Writing()
elif recognizerType == 'tegaki':
recognizers = Recognizer.get_available_recognizers()
if not recognizers:
raise Exception('No recognizer available')
if 'tegaki' in recognizerSettings \
and 'recognizer' in recognizerSettings['tegaki']:
engine = recognizerSettings['tegaki']['recognizer']
if engine not in recognizers:
raise Exception('recognizer not available')
else:
engine = recognizers.keys()[0]
recognizer_klass = recognizers[engine]
self.recognizer = recognizer_klass()
if 'tegaki' in recognizerSettings \
and 'model' in recognizerSettings['tegaki']:
model = recognizerSettings['tegaki']['model']
if model not in recognizer_klass.get_available_models():
raise Exception('Model not available')
else:
model = recognizer_klass.get_available_models().keys()[0]
self.recognizer.set_model(model)
# will encapsulate stroke data
if not self.writing:
self.writing = Writing()
else:
self.writing = None
