def update(self, image=Image()):
"""
(Image) -> (Image)
Update database image
"""
session = self.session_factory()
imageDB = session.query(ImageDB).filter_by(id=image.id).first()
dic = {}
if (imageDB.disease.id != image.disease.id):
dic['idDisease'] = image.disease.id
if (imageDB.url != image.url):
dic['url'] = image.url
if (imageDB.description != image.description):
dic['description'] = image.description
if (imageDB.source != image.source):
dic['source'] = image.source
if (imageDB.size != image.size):
dic['size'] = image.size
if (dic != {}):
session.query(ImageDB).filter_by(id=image.id).update(dic)
session.commit()
session.flush()
session.refresh(imageDB)
return Image(
imageDB.id,
Disease(
imageDB.disease.id,
Plant(imageDB.disease.plant.id,
imageDB.disease.plant.scientificName,
imageDB.disease.plant.commonName),
imageDB.disease.scientificName, imageDB.disease.commonName),
imageDB.url, imageDB.description, imageDB.source, imageDB.size)
def shot(self, camera):
print("taking shot")
path = '../image.jpg'
camera.capture(path, use_video_port=True)
image = Image(config=self.config, path=path)
image.upload_image()
def user_image_create():
username_of_jwt = get_jwt_identity()
image_id = 1
images = Image.query.order_by(Image.id.desc()).first()
if images is None:
pass
else:
image_id = images.id + 1
if "image" not in request.files:
return abort(400, description="No image")
image = request.files["image"]
if Path(image.filename).suffix not in [".jpg", ".png"]:
return abort(400, description="Invalid file type")
filename = str(image_id) + Path(image.filename).suffix
bucket = boto3.resource("s3").Bucket(current_app.config["AWS_S3_BUCKET"])
key = f"images/user-{username_of_jwt}-image-{filename}"
bucket.upload_fileobj(image, key)
new_image = Image()
new_image.username = username_of_jwt
new_image.path = key
db.session.add(new_image)
db.session.commit()
return jsonify(image_schema.dump(new_image))
def search(self, image=Image(), pageSize=10, offset=0):
"""
(Image, pageSize, offset) -> [Image]
"""
session = self.session_factory()
query = session.query(ImageDB).filter(
or_(ImageDB.url.like('%' + image.url + '%'),
ImageDB.description == image.description,
ImageDB.source == image.source))
content = query.slice(offset, pageSize).all()
total = query.count()
images = []
for imageDB in content:
images.append(
Image(
imageDB.id,
Disease(
imageDB.disease.id,
Plant(imageDB.disease.plant.id,
imageDB.disease.plant.scientificName,
imageDB.disease.plant.commonName),
imageDB.disease.scientificName,
imageDB.disease.commonName), imageDB.url,
imageDB.description, imageDB.source, imageDB.size))
return {'total': total, 'content': images}
def post(self):
file = request.files["image"]
image = Image()
image.image = file
image.image.content_type = "image/png"
image.save()
return "Image saved"
def create(self, analysis=Analysis()):
"""
(Analysis) -> (Analysis)
Add analysis to database
"""
analysisDB = AnalysisDB(analysis=analysis)
session = self.session_factory()
session.add(analysisDB)
session.flush()
session.refresh(analysisDB)
session.commit()
return Analysis(
analysisDB.id,
image=Image(
analysisDB.image.id,
Disease(
analysisDB.image.disease.id,
Plant(analysisDB.image.disease.plant.id,
analysisDB.image.disease.plant.scientificName,
analysisDB.image.disease.plant.commonName),
analysisDB.image.disease.scientificName,
analysisDB.image.disease.commonName), analysisDB.image.url,
analysisDB.image.description, analysisDB.image.source,
analysisDB.image.size),
classifier=Classifier(
analysisDB.classifier.id,
Plant(analysisDB.classifier.plant.id,
analysisDB.classifier.plant.scientificName,
analysisDB.classifier.plant.commonName),
analysisDB.classifier.tag, analysisDB.classifier.path),
user=User(id=analysisDB.user.id,
idType=analysisDB.user.idType,
email=analysisDB.user.email,
username=analysisDB.user.username))
def create(image):
name = image.get("name", None)
id_recipe = image.get("id_recipe", None)
image = Image(None, name, id_recipe)
id_img = ImageDAOImpl.insert(image)
json.dumps(id_img)
return id_img
def getImageBase64(self, image=Image(), imagesDir=""):
"""
(Image, String) -> (Image)
Method used to get image considering plant common name,
disease scientific name, size image and url and
convert it to base64 in url field
"""
size = "large"
if image.size == 1:
size = "thumb"
elif image.size == 2:
size = "medium"
elif image.size == 3:
size = "large"
filepath = "{}/{}/{}/{}/{}".format(
imagesDir, size,
image.disease.plant.commonName.replace(' ', '_').replace(
'(', '_').replace(')', '_'),
image.disease.scientificName.replace(" ", "_").replace(
";",
"").replace("(",
"_").replace(")",
"_").replace("<i>",
"").replace("</i>", ""),
image.url)
fh = open(filepath, 'rb')
content = fh.read()
fh.close()
image.url = base64.encodestring(content).decode('utf-8')
return image
def saveImage(self, image=Image(), imagesDir="", extension=".JPG"):
"""
(Image, str, str) -> (Image)
Method used to save images considering image url field
"""
size = "large"
if image.size == 1:
size = "thumb"
elif image.size == 2:
size = "medium"
elif image.size == 3:
size = "large"
filename = str(uuid.uuid4())
filepath = "{}/{}/{}/{}/{}".format(
imagesDir, size,
image.disease.plant.commonName.replace(' ', '_').replace(
'(', '_').replace(')', '_'),
image.disease.scientificName.replace(" ", "_").replace(
";",
"").replace("(",
"_").replace(")",
"_").replace("<i>",
"").replace("</i>", ""),
filename + extension)
fh = open(filepath, 'wb')
fh.write(base64.decodestring(image.url.encode('utf-8')))
fh.close()
image.url = filename + extension
return image
class ImageCustomResource(Resource):
def __init__(self):
self.parser = reqparse.RequestParser()
self.parser.add_argument('image')
self.args = self.parser.parse_args()
@marshal_with(Image.format())
def post(self):
file = request.files["image"]
image = Image()
image.image = file
image.image.content_type = "image/png"
image.save()
return "Image saved"
def get(self, id):
image = Image.objects.get(id=id)
response = make_response(image.image.read())
response.content_type = "image/png"
return response
def create_images(file_name):
with open(file_name, "r") as f:
# The first line indicates how many images store
images_cnt = f.readline().split()
images_list = []
for i in range(int(images_cnt[0])):
line = f.readline().split()
image = Image(line[0], validator.validate_int_value(line[1]), line[2])
images_list.append(image)
dao.create_images(images_list)
def findAll():
conn = ConnectionDB().getConnection()
cursor = conn.cursor()
try:
images = []
for row in cursor.execute("SELECT * FROM images"):
images.append(Image(row[0], row[1], row[2]))
return images
except sqlite3.Error as error:
print(error.with_traceback())
def findOneById(id_img):
conn = ConnectionDB().getConnection()
cursor = conn.cursor()
try:
cursor.execute('SELECT * FROM images WHERE id = ?', (id_img, ))
row = cursor.fetchone()
image = Image(id_img, row[1], row[2])
return image
except sqlite3.Error as error:
print(error.with_traceback())
def findOneByName(name):
conn = ConnectionDB().getConnection()
cursor = conn.cursor()
try:
cursor.execute('SELECT * FROM images WHERE name = ?', (name, ))
row = cursor.fetchone()
image = Image(row[0], name, row[2])
return image
except sqlite3.Error as error:
print(error.with_traceback())
def create(self, image=Image()):
"""
(Image) -> (Image)
Add image to database
"""
imageDB = ImageDB(image=image)
session = self.session_factory()
session.add(imageDB)
session.flush()
session.refresh(imageDB)
session.commit()
return Image(
imageDB.id,
Disease(
imageDB.disease.id,
Plant(imageDB.disease.plant.id,
imageDB.disease.plant.scientificName,
imageDB.disease.plant.commonName),
imageDB.disease.scientificName, imageDB.disease.commonName),
imageDB.url, imageDB.description, imageDB.source, imageDB.size)
def create(self, analysisResult=AnalysisResult()):
"""
(AnalysisResult) -> (AnalysisResult)
Add analysis result to database
"""
analysisResultDB = AnalysisResultDB(analysisResult=analysisResult)
session = self.session_factory()
session.add(analysisResultDB)
session.flush()
session.commit()
session.refresh(analysisResultDB)
return AnalysisResult(
analysisResultDB.id,
Analysis(
analysisResultDB.analysis.id,
Image(
analysisResultDB.analysis.image.id,
Disease(
analysisResultDB.analysis.image.disease.id,
Plant(
analysisResultDB.analysis.image.disease.plant.id,
analysisResultDB.analysis.image.disease.plant.
scientificName, analysisResultDB.analysis.image.
disease.plant.commonName),
analysisResultDB.analysis.image.disease.scientificName,
analysisResultDB.analysis.image.disease.commonName),
analysisResultDB.analysis.image.url,
analysisResultDB.analysis.image.description,
analysisResultDB.analysis.image.source,
analysisResultDB.analysis.image.size),
Classifier(
analysisResultDB.analysis.classifier.id,
Plant(
analysisResultDB.analysis.classifier.plant.id,
analysisResultDB.analysis.classifier.plant.
scientificName,
analysisResultDB.analysis.classifier.plant.commonName),
analysisResultDB.analysis.classifier.tag,
analysisResultDB.analysis.classifier.path),
user=User(id=analysisResultDB.analysis.user.id,
idType=analysisResultDB.analysis.user.idType,
email=analysisResultDB.analysis.user.email,
username=analysisResultDB.analysis.user.username)),
Disease(
analysisResultDB.disease.id,
Plant(analysisResultDB.disease.plant.id,
analysisResultDB.disease.plant.scientificName,
analysisResultDB.disease.plant.commonName),
analysisResultDB.disease.scientificName,
analysisResultDB.disease.commonName), analysisResultDB.score,
analysisResultDB.frame)
def searchByID(self, id):
"""
(int) -> (AnalysisResult)
Search analysis result by ID
"""
session = self.session_factory()
analysisResultDB = session.query(AnalysisResultDB).get(id)
if (analysisResultDB is None):
raise Exception("AnalysisResults not found!")
return AnalysisResult(
analysisResultDB.id,
Analysis(
analysisResultDB.analysis.id,
Image(
analysisResultDB.analysis.image.id,
Disease(
analysisResultDB.analysis.image.disease.id,
Plant(
analysisResultDB.analysis.image.disease.plant.id,
analysisResultDB.analysis.image.disease.plant.
scientificName, analysisResultDB.analysis.image.
disease.plant.commonName),
analysisResultDB.analysis.image.disease.scientificName,
analysisResultDB.analysis.image.disease.commonName),
analysisResultDB.analysis.image.url,
analysisResultDB.analysis.image.description,
analysisResultDB.analysis.image.source,
analysisResultDB.analysis.image.size),
Classifier(
analysisResultDB.analysis.classifier.id,
Plant(
analysisResultDB.analysis.classifier.plant.id,
analysisResultDB.analysis.classifier.plant.
scientificName,
analysisResultDB.analysis.classifier.plant.commonName),
analysisResultDB.analysis.classifier.tag,
analysisResultDB.analysis.classifier.path),
user=User(id=analysisResultDB.analysis.user.id,
idType=analysisResultDB.analysis.user.idType,
email=analysisResultDB.analysis.user.email,
username=analysisResultDB.analysis.user.username)),
Disease(
analysisResultDB.disease.id,
Plant(analysisResultDB.disease.plant.id,
analysisResultDB.disease.plant.scientificName,
analysisResultDB.disease.plant.commonName),
analysisResultDB.disease.scientificName,
analysisResultDB.disease.commonName), analysisResultDB.score,
analysisResultDB.frame)
def delete(self, image=Image()):
"""
(Image) -> (bool)
Delete database image
"""
status = False
session = self.session_factory()
imageDB = session.query(ImageDB).filter_by(id=image.id).first()
session.delete(imageDB)
session.commit()
session.flush()
if (not session.query(ImageDB).filter_by(id=imageDB.id).count()):
status = True
session.close()
return status
def searchByID(self, id):
"""
(Int) -> (Image)
Method used to get image object by ID
"""
session = self.session_factory()
imageDB = session.query(ImageDB).get(id)
return Image(
imageDB.id,
Disease(
imageDB.disease.id,
Plant(imageDB.disease.plant.id,
imageDB.disease.plant.scientificName,
imageDB.disease.plant.commonName),
imageDB.disease.scientificName, imageDB.disease.commonName),
imageDB.url, imageDB.description, imageDB.source, imageDB.size)
def searchByID(self, id):
"""
(int) -> (Analysis)
Search analysis by ID
"""
session = self.session_factory()
analysisDB = session.query(AnalysisDB).get(id)
if (analysisDB is None):
raise Exception("Analysis not found!")
results = []
for result in analysisDB.analysis_results:
results.append(
AnalysisResult(
id=result.id,
disease=Disease(
id=result.disease.id,
scientificName=result.disease.scientificName,
commonName=result.disease.commonName),
frame=result.frame,
score=result.score))
return Analysis(
id=analysisDB.id,
image=Image(
analysisDB.image.id,
Disease(
analysisDB.image.disease.id,
Plant(analysisDB.image.disease.plant.id,
analysisDB.image.disease.plant.scientificName,
analysisDB.image.disease.plant.commonName),
analysisDB.image.disease.scientificName,
analysisDB.image.disease.commonName), analysisDB.image.url,
analysisDB.image.description, analysisDB.image.source,
analysisDB.image.size),
classifier=Classifier(
analysisDB.classifier.id,
Plant(analysisDB.classifier.plant.id,
analysisDB.classifier.plant.scientificName,
analysisDB.classifier.plant.commonName),
analysisDB.classifier.tag, analysisDB.classifier.path),
analysis_results=results,
user=User(id=analysisDB.user.id,
idType=analysisDB.user.idType,
email=analysisDB.user.email,
username=analysisDB.user.username))
def update_rooms_images(room_id):
data = request.get_json()
images_dict = data['images']
room = Room.query.filter_by(id=room_id).first()
if room is None:
return jsonify({'message': 'ERROR'})
Image.query.filter_by(room_id=room.id).delete()
for i in images_dict:
image = Image(i['src'])
room.images.append(image)
db.session.commit()
return jsonify({'message': 'SUCCESS'})
def save_image(source, file_name, from_type='string'):
""" Saves an image to disk.
# Arguments
source: image to be saved.
from_type: format of image to be saved.
# Raises
NotImplementedError: if from_type is not supported.
"""
image = Image()
db.session.add(image)
db.session.flush()
image.name = file_name
image.path = f'uploads/images/{image.id}_{file_name}'
image.thumbnail = f'uploads/thumbnails/{image.id}_{file_name}'
if from_type == 'np_array':
cv2.imwrite(image.path, source)
elif from_type == 'string':
with open(image.path, 'wb+') as f:
f.write(source.read())
else:
raise NotImplementedError(f'Support for {from_type} is currenlty not supported!')
prediction, label, class_index = app.config['MODEL'].predict_from_path(image.path)
image.label = label
image.prediction = prediction
image.class_index = int(class_index)
thumbnail = cv2.imread(image.path)
thumbnail = cv2.resize(thumbnail, (100, 100))
cv2.imwrite(image.thumbnail, thumbnail)
db.session.add(image)
db.session.commit()
def create_recipe(recipe):
name_recipe = recipe.get("name_recipe", None)
nbr_person = recipe.get("nbr_person", None)
id_src = recipe.get("id_src", None)
if id_src == 0:
id_src = None
recipe_to_insert = Recipe(None, name_recipe, nbr_person, id_src)
id_recipe = RecipeDAOimpl.insert(recipe_to_insert)
for img in recipe.get("images", None):
ImageDAOImpl.insert(Image(None, img.get("name", None), id_recipe))
for id_cat in recipe.get("id_cats", None):
RecipeDAOimpl.addCategory(id_recipe, id_cat)
for id_tool in recipe.get("id_tools", None):
RecipeDAOimpl.addTool(id_recipe, id_tool)
for section in recipe.get("sections", None):
SectionsRestController.add_section(id_recipe, section)
def get_random_data():
rooms_number = 100
rooms = []
for i in range(rooms_number):
room = Room(random.choice(list(RoomTypes)), random.randint(1, 5),
random.randint(1, 5), random.randint(1, 10),
bool(random.getrandbits(1)), "desc",
bool(random.getrandbits(1)), bool(random.getrandbits(1)),
bool(random.getrandbits(1)), bool(random.getrandbits(1)),
bool(random.getrandbits(1)), bool(random.getrandbits(1)),
bool(random.getrandbits(1)), bool(random.getrandbits(1)),
bool(random.getrandbits(1)), bool(random.getrandbits(1)),
37.9754983 + random.uniform(-1, 1),
23.7356671 + random.uniform(-1, 1), "address", "info",
random.randint(1, 5), random.randint(23, 300),
random.uniform(10, 70), random_sentence(3),
random.randint(6, 20), random.randint(1, 3), 7)
for y in range(10):
room.images.append(
Image('https://picsum.photos/id/' + str(i * 10 + y) +
'/400/400'))
room.reviews.append(
Review(random.uniform(1, 5), random_sentence(3),
random_sentence(10), 4))
start_date = datetime.now()
for x in range(10):
next_date = start_date + timedelta(days=random.randint(2, 30))
room.reservations.append(
Reservation(start_date, next_date, Status.rented))
start_date = next_date + timedelta(days=random.randint(20, 40))
next_date = None
room.reservations.append(
Reservation(start_date, next_date, Status.not_available))
db.session.add(room)
db.session.commit()
def __init__(self,
id=0,
image=Image(),
classifier=Classifier(),
analysis_results=[],
user=User()):
"""Analisys model constructor
Args:
id: Integer number to identification
image: Image object that has been used for this Analysis
classifier: Classifier object that has been used for this Analysis
analysis_results: A list of AnalysisResult object with all results
user: User which perform this analysis
"""
self.id = id
self.image = image
self.classifier = classifier
self.analysis_results = analysis_results
self.user = user
def update(self, analysis=Analysis()):
"""
(Analysis) -> (Analysis)
update analysis table
"""
session = self.session_factory()
analysisDB = session.query(AnalysisDB).filter_by(
id=analysis.id).first()
dic = {}
if (analysisDB.idImage != analysis.image.id):
dic['idImage'] = analysis.image.id
if (analysisDB.idClassifier != analysis.classifier.id):
dic['idClassifier'] = analysis.classifier.id
if (dic != {}):
session.query(AnalysisDB).filter_by(id=analysis.id).update(dic)
session.commit()
session.flush()
session.refresh(analysisDB)
return Analysis(
analysisDB.id,
image=Image(
analysisDB.image.id,
Disease(
analysisDB.image.disease.id,
Plant(analysisDB.image.disease.plant.id,
analysisDB.image.disease.plant.scientificName,
analysisDB.image.disease.plant.commonName),
analysisDB.image.disease.scientificName,
analysisDB.image.disease.commonName), analysisDB.image.url,
analysisDB.image.description, analysisDB.image.source,
analysisDB.image.size),
classifier=Classifier(
analysisDB.classifier.id,
Plant(analysisDB.classifier.plant.id,
analysisDB.classifier.plant.scientificName,
analysisDB.classifier.plant.commonName),
analysisDB.classifier.tag, analysisDB.classifier.path),
user=User(id=analysisDB.user.id,
idType=analysisDB.user.idType,
email=analysisDB.user.email,
username=analysisDB.user.username))
def search(self, analysis=Analysis(), pageSize=10, offset=0):
"""
(Analysis, pageSize, offset) -> [Analysis]
search by analysis
"""
session = self.session_factory()
query = session.query(AnalysisDB).filter(
and_(AnalysisDB.idImage == analysis.image.id,
AnalysisDB.idClassifier == analysis.classifier.id))
content = query.slice(offset, pageSize).all()
total = query.count()
analyses = []
for analysisDB in content:
analyses.append(
Analysis(
analysisDB.id,
image=Image(
analysisDB.image.id,
Disease(
analysisDB.image.disease.id,
Plant(
analysisDB.image.disease.plant.id,
analysisDB.image.disease.plant.scientificName,
analysisDB.image.disease.plant.commonName),
analysisDB.image.disease.scientificName,
analysisDB.image.disease.commonName),
analysisDB.image.url, analysisDB.image.description,
analysisDB.image.source, analysisDB.image.size),
classifier=Classifier(
analysisDB.classifier.id,
Plant(analysisDB.classifier.plant.id,
analysisDB.classifier.plant.scientificName,
analysisDB.classifier.plant.commonName),
analysisDB.classifier.tag, analysisDB.classifier.path),
user=User(id=analysisDB.user.id,
idType=analysisDB.user.idType,
email=analysisDB.user.email,
username=analysisDB.user.username)))
return {'total': total, 'content': analyses}
def saveImage(self, image=Image(), imagesDir="", extension=".JPG"):
"""
(Image, str, str) -> (Image)
Method used to save images considering image url field
"""
size = "large"
if image.size == 1:
size = "thumb"
elif image.size == 2:
size = "medium"
elif image.size == 3:
size = "large"
filename = str(uuid.uuid4())
filepath = "{}/{}/{}/{}/{}".format(
imagesDir, size,
image.disease.plant.commonName.replace(' ', '_').replace(
'(', '_').replace(')', '_'),
image.disease.scientificName.replace(" ", "_").replace(
";",
"").replace("(",
"_").replace(")",
"_").replace("<i>",
"").replace("</i>", ""),
filename + extension)
if not os.path.exists(os.path.dirname(filepath)):
try:
os.makedirs(os.path.dirname(filepath))
except Exception as exc:
raise exc
nparr = np.fromstring(base64.b64decode(image.url), np.uint8)
cv2.imwrite(filepath, cv2.imdecode(nparr, cv2.IMREAD_COLOR))
image.url = filepath
return image
def seed_tables():
# User
for i in range(10):
user = User()
user.id = i
user.displayname = f"testuser{i}"
user.email = f"TestEmail{i}@test.com"
user.username = f"TestUserName{i}"
user.password = bcrypt.generate_password_hash("testpassword").decode("utf-8")
db.session.add(user)
db.session.commit()
print("Seeded Table: user")
# Artist
artists = []
for i in range(10):
artist = Artist()
artist.name = f"TestArtistName{i}"
db.session.add(artist)
artists.append(artist)
db.session.commit()
print("Seeded Table: artist")
# Image
for i in range(20):
image = Image()
image.url = f"TestURL{i}"
image.height = choice(range(600, 1200))
image.width = choice(range(600, 1200))
db.session.add(image)
db.session.commit()
print("Seeded Table: images")
def moods_table_creation():
moods = Moods()
moods.amusement = choice(range(1, 101))
moods.joy = choice(range(1, 101))
moods.beauty = choice(range(1, 101))
moods.relaxation = choice(range(1, 101))
moods.sadness = choice(range(1, 101))
moods.dreaminess = choice(range(1, 101))
moods.triumph = choice(range(1, 101))
moods.anxiety = choice(range(1, 101))
moods.scariness = choice(range(1, 101))
moods.annoyance = choice(range(1, 101))
moods.defiance = choice(range(1, 101))
moods.feelingpumped = choice(range(1, 101))
db.session.add(moods)
db.session.commit()
return moods
# Tracks
for i in range(30):
track = Tracks()
track.trackname = f"TestTrackName{i}"
track.artist_id = choice(artists).id
track.moods_id = moods_table_creation().id
track.trackurl = f"TestTrackURL{i}"
db.session.add(track)
db.session.commit()
print("Seeded Table: tracks")
def organize(database, workdir, output, size):
""" (str, str, str, str) -> Bool
Method used to execute organization of images
"""
filehandler = open(output, "a")
logging.info("CONNECTING DATABASE {}".format(database))
conn = sqlite3.connect(database)
cursor = conn.cursor()
plants = []
scriptPlants = ""
scriptDiseases = ""
scriptImages = ""
for row in cursor.execute(
"SELECT id, crop_common_name, crop_scientific_name, disease_common_name, disease_scientific_name, url, description, metadata FROM ANNOTATIONS;"
):
oldAnnotation = OldAnnotation(row[0], row[1], row[2], row[3], row[4],
row[5], row[6], row[7])
if (oldAnnotation.url == "" or oldAnnotation.cropScientificName == ""):
continue
indexPlant = searchPlantByScientificName(plants,
oldAnnotation.cropCommonName)
plant = Plant()
if (indexPlant == -1):
plant = Plant(scientificName=oldAnnotation.cropScientificName,
commonName=oldAnnotation.cropCommonName,
diseases=[])
logging.info("CREATING {}".format(plant.commonName).replace(
" ", "_").replace(";", "").replace("(", "_").replace(
")", "_").replace("<i>", "").replace("</i>", ""))
os.system("mkdir -p " + workdir + "/" + plant.commonName.replace(
" ", "_").replace(";", "").replace("(", "_").replace(
")", "_").replace("<i>", "").replace("</i>", ""))
#filehandler.write("INSERT INTO PLANTS(scientific_name, common_name) VALUES ('{}', '{}')\n".format(plant.scientificName, plant.commonName))
scriptPlants += "INSERT INTO PLANTS(scientific_name, common_name) VALUES ('{}', '{}');\n".format(
plant.scientificName, plant.commonName)
else:
logging.info("index: {} - plant: {}".format(
str(indexPlant), plants[indexPlant].scientificName))
plant = plants[indexPlant]
disease = Disease(plant=plant,
commonName=oldAnnotation.diseaseCommonName,
scientificName=oldAnnotation.diseaseScientificName)
if (oldAnnotation.diseaseCommonName == ""
or oldAnnotation.diseaseScientificName == ""
or "Healthy" in oldAnnotation.description
or "healthy" in oldAnnotation.description):
disease.scientificName = "healthy"
disease.commonName = "healthy"
indexDisease = searchDiseaseByScientificName(disease.plant,
disease.scientificName)
logging.info("DISEASE: {} - {} - {}".format(disease.scientificName,
plant.scientificName,
indexDisease))
if (indexDisease == -1):
logging.info("CREATING {}/{}".format(
plant.commonName.replace(" ", "_").replace(";", "").replace(
"(", "_").replace(")",
"_").replace("<i>",
"").replace("</i>", ""),
disease.scientificName.replace(" ", "_").replace(
";", "").replace("(", "_").replace(")", "_").replace(
"<i>", "").replace("</i>", "")))
os.system("mkdir -p " + workdir + "/" + plant.commonName.replace(
" ", "_").replace(";", "").replace("(", "_").replace(
")", "_").replace("<i>", "").replace("</i>", "") + "/" +
disease.scientificName.replace(" ", "_").replace(
";", "").replace("(", "_").replace(")", "_").replace(
"<i>", "").replace("</i>", ""))
scriptDiseases += "INSERT INTO DISEASES(id_plant, scientific_name, common_name) VALUES ((SELECT id FROM PLANTS WHERE scientific_name = '{}' LIMIT 1),'{}', '{}');\n".format(
plant.scientificName, disease.scientificName,
disease.commonName)
#filehandler.write("INSERT INTO DISEASES(id, scientific_name, common_name) VALUES ((SELECT id FROM PLANTS WHERE scientific_name = '{}' LIMIT 1),'{}', '{}')\n".format(disease.plant.scientificName, disease.scientificName, disease.commonName))
else:
disease = plant.diseases[indexDisease]
image = Image(disease=disease,
url=oldAnnotation.url.replace("<i>",
"").replace("</i>", ""),
description=oldAnnotation.description,
source=oldAnnotation.metadata)
regex = re.compile("[\w]+/[\w,;\-]*\/([\w\.;\-,]+)+")
logging.info(image.url)
if (not regex.match(image.url) == None):
logging.info(image.url)
image.url = regex.match(image.url).group(1)
if ("large" in image.url):
continue
else:
logging.info(image.url)
continue
if ("large" in disease.scientificName):
continue
logging.info("CREATING {}/{}/{} ".format(
plant.commonName.replace(" ", "_"),
disease.scientificName.replace(" ", "_"),
image.url.replace(" ", "_")))
os.makedirs(workdir + "/" + plant.commonName.replace(" ", "_").replace(
";", "").replace("(", "_").replace(")", "_").replace(
"<i>", "").replace("</i>", "") +
"/" + disease.scientificName.replace(" ", "_").replace(
";", "").replace("(", "_").replace(")", "_").replace(
"<i>", "").replace("</i>", "") + "/",
exist_ok=True)
dir1 = workdir + "/" + plant.commonName.replace(" ", "_").replace(
"(", "_").replace(")", "_").replace("<i>", "").replace(
"</i>", "") + "/" + image.url
dir2 = workdir + "/" + plant.commonName.replace(" ", "_").replace(
";", "").replace(
"(", "_").replace(")", "_").replace("<i>", "").replace(
"</i>", "") + "/" + disease.scientificName.replace(
" ", "_").replace(";", "").replace("(", "_").replace(
")", "_").replace("<i>", "").replace(
"</i>", "") + "/" + image.url
logging.info(dir1)
logging.info(dir2)
if ("large" in dir2):
continue
try:
shutil.copyfile(dir1, dir2)
except FileNotFoundError:
continue
#filehandler.write("INSERT INTO IMAGES(id_disease, url, description, source) VALUES ((SELECT id FROM DISEASES WHERE scientific_name = '{}' AND id_plant = (SELECT id FROM PLANTS WHERE scientific_name = '{}' LIMIT 1) LIMIT 1), '{}', '{}', '{}')\n".format(image.disease.scientificName, image.disease.plant.scientificName, image.url, image.description, image.source))
scriptImages += "INSERT INTO IMAGES(id_disease, url, description, source, size) VALUES ((SELECT id FROM DISEASES WHERE scientific_name = '{}' AND id_plant = (SELECT id FROM PLANTS WHERE scientific_name = '{}' LIMIT 1) LIMIT 1), '{}', '{}', '{}', (SELECT id FROM TYPES WHERE value='{}' AND description='image-size' LIMIT 1));\n".format(
disease.scientificName, plant.scientificName, image.url,
image.description, image.source, size)
disease.images.append(image)
if (indexDisease == -1):
plant.diseases.append(disease)
else:
plant.diseases[indexDisease] = disease
if (indexPlant == -1):
plants.append(plant)
else:
plants[indexPlant] = plant
filehandler.write(scriptPlants)
filehandler.write(scriptDiseases)
filehandler.write(scriptImages)
filehandler.close()
return True