def baidu_img_realize(filepath):
APP_ID = APP_ID
API_KEY = API_KEY
SECRET_KEY = SECRET_KEY
aipimg = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
options = {}
image = get_file_content(filepath)
aipimg.advancedGeneral(image)
result = aipimg.advancedGeneral(image, options)
return result
def image_labels(filePath):
APP_ID = '16562491'
API_KEY = 'RjFLMA41ELxZG0A07A3UgxDV'
SECRET_KEY = '4Kk6jdzfNliYwEVFCOrjwtUee7Ylu6QP'
filePath = "/home/lwf/scan_recognition/" + filePath
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
image = get_file_content(filePath)
client.advancedGeneral(image)
options = {}
options["baike_num"] = 5
ret = client.advancedGeneral(image, options)
return ret['result'][0]['root'] + ret['result'][0]['keyword']
class ImageClassify:
def __init__(self,app_id,api_key,secret_key):
self.image_client = AipImageClassify(app_id,api_key,secret_key)
self.words_client = AipOcr(app_id,api_key,secret_key)
def _get_token(self):
url = 'https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id='+self.api_key+'&client_secret='+self.secret_key
response = requests.get(url)
if response and response.status_code == 200:
content = response.json()
token = content.get('access_token') or ''
return token
return None
def _get_file_content(self,file_path):
with open(file_path, 'rb') as fp:
return fp.read()
def resolve_image(self,file_path):
image = self._get_file_content(file_path)
contents = self.image_client.advancedGeneral(image)
result = contents.get('result')[0]
return result.get('keyword')
def resolve_words(self,file_path):
words = self._get_file_content(file_path)
contents = self.words_client.basicGeneral(words)
result = contents.get('words_result')[0]
return result.get('words')
class ClassifyApi:
def __init__(self):
APP_ID = "11455535"
API_KEY = "oGUA2c9R2CjWFnrKTCSHLbTY"
SECRET_KEY = "qy6QqdUsfNs5cmRys9RX2cECo0H2vjX3"
self.client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
# 识别图片有可能叫什么
def classify(self, url):
try:
image = open(url, 'rb').read()
msg = self.client.advancedGeneral(image)
rets = []
result = msg.get("result")
if result != None: # 会存在 api调用次数上线,不返回数据了
for i in result:
temp = {
"root": i.get("root").encode("utf-8"),
"keyword": i.get("keyword").encode("utf-8"),
"score": float(i.get("score"))
}
rets.append(temp)
return rets
else:
return None
except Exception, e:
print e
raise RuntimeError("百度api调用异常")
def query_api(self, filePath, options=None):
image = self.get_file_content(filePath)
client = AipImageClassify(self.id, self.key, self.secret)
res = client.advancedGeneral(image)['result']
res = sorted(res, key=lambda x: x['score'], reverse=True)
if len(res) >= 3:
res = res[:3]
for r in res:
r['score'] = float('%.2f' % (r['score'] * 100))
print(res)
return res
# path="D:/GitHub/animaltest/animaltest/static/uploads/188.jpg"
# animalAPI=animalAPI(APP_ID,API_KEY,SECRET_KEY)
# animalAPI.query_api(path)
# image = get_file_content('D:/GitHub/animaltest/animaltest/static/uploads/188.jpg')
# """ 调用通用物体识别 """
# client.advancedGeneral(image)
# """ 如果有可选参数 """
# options = {}
# options["baike_num"] = 3
# """ 带参数调用通用物体识别 """
# print(client.advancedGeneral(image))
def baidu_image(image_path):
# content = ''
options = dict()
options['baike_num'] = 1
client = AipImageClassify(BAIDU['IMAGE']['WECHAT']['APP_ID'],
BAIDU['IMAGE']['WECHAT']['API_KEY'],
BAIDU['IMAGE']['WECHAT']['SECRET_KEY'])
def get_file_content(file_path):
with open(file_path, 'rb') as fb:
return fb.read()
image = get_file_content(image_path)
response = client.advancedGeneral(image, options)
# print(response)
if 'error_code' not in response:
if response['result'][0]['baike_info'] and response['result'][0][
'root'] != '非自然图像-屏幕截图':
keyword = response['result'][0]['keyword']
description = response['result'][0]['baike_info']['description']
image_url = response['result'][0]['baike_info']['image_url']
reply_image_path = ".\\grp_img\\reply_%s.jpg" % image_path.split(
'\\')[2][:-4]
with open(reply_image_path, 'wb') as f:
f.write(requests.get(image_url).content)
content = '%s\n%s' % (keyword, description)
return content, reply_image_path
else:
return None
def recv_picture(conn, addr):
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
with open('pic.jpeg', 'wb') as fp:
first=conn.recv(BUFF_SIZE)
file_size, first = first.split(bytes('<SEPARATOR>', 'utf-8'))
file_size = int(file_size)
print(file_size)
fp.write(first)
file_size -= len(first)
while file_size > 0:
data = conn.recv(BUFF_SIZE)
if not data:
break
fp.write(data)
file_size -= len(data)
print('picture received')
fp.close()
img = get_file_content("pic.jpeg")
res = client.advancedGeneral(img)
name = res['result'][0]['keyword']
kind = get_kind(name)
kind_list = ['可回收垃圾', '有害垃圾', '厨余垃圾', '其他垃圾', '无法识别']
kind_name = kind_list[int(kind)]
print('类型：%s' % (kind_name))
# res=recognize.application()
conn.send(bytes(str(kind)+'\r', 'utf-8'))
conn.close()
def tag_recognition(url, APP_ID, API_KEY, SECRET_KEY):
APP_ID = APP_ID
API_KEY = API_KEY
SECRET_KEY = SECRET_KEY
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
img_response = requests.get(url)
response = client.advancedGeneral(img_response.content)
return response
def sss(img_url):
APP_ID = '17926029'
API_KEY = 'dvzmdFFaMFidNass4pZcYals'
SECRET_KEY = 'GTRmEpFHT1zXVNEhWX3rzzfLgXFkLREf'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
print(img_url)
def get_file_content(img):
with open(img, 'rb') as fp:
return fp.read()
image = get_file_content(img_url)
# 调用通用物体识别
client.advancedGeneral(image)
# 如果有可选参数
options = {}
options["baike_num"] = 5
# 带参数调用通用物体识别
result = client.advancedGeneral(image, options)
return result
class ImageAi(object):
def __init__(self, conf_path):
config = configparser.ConfigParser()
config.read(conf_path)
self.__app_id = config["image"]["app_id"]
self.__api_key = config["image"]["api_key"]
self.__secret_key = config["image"]["secret_key"]
self.__client = AipImageClassify(self.__app_id, self.__api_key, self.__secret_key)
def deal(self, image):
return self.__client.advancedGeneral(image)
def query_api(self,filePath,options=None):
image=self.get_file_content(filePath)
client = AipImageClassify(self.id, self.key, self.secret)
res=client.advancedGeneral(image)['result']
res=sorted(res,key=lambda x:x['score'],reverse=True)
if len(res)>=3:
res=res[:3]
for r in res:
r['score']=float('%.2f' % (r['score']*100))
print(res)
return res
def ir_api(image):
""" 你的 APPID AK SK """
APP_ID = '15719765'
API_KEY = 'W3gO6OKVcKtGSGtIjN2rTZgW'
SECRET_KEY = '2T1cZrytwBGLLrjFosQjNvSczgIufLg2'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
""" 调用通用物体识别 """
client.advancedGeneral(image)
""" 如果有可选参数 """
options = {}
options["baike_num"] = 5
""" 带参数调用通用物体识别 """
result = client.advancedGeneral(image, options)['result']
obj_type = result[0]['root']
obj_confidence = result[0]['score']
print("object type: ", obj_type)
print("object confidence: ", obj_confidence)
return obj_type, obj_confidence
def main(arg):
""" 你的 APPID AK SK """
APP_ID = '23521368'
API_KEY = 'ZsU4yX9sebQmW06s7xc3oaaG'
SECRET_KEY = '94OsjVY5GwbaD8QZRLqzRGQgWhwdWcTq'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
image = get_file_content(arg[0])
""" 调用通用物体识别 """
res = client.advancedGeneral(image)
sim_res = "\nGeneral:\n"
poem_keys = ""
for i in range(len(res["result"])):
sim_res += res["result"][i]["keyword"] + ' '
if len(res["result"][i]["keyword"]) > 4:
res["result"][i]["keyword"] = res["result"][i]["keyword"][:4]
if i < 3:
poem_keys += res["result"][i]["keyword"] + ' '
if i == 3:
poem_keys += res["result"][i]["keyword"]
res = client.animalDetect(image)
sim_res += "\nAnimal:\n"
for i in range(len(res["result"])):
sim_res += res["result"][i]["name"] + ' '
res = client.plantDetect(image)
sim_res += "\nPlant:\n"
for i in range(len(res["result"])):
sim_res += res["result"][i]["name"] + ' '
res = client.dishDetect(image)
sim_res += "\nDish:\n"
for i in range(len(res["result"])):
sim_res += res["result"][i]["name"] + ' '
sim_res += "\nPoem:\n"
conn = s.connect(("59.78.8.125", 50010))
s.send(('{"keys":"' + poem_keys + '","yun":"' + str(random.randint(0, 5)) +
'","pattern_id":"' + str(random.randint(0, 3)) +
'"}').encode('utf-8'))
poem = s.recv(1024).decode('utf-8')
sim_res += poem
print(sim_res)
class BaiduImageClassify(object):
def __init__(self):
self.__AppID = self.__get_AppID() # 百度AppID
self.__APIKey = self.__get_APIKey() # 百度APIKey
self.__SecretKey = self.__get_SecretKey() # 百度SecretKey
self.__client = AipImageClassify(self.__AppID, self.__APIKey,
self.__SecretKey)
def __get_AppID(self): # 百度AppID
return '15564545'
def __get_APIKey(self): # 百度APIKey
return 'eTQu0rFLAo18fQC6WN1kgNaG'
def __get_SecretKey(self): # 百度SecretKey
return 'fjtIgD7auNmWwEOqmOL9grdHCQSZmb7m'
def ImageClassify(self, filePath):
try:
""" 读取图片 """
bucket = Bucket('wechat')
image = bucket.get_object_contents(filePath)
""" 调用通用物体识别 """
self.__client.advancedGeneral(image)
""" 如果有可选参数 """
options = {}
options["baike_num"] = 0
""" 带参数调用通用物体识别 """
info = self.__client.advancedGeneral(image, options)
#print info
if 'error_code' in info: # 识别失败
raise Exception("error_code: %s, error_msg: %s" %
(info['error_code'], info['error_msg']))
print "image:%s" % (filePath)
for item in info['result']:
print 'root:%s,keyword:%s' % (item['root'], item['keyword'])
except Exception, ex:
print 'BaiduImageClassify.ImageClassify error:%s' % (ex)
def main(arg):
""" 你的 APPID AK SK """
APP_ID = '23521368'
API_KEY = 'ZsU4yX9sebQmW06s7xc3oaaG'
SECRET_KEY = '94OsjVY5GwbaD8QZRLqzRGQgWhwdWcTq'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
image = get_file_content(arg[0])
""" 调用通用物体识别 """
print(client.advancedGeneral(image))
def content_find_file():
img_list = globalvar.get_value('img_list_global')
show_img = img_list[len(img_list) - 1]
global APP_ID, API_KEY, SECRET_KEY
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
# print(type(show_img)) #PIL Image
# 1 保存 2 读文件流
show_img.save('baidu_ai_temp.jpg')
baidu_ai_temp = open('baidu_ai_temp.jpg', 'rb').read()
r = client.advancedGeneral(baidu_ai_temp) # jpg png图片的二进制
# print(r)
t = r['result'][0]['keyword']
# print(t)
messagebox.showinfo(title='信息', message=('这可能是' + t + '！')) # return ok
class Image(object):
def __init__(self, filename, regs):
app_id, app_key, secret_key = regs
# self.app_id, self.app_key, self.secret_key = app_id, app_key, secret_key
self.filename = filename
self.image = get_img_content(filename)
self.base64 = img2base64(self.image)
self.client = AipImageClassify(app_id, app_key, secret_key)
def is_same_as(self, image):
return self.base64 == image.base64
'''
def _find_logo(self):
res = None
token = access_token(url='https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=' + self.app_key + '&client_secret=' + self.secret_key,
key='access_token')
params = {"custom_lib":True, "image":self.base64}
url = "https://aip.baidubce.com/rest/2.0/image-classify/v2/logo?access_token=" + token
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
data = json.loads(post_json(url, data=params, headers=headers))
print(data)
if data is not None:
res = data.get('result')
return res
'''
# def _result(self, result_num, result):
# for i in range(result_num):
# r = result[i]
def find(self, options=None):
if options is None:
options = {}
return self.client.advancedGeneral(self.image, options)
def find_logo(self, options=None):
if options is None:
options = {}
r = self.client.logoSearch(self.image, options)
result_num = r.get('result_num')
result = r.get('result')
return result_num, result
def main(arg):
""" 你的 APPID AK SK """
APP_ID = '23521368'
API_KEY = 'ZsU4yX9sebQmW06s7xc3oaaG'
SECRET_KEY = '94OsjVY5GwbaD8QZRLqzRGQgWhwdWcTq'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
image = get_file_content(arg[0])
""" 调用通用物体识别 """
res = client.advancedGeneral(image)
sim_res = "\nGeneral:\n"
for i in range(len(res["result"])):
sim_res += res["result"][i]["keyword"] + '; '
res = client.animalDetect(image)
sim_res += "\nAnimal:\n"
for i in range(len(res["result"])):
sim_res += res["result"][i]["name"] + '; '
res = client.plantDetect(image)
sim_res += "\nPlant:\n"
for i in range(len(res["result"])):
sim_res += res["result"][i]["name"] + '; '
res = client.dishDetect(image)
sim_res += "\nDish:\n"
for i in range(len(res["result"])):
sim_res += res["result"][i]["name"] + '; '
print(sim_res)
def imgdetect(request, img):
from aip import AipImageClassify
""" 这里输入你创建应用获得的三个参数"""
APP_ID = '15279946'
API_KEY = 'gFT6Iim8OPT51HQFIyGOmIra'
SECRET_KEY = 'Afi8SoHMFWSKYzi1QD78giGMyakVtr3k'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
imgpath = os.path.join(settings.MEDIA_ROOT, "images", img)
imgurl = "/media/images/" + img
with open(imgpath, "rb") as fp:
img = fp.read()
options = {}
options["baike_num"] = 5
resultimg = client.advancedGeneral(img, options)
img_num = resultimg["result_num"]
sclist = []
snamelist = []
baikeurllist = []
baikedeslist = []
for num in range(img_num):
sc = str(round(resultimg["result"][num]["score"] * 100, 2)) + "%"
sname = resultimg["result"][num]["keyword"]
if resultimg["result"][num]["baike_info"]:
baikeurl = resultimg["result"][num]["baike_info"]["baike_url"]
baikedes = resultimg["result"][num]["baike_info"]["description"]
else:
baikeurl = "#"
baikedes = ""
snamelist.append(sname)
sclist.append(sc)
baikeurllist.append(baikeurl)
baikedeslist.append(baikedes)
imginfo = zip(snamelist, sclist, baikeurllist, baikedeslist)
return render(request, "imginfo.html", locals())
class BaiduApi(Base):
def __init__(self):
super().__init__()
self.APP_ID = secure.DU_CV_API_ID
self.API_KEY = secure.DU_CV_API_KEY
self.SECRET_KEY = secure.DU_CV_SECRET_KEY
# this is the source object to be wrapped
self.baidu_client = AipImageClassify(self.APP_ID, self.API_KEY,
self.SECRET_KEY)
def classify(self):
self.img = self._img_encode(self.img)
return self.baidu_client.advancedGeneral(self.img)
def _img_encode(self,
img_content: str,
coding=config.IMG_ENCODING_PATTERN):
"""
百度的sdk包含了对图片进行处理的相关代码，此处图片编码不做实现
:param img_content:
:param coding:
:return:
"""
return self.img
#coding:utf-8
from aip import AipImageClassify
""" 这里输入你创建应用获得的三个参数"""
APP_ID = '11638563'
API_KEY = 'XsQl0XGRGWeYIN7k52AMGVU4'
SECRET_KEY = 'z53nby7BINknecpiOSCkenPTFtYZUHsx'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
""" 读取图片 """
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
""" 图片为存储在本地的图片，格式不限 """
image = get_file_content('180806-202532.png')
""" 调用通用物体识别 """
print(client.advancedGeneral(image))
from aip import AipImageClassify
import os
""" 填入参数"""
APP_ID = '**'
API_KEY = '**'
SECRET_KEY = '**'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
""" 读取图片 """
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
dish_path = os.getcwd()
dish_path = dish_path + '/object'
folderlist = os.listdir(dish_path)
for folder in folderlist:
filePath=dish_path + '/'+folder
image = get_file_content(filePath)
""" 调用通用物体识别 """
results = client.advancedGeneral(image)
result = results['result'][0]
print(result['keyword'], '\t置信度：', result['score'])
APP_ID = '20103218'
API_KEY = 'sGsoiPGUCC2nyCcrlGN1pneF'
SECRET_KEY = 'ttXvP6pCGcMRVHewFEf1j0HxMi60XV9g'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
""" 读取图片 """
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
image = get_file_content('E:\pycharm\ex2\static\img\img1.jpg')
""" 调用通用物体识别 """
client.advancedGeneral(image)
""" 如果有可选参数 """
options = {}
options["baike_num"] = 5
""" 带参数调用通用物体识别 """
result = client.advancedGeneral(image, options)
print(result)
"""读取对联字典"""
f = open(r"dic.txt", "r")
str = f.read()
temp = str.split(" ")
dic = []
for i in temp:
if i == "":
pass
else:
from aip import AipImageClassify
""" 你的 APPID AK SK """
APP_ID = '23942564'
API_KEY = '7uL42GlUO4mMYnVGxUp8GU8i'
SECRET_KEY = '5CxKfUO9412hbTueg9NMwajx82M3op52'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
""" 读取图片 """
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
image = get_file_content('4.jpg')
""" 调用通用物体识别 """
result = client.advancedGeneral(image)
# print(result)
result = client.advancedGeneral(image)['result']
for i in result:
print(i['keyword'], i['root'])
APP_ID = '16794181'
API_KEY = 'ZfRjnGxm8Uqdfqs3YzL9XGy8'
SECRET_KEY = '1FQUf9D6qRYcd54ZEE0xKAVXYClKoXOb'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
if __name__ == "__main__":
filePath = input('输入图片的路径：')
image = get_file_content(filePath)
data = client.advancedGeneral(image)
if data:
print(data)
result1 = data.get('result')[0]
kind = result1.get('root')
msg = result1.get('keyword')
print(kind, msg)
if '汽车' in kind:
data = client.carDetect(image)
if data:
print(data)
print('*' * 50)
car1 = data.get('result')[0]
carname = car1.get('name')
color = data.get('color_result')
def BaiDu_image_recognize(file_path, recognize_type):
"""
图像识别
:param file_path: 文件路径
:param recognize_type: 识别类型，共12种：
1. 通用图像识别
2. 菜品识别
3. 车辆识别
4. logo商标识别
5. 动物识别
6. 植物识别
7. 图像主体检测
8. 地标识别
9. 食材识别
10. 红酒识别
11. 货币识别
:return:
"""
# TODO 隐私信息
""" 你的 APP_ID API_KEY SECRET_KEY """
app_id = '23899102' # '你的 App ID'
api_key = 'GKHIEq6gVOfp2AeRxfUopSDM' # '你的 Api Key'
secret_key = 'dLrlMlGemQ1oan2OS8GogLDD0dt1HuVI' # '你的 Secret Key'
# 获取百度云操作类对象
client = AipImageClassify(app_id, api_key, secret_key)
image = get_file_content(file_path)
# """ 调用通用物体识别 """
# result = client.dishDetect(image)
# print(result)
""" 如果有可选参数 """
options = {"baike_num": 5}
""" 带参数调用通用物体识别 """
if recognize_type == 1: # 通用图像识别
response = client.advancedGeneral(image, options)
elif recognize_type == 2: # 菜品识别
response = client.dishDetect(image, options)
elif recognize_type == 3: # 车辆识别
response = client.carDetect(image, options)
elif recognize_type == 4: # logo商标识别
response = client.logoSearch(image)
elif recognize_type == 5: # 动物识别
response = client.animalDetect(image, options)
elif recognize_type == 6: # 植物识别
response = client.plantDetect(image, options)
elif recognize_type == 7: # 图像主体检测
response = client.objectDetect(image)
elif recognize_type == 8: # 地标识别
response = client.landmark(image)
# 花卉识别已经移除
# elif recognize_type == 9: # 花卉识别
# response = client.flower(image)
elif recognize_type == 9: # 食材识别
response = client.ingredient(image, options)
elif recognize_type == 10: # 红酒识别
response = client.redwine(image)
elif recognize_type == 11: # 货币识别
response = client.currency(image)
else:
response = None
response = response['result'][0]
return response
from aip import AipImageClassify
APP_ID = '22790464'
API_KEY = '6CeW2kefahGVAl75VHiP2Ig5'
SECRET_KEY = 'xzvLAz6M4M7ZD3AY9flnEZMuHqLFoIe5 '
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
""" 读取图片 """
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
image = get_file_content('C:/Users/Rain/Pictures/01.jpg')
""" 调用通用物体识别 """
client.advancedGeneral(image);
""" 如果有可选参数 """
options = {}
options["baike_num"] = 5
""" 带参数调用通用物体识别 """
resp = client.advancedGeneral(image, options)
print(resp)
class ImgTagExtractor:
def __init__(self, em):
self.em = em
self.currentindex = 0
self._client = AipOcr(APP_ID, API_KEY, SECRET_KEY)
self._imgClient = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
def extractone(self, params):
# self.em.rclog("extractone %s" % params["filename:"])
ok = False
if "filename:" not in params:
self.em.rclog("extractone: no file name")
return (ok, docdata, "", rclexecm.RclExecM.eofnow)
filename = params["filename:"]
# print("filename ", filename)
try:
metadata = pyexiv2.ImageMetadata(filename)
metadata.read()
keys = metadata.exif_keys + metadata.iptc_keys + metadata.xmp_keys
# print("metadata:",keys)
mdic = {}
for k in keys:
# we skip numeric keys and undecoded makernote data
if k != 'Exif.Photo.MakerNote' and not khexre.match(k):
mdic[k] = str(metadata[k].raw_value)
except Exception as err:
self.em.rclog("extractone: extract failed: [%s]" % err)
return (ok, "", "", rclexecm.RclExecM.eofnow)
docdata = b'<html><head>\n'
# print("mdic:", mdic)
ttdata = set()
for k in pyexiv2_titles:
if k in mdic:
ttdata.add(self.em.htmlescape(mdic[k]))
if ttdata:
title = ""
for v in ttdata:
v = v.replace('[', '').replace(']', '').replace("'", "")
title += v + " "
docdata += rclexecm.makebytes("<title>" + title + "</title>\n")
for k in exiv2_dates:
if k in mdic:
# Recoll wants: %Y-%m-%d %H:%M:%S.
# We get 2014:06:27 14:58:47
dt = mdic[k].replace(":", "-", 2)
docdata += b'<meta name="date" content="' + \
rclexecm.makebytes(dt) + b'">\n'
break
for k, v in mdic.items():
if k == 'Xmp.digiKam.TagsList':
docdata += b'<meta name="keywords" content="' + \
rclexecm.makebytes(self.em.htmlescape(mdic[k])) + \
b'">\n'
docdata += b'</head><body><pre>\n'
## TODO should we need?
for k, v in mdic.items():
if k in meta_pyexiv2_keys:
docdata += rclexecm.makebytes(k + " : " + \
self.em.htmlescape(mdic[k]) + "<br />\n")
img_result = self._imgClient.advancedGeneral(
get_file_content(filename))
ocr_result = self._client.basicGeneral(get_file_content(filename))
for item in ocr_result['words_result']:
docdata += rclexecm.makebytes(
self.em.htmlescape(item["words"]) + "<br />\n")
for item in img_result['result']:
docdata += rclexecm.makebytes(
self.em.htmlescape(item["keyword"]) + "<br />\n")
docdata += b'</pre></body></html>'
self.em.setmimetype("text/html")
return (True, docdata, "", rclexecm.RclExecM.eofnext)
###### File type handler api, used by rclexecm ---------->
def openfile(self, params):
self.currentindex = 0
return True
def getipath(self, params):
return self.extractone(params)
def getnext(self, params):
if self.currentindex >= 1:
return (False, "", "", rclexecm.RclExecM.eofnow)
else:
ret = self.extractone(params)
self.currentindex += 1
return ret
class BaiduDetector(object):
def __init__(self, image_path):
self.image_path = image_path
self.image = get_file_content(image_path)
self.client = AipImageClassify(baidu_appid, baidu_apikey,
baidu_secretkey)
self.object_class = ''
self.object_classkeyword = ''
self.result_string = ''
self.cls_string = ''
self.object_keyword = ''
self.baike_des = ''
self.ignore_reply = 0
def config_result(self, result):
print('二级识别')
print(result)
result_arr = result['result']
self.object_keyword = '按照' + self.cls_string + '属性进行二级识别：'
for obj in result_arr:
probability = 0
if 'probability' in obj.keys():
probability = float(obj['probability'])
elif 'score' in obj.keys():
probability = float(obj['score'])
percent = probability * 100.0
if percent == 0:
self.object_keyword = self.object_keyword + '\n' + '可能是：' + obj[
'name']
else:
self.object_keyword = self.object_keyword + '\n' + str(
round(percent, 0)) + '%的可能是：' + obj['name']
# result_best = result_arr[0]
# self.object_keyword = result_best['name']
# baike_info = result_best['baike_info']
# self.baike_des = baike_info['description']
def label_detect(self, label, general_result):
result_arr = general_result['result']
result_best = result_arr[0]
if '车' in label:
print('车')
self.cls_string = '汽车'
result = self.client.carDetect(self.image)
self.config_result(result)
elif '食物' in label:
print('食物')
self.cls_string = '食物'
result = self.client.dishDetect(self.image)
self.config_result(result)
elif 'Logo' in label:
print('Logo')
self.cls_string = 'Logo'
result = self.client.logoSearch(self.image)
self.config_result(result)
elif '动物' in label:
print('动物')
self.cls_string = '动物'
result = self.client.animalDetect(self.image)
self.config_result(result)
elif '植物' in label:
print('植物')
self.cls_string = '植物'
result = self.client.plantDetect(self.image)
self.config_result(result)
elif '地标' in label or '建筑' in label:
print('地标')
self.cls_string = '地标'
result = self.client.landmark(self.image)
print('二级属性')
print(result)
self.object_keyword = ''
result_obj = result['result']
if (result_obj is list):
for obj in result_obj:
self.object_keyword = self.object_keyword + obj[
'landmark'] + '?'
elif (result_obj is dict):
self.object_keyword = self.object_keyword + result_obj[
'landmark'] + '?'
elif '人物' in label:
print('人物')
self.cls_string = '人物'
self.object_keyword = result_best['keyword']
else:
self.object_keyword = result_best['keyword']
def womengrade(self):
f = open("./react_words.json", encoding='utf-8')
map = json.load(f)
womengrade = map['womengrade']
index = random.randint(0, len(womengrade) - 1)
return womengrade[index]
def general_detect(self):
result = self.client.advancedGeneral(self.image)
print('通用识别')
print(result)
result_arr = result['result']
result_best = result_arr[0]
# baike_info = result_best['baike_info']
# self.baike_des = baike_info['description']
label_str = ''
result_str = '图像识别大类：'
self.ignore_reply = 0
for obj in result_arr:
#如果大于20%的几率是文字图，屏幕截图，不回答
score = float(obj['score'])
percent = score * 100.0
keyword = obj['keyword']
if percent > 20 and ('屏幕截图' in keyword or '文字图' in keyword):
self.ignore_reply = 1
result_str = result_str + '\n' + str(round(
percent, 0)) + '%的可能是：' + keyword + '(' + obj['root'] + ')'
label_str = label_str + obj['root'] + '?' + obj['keyword'] + '?'
print('label = ' + label_str)
if self.ignore_reply == 0:
self.result_string = result_str
self.object_class = result_best['root']
self.object_classkeyword = result_best['keyword']
self.label_detect(label_str, result)
else:
print('要忽略显示')
def answer(self):
if self.ignore_reply == 1:
return ''
cls_arr = self.object_class.split('-')
# 二级属性
second_att = ''
if self.object_keyword != '':
second_att = '\n' + self.object_keyword
# answer = '这是'+ self.object_classkeyword +'吧，一种' + cls_arr[len(cls_arr)-1] + second_att
answer = self.result_string + second_att
if '女人' in answer or '美女' in answer:
return self.womengrade()
else:
return answer
# if __name__ == '__main__':
# dectector = BaiduDetector('./car.jpeg')
# dectector.general_detect()
# print(dectector.object_class)
# print(dectector.object_classkeyword)
# print(dectector.object_keyword)
# print(dectector.baike_des)
from aip import AipImageClassify
""" 你的 APPID AK SK """
APP_ID = '15719765'
API_KEY = 'W3gO6OKVcKtGSGtIjN2rTZgW'
SECRET_KEY = '2T1cZrytwBGLLrjFosQjNvSczgIufLg2'
client = AipImageClassify(APP_ID, API_KEY, SECRET_KEY)
""" 读取图片 """
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()
image = get_file_content(
'C:\\Users\\tencon2010\\Desktop\\20150620224348_ajx2z.jpeg')
""" 调用通用物体识别 """
client.advancedGeneral(image)
""" 如果有可选参数 """
options = {}
options["baike_num"] = 5
""" 带参数调用通用物体识别 """
print(client.advancedGeneral(image, options))
