def pegar_desenho(Escolha="flower"):
qd = QuickDrawData() #define todos o dataset disponivel
arquivo_str = '' #começa uma string onde as informaçoes serão escritas
if Escolha != "random":
desenho = qd.get_drawing(Escolha) #desenho especifico
else:
desenho = qd.get_drawing(random.choice(
qd.drawing_names)) #desenho aleatorio
desenho.image.save("Desenho.png")
data_array = desenho.image_data #data bruto
print(data_array)
print(len(data_array))
#number of strokes
arquivo_str += "{} ".format(len(data_array))
for stroke in desenho.strokes:
#tamanho do stroke
arquivo_str += "{} ".format(len(stroke))
print(len(stroke))
for x, y in stroke:
#stroke
arquivo_str += "{} {} ".format(x, y)
return arquivo_str #devolve a string construida
def test_get_specific_drawing():
qd = QuickDrawData()
# get the first anvil drawing and test the values
d = qd.get_drawing("anvil", 0)
assert d.name == "anvil"
assert d.key_id == 5355190515400704
assert d.recognized == True
assert d.countrycode == "PL"
assert d.timestamp == 1488368345
# 1 stroke, 2 x,y coords, 33 points
assert len(d.image_data) == 1
assert len(d.image_data[0]) == 2
assert len(d.image_data[0][0]) == 33
assert len(d.image_data[0][1]) == 33
assert d.no_of_strokes == 1
assert len(d.strokes) == 1
assert len(d.strokes[0]) == 33
assert len(d.strokes[0][0]) == 2
assert isinstance(d.image, Image)
assert isinstance(
d.get_image(stroke_color=(10, 10, 10),
stroke_width=4,
bg_color=(200, 200, 200)), Image)
def find(different_object, the_object, closer, K):
# closer can be True or False. If True, it means closest. If False, it means farthest.
the_point = the_dict.get(the_object)
distance = []
coordinates = latent_dictionary.get(different_object)
for i in range(len(coordinates[0])):
xy = [coordinates[0][i], coordinates[1][i]]
dist = dstnc.euclidean(the_point, xy)
distance.append(dist)
for M in range(K):
if closer:
the_distance = min(distance)
elif not closer:
the_distance = max(distance)
for i in range(len(distance)):
if distance[i] == the_distance:
index = i
break
coordinate = [coordinates[0][index], coordinates[1][index]]
for key in id_vector:
if id_vector.get(key) == coordinate:
the_id = key
break
qd = QuickDrawData()
doodle = qd.get_drawing(different_object)
while not doodle.key_id == the_id:
doodle = qd.get_drawing(different_object)
found = True
if found:
DEFAULT_SIZE_WHITE_CHANNEL = (1000, 1000, 1)
canvas = np.ones(DEFAULT_SIZE_WHITE_CHANNEL, dtype="uint8") * 255
cv2.namedWindow('Window')
my_stroke_list = doodle.image_data
for N in my_stroke_list:
x_list = N[0]
y_list = N[1]
for point in range((len(x_list) - 1)):
cv2.line(canvas, (x_list[point], y_list[point]),
(x_list[point + 1], y_list[point + 1]), (0, 0, 0),
2)
cv2.imwrite(
"./png_sketches/latent_png/" + different_object + "_" +
the_object + "_" + str(closer) + "_" + str(M) + ".png", canvas)
distance.pop(index)
coordinates[0].pop(index)
coordinates[1].pop(index)
else:
print("Image cannot be found.")
def test_anvil():
qd = QuickDrawData()
anvil = qd.get_drawing("anvil")
# anvil.image.show()
trans = transforms.Compose([transforms.Resize(64), transforms.ToTensor()])
anvil_tensor = transforms.ToTensor()(anvil.image)
down_sized_anvil = trans(anvil.image)
plt.imshow(anvil_tensor.permute(1, 2, 0))
plt.show()
plt.imshow(down_sized_anvil.permute(1, 2, 0));
plt.show()
def loadNdjson(tag, scale, pos, index=None, immutable=False):
try:
if tag not in Status.cache:
qd = QuickDrawData(True)
anvil = qd.get_drawing(tag, index)
Status.cache[tag] = list(anvil.strokes)
if not immutable:
Status.objects[tag] = [scale, pos[0], pos[1]]
if tag in Status.cache and not immutable:
Status.objects[tag] = [scale, pos[0], pos[1]]
except:
pass
def __init__(self, datasize, classname=None, transforms=None):
self.datasize = datasize
self.qd = QuickDrawData(max_drawings=self.datasize)
if classname is None:
self.classname = self.qd.drawing_names
else:
self.classname = classname
self.transfroms = transforms
self.label_ids = self.getLabelID(self.classname, self.datasize)
self.img_ids = self.getImageID(self.classname, self.datasize)
class Quickdraw(Dataset):
def __init__(self, datasize, classname=None, transforms=None):
self.datasize = datasize
self.qd = QuickDrawData(max_drawings=self.datasize)
if classname is None:
self.classname = self.qd.drawing_names
else:
self.classname = classname
self.transfroms = transforms
self.label_ids = self.getLabelID(self.classname, self.datasize)
self.img_ids = self.getImageID(self.classname, self.datasize)
def getLabelID(self, classname, datasize):
label_ids = []
for i in range(len(classname)):
label_id = [i for _ in range(datasize)]
label_ids.append(label_id)
label_ids = [element for sublist in label_ids for element in sublist]
return label_ids
def getImageID(self, classname, datasize):
img_ids = []
for i in range(len(classname)):
for j in range(datasize):
img = self.qd.get_drawing(classname[i], index=j)
img_ids.append(img.image)
return img_ids
def __getitem__(self, idx):
return self.img_ids[idx], self.label_ids[idx]
def __len__(self):
return self.datasize * len(self.classname)
def bad_sketch(keyword: str) -> str:
"""
Input a noun you want a sketch of, and if Google Quickdraw finds it,
it will save a random doodle of it to keyword.gif, and return the filepath.
"""
qd = QuickDrawData()
if keyword is not None:
keyword = keyword.lower()
if keyword == "person":
keyword = "smiley face"
try:
key = qd.get_drawing(keyword)
filepath = "keyword.gif"
key.image.save(filepath)
return filepath
except ValueError:
return "blank.png"
class QuickDrawDataset(data.Dataset):
def __init__(self, root, classes, transform):
self.classes = classes
self.labels = torch.arange(len(classes))
self.transform = transform
self.qdd = QuickDrawData(recognized=True, max_drawings=10000, cache_dir=root)
self.qdd.load_drawings(classes)
def __getitem__(self, idx):
c = self.classes[idx%len(self.classes)]
label = self.labels[idx%len(self.classes)]
img = self.qdd.get_drawing(c).image
if self.transform:
img = self.transform(img)
return img, label
def __len__(self):
return 10000
def get_array_numpy_images():
"""returns labels, ndarry (shape (~, 28, 28))"""
# max_drawings -- maximum number of drawings to be loaded into memory,
# defaults to 1000 (3 minutes)
qd = QuickDrawData(max_drawings=1000)
# LIST OBJECT
drawing_names = qd.drawing_names
# LABELS
list_of_labels = []
# just append your arrays to a Python list and convert it at the end;
# the result is simpler and faster
list_of_np = []
for label in drawing_names:
# QuickDrawDataGroup Object
qd_data_group = qd.get_drawing_group(label)
# QuickDrawing Object
for drawing in qd_data_group.drawings:
list_of_labels.append(label)
# PIL IMAGE
PIL_im = drawing.image.convert('L').resize((28, 28),
Image.ANTIALIAS)
nump_im = np.array(PIL_im)
list_of_np.append(nump_im)
# convert to ndarray
array_of_np = np.asarray(list_of_np)
array_of_labels = np.asarray(list_of_labels)
print("IMAGES SHAPE ", array_of_np.shape)
print("LABELS SHAPE ", array_of_labels.shape)
np.save("images-new.npy", array_of_np)
np.save("labels-new.npy", array_of_labels)
def test_load_drawings():
qd = QuickDrawData()
qd.load_drawings(["anvil", "ant"])
assert qd.loaded_drawings == ["anvil", "ant"]
qd.get_drawing("angel")
assert qd.loaded_drawings == ["anvil", "ant", "angel"]
def test_get_random_drawing():
qd = QuickDrawData()
d = qd.get_drawing("anvil", 0)
assert d.name == "anvil"
assert isinstance(d.key_id, int)
assert isinstance(d.recognized, bool)
assert isinstance(d.timestamp, int)
assert isinstance(d.countrycode, str)
assert isinstance(d.image_data, list)
assert len(d.image_data) == d.no_of_strokes
assert isinstance(d.strokes, list)
assert len(d.strokes) == d.no_of_strokes
for stroke in d.strokes:
for point in stroke:
assert len(point) == 2
assert isinstance(d.image, Image)
assert isinstance(
d.get_image(stroke_color=(10, 10, 10),
stroke_width=4,
bg_color=(200, 200, 200)), Image)
def test_unrecognized_data():
qdg = QuickDrawData(recognized=False).get_drawing_group("anvil")
assert qdg.drawing_count == 1000
rec = 0
unrec = 0
for drawing in qdg.drawings:
if drawing.recognized:
rec += 1
else:
unrec += 1
assert rec == 0
assert unrec == qdg.drawing_count
def test_search_drawings():
qd = QuickDrawData()
# test a search with no criteria returns 1000 results
r = qd.search_drawings("anvil")
assert len(r) == 1000
# test a recognized search
r = qd.search_drawings("anvil", recognized=True)
for d in r:
assert d.recognized
r = qd.search_drawings("anvil", recognized=False)
for d in r:
assert not d.recognized
# test a country search
r = qd.search_drawings("anvil", countrycode="US")
for d in r:
assert d.countrycode == "US"
# pull first drawing
key_id = r[0].key_id
timestamp = r[0].timestamp
# test key_id search
r = qd.search_drawings("anvil", key_id=key_id)
for d in r:
assert d.key_id == key_id
# test timestamp search
r = qd.search_drawings("anvil", timestamp=timestamp)
for d in r:
assert d.timestamp == timestamp
# test a compound search of recognized and country code
r = qd.search_drawings("anvil", recognized=True, countrycode="US")
for d in r:
assert d.recognized
assert d.countrycode == "US"
def __init__(self,
recognized: Optional[bool] = None,
transform: Callable[[QuickDrawing], torch.Tensor] = None):
self.qd = QuickDrawData()
self.qd_class_names = self.qd.drawing_names
# dictionary of QuickDrawDataGroups based on all possible names, loads 1000 examples from each class, but can
# be changed by specifying max_drawings
self.qd_DataGroups = {
name: QuickDrawDataGroup(name, recognized=recognized)
for name in self.qd_class_names
}
if transform is None:
self.transform = lambda x: x
else:
self.transform = transform
def get_drawing(self, recognized=True):
dirname = os.path.dirname(__file__)
cache_dir = os.path.join(dirname, '.quickdrawcache')
qd = QuickDrawData(max_drawings=1, cache_dir=cache_dir)
group_name = random.choice(qd.drawing_names)
qd.load_drawings([group_name])
drawing_data = qd.get_drawing(group_name)
while drawing_data.recognized != recognized:
group_name = random.choice(qd.drawing_names)
qd.load_drawings([group_name])
drawing_data = qd.get_drawing(group_name)
drawing_size = drawing_data.get_image().size
drawing = Image.new('RGB', drawing_size, 'white')
draw = ImageDraw.Draw(drawing)
frame = copy.deepcopy(drawing)
frames = []
for stroke in drawing_data.strokes:
draw.line(stroke, 'black')
frame = copy.deepcopy(drawing)
frames.append(frame)
return frames, drawing_data
def find_doodle():
label = request.args.get('label')
index = request.args.get('index')
# label이 labels.txt에 존재하는지 확인
# label에 맞는 낙서 img를 찾아서 key, img, status 보내기
try:
doodle = QuickDrawData().get_drawing(label, int(index))
except:
return jsonify({'success': False})
print(TEMP_DIR)
filename = '%s_%s.png' % (
label,
index,
)
doodle.image.save(os.path.join(TEMP_DIR, filename))
return send_from_directory(TEMP_DIR, filename)
def draw_doodle(self, img, label, d_w0, d_h0, d_w, d_h):
idx = random.randrange(0, 999)
self.random_Key = idx
doodle = QuickDrawData().get_drawing(label, idx)
# 낙서 그릴때 dobot_coord.txt도 동시에 만든다.
if self.d_strokes is None:
self.d_strokes = []
# with open(self.OUTPUT_FILE, 'w') as f:
for stroke in doodle.strokes:
d_points = []
for i in range(0, len(stroke) - 1):
x = int(d_w * stroke[i][0] / 255) + d_w0
y = int(d_h * stroke[i][1] / 255) + d_h0
pre_x = int(d_w * stroke[i + 1][0] / 255) + d_w0
pre_y = int(d_h * stroke[i + 1][1] / 255) + d_h0
cv2.line(img, (pre_x, pre_y), (x, y), (0, 0, 0), 10)
d_x = int((x / self.width * 255) / 2 + 180)
d_y = int((y / self.height * 255) / 2 - 80)
d_points.append((d_x, d_y))
# f.write('%d %d\n' % (d_x, d_y,))
if i == len(stroke) - 2:
x = int(d_w * stroke[i + 1][0] / 255) + d_w0
y = int(d_h * stroke[i + 1][1] / 255) + d_h0
d_x = int((x / self.width * 255) / 2 + 180)
d_y = int((y / self.height * 255) / 2 - 80)
d_points.append((d_x, d_y))
# f.write('%d %d\n' % (d_x, d_y,))
# f.write('\n')
self.d_strokes.append(d_points)
from quickdraw import QuickDrawDataGroup
from quickdraw import QuickDrawData
import sys
import os
qd = QuickDrawData()
##for drawing_num, drawing_name in enumerate(qd.drawing_names):
## if drawing_num < 86:
## continue
## print("Saving " + drawing_name + " images")
## qdg = QuickDrawDataGroup(drawing_name, max_drawings=20)
## directory_name = 'images/' + drawing_name
## if not os.path.isdir(os.path.join(os.getcwd(), directory_name)):
## os.mkdir(directory_name)
## for drawing_count, drawing in enumerate(qdg.drawings, 1):
## drawing.image.save(directory_name + "/" + drawing_name + "{:0>4d}.png".format(drawing_count))
drawing_name = "face"
print("Saving " + drawing_name + " images")
qdg = QuickDrawDataGroup(drawing_name, max_drawings=300)
directory_name = 'images/' + drawing_name
if not os.path.isdir(os.path.join(os.getcwd(), directory_name)):
os.mkdir(directory_name)
for drawing_count, drawing in enumerate(qdg.drawings, 1):
drawing.image.save(directory_name + "/" + drawing_name +
"{:0>4d}.png".format(drawing_count))
class Detector:
def __init__(self):
# Load a model imported from Tensorflow.
frozen_ssd_model = os.path.join(os.path.dirname(__file__), '../models',
'ssd_mobilenet_model',
'frozen_inference_graph.pb')
ssd_config = os.path.join(os.path.dirname(__file__), '../models',
'ssd_mobilenet_model',
'ssd_mobilenet_v1_coco_2017_11_17.pbtxt')
self.tensorflowNet = cv2.dnn.readNetFromTensorflow(
frozen_ssd_model, ssd_config)
# List of dictionaries containg detected objects information.
self.detected_objects = []
# QuckDraw object
cache_path = os.path.join(os.path.dirname(__file__), 'quickdrawcache')
self.qd = QuickDrawData(recognized=True,
max_drawings=1000,
cache_dir=cache_path)
# Label HashMap
self.classNames = {
0: 'background',
1: 'person',
2: 'bicycle',
3: 'car',
4: 'motorcycle',
5: 'airplane',
6: 'bus',
7: 'train',
8: 'truck',
9: 'boat',
10: 'traffic light',
11: 'fire hydrant',
13: 'stop sign',
14: 'parking meter',
15: 'bench',
16: 'bird',
17: 'cat',
18: 'dog',
19: 'horse',
20: 'sheep',
21: 'cow',
22: 'elephant',
23: 'bear',
24: 'zebra',
25: 'giraffe',
27: 'backpack',
28: 'umbrella',
31: 'handbag',
32: 'tie',
33: 'suitcase',
34: 'frisbee',
35: 'skis',
36: 'snowboard',
37: 'sports ball',
38: 'kite',
39: 'baseball bat',
40: 'baseball glove',
41: 'skateboard',
42: 'surfboard',
43: 'tennis racket',
44: 'bottle',
46: 'wine glass',
47: 'cup',
48: 'fork',
49: 'knife',
50: 'spoon',
51: 'bowl',
52: 'banana',
53: 'apple',
54: 'sandwich',
55: 'orange',
56: 'broccoli',
57: 'carrot',
58: 'hot dog',
59: 'pizza',
60: 'donut',
61: 'cake',
62: 'chair',
63: 'couch',
64: 'potted plant',
65: 'bed',
67: 'dining table',
70: 'toilet',
72: 'tv',
73: 'laptop',
74: 'mouse',
75: 'remote',
76: 'keyboard',
77: 'cell phone',
78: 'microwave',
79: 'oven',
80: 'toaster',
81: 'sink',
82: 'refrigerator',
84: 'book',
85: 'clock',
86: 'vase',
87: 'scissors',
88: 'teddy bear',
89: 'hair drier',
90: 'toothbrush'
}
# Tensorflow to QuickDraw HashMap
self.tensorflow_to_quickdraw_hash = {
'background': '',
'person': 'face',
'bicycle': 'bicycle',
'car': 'car',
'motorcycle': 'motorbike',
'airplane': 'airplane',
'bus': 'bus',
'train': 'train',
'truck': 'truck',
'boat': 'sailboat',
'traffic light': 'traffic light',
'fire hydrant': 'fire hydrant',
'stop sign': 'stop sign',
'parking meter': '',
'bench': 'bench',
'bird': 'bird',
'cat': 'cat',
'dog': 'dog',
'horse': 'horse',
'sheep': 'sheep',
'cow': 'cow',
'elephant': 'elephant',
'bear': 'bear',
'zebra': 'zebra',
'giraffe': 'giraffe',
'backpack': 'backpack',
'umbrella': 'umbrella',
'handbag': 'purse',
'tie': 'bowtie',
'suitcase': 'suitcase',
'frisbee': 'circle',
'skis': '',
'snowboard': '',
'sports ball': 'soccer ball',
'kite': 'scissors',
'baseball bat': 'baseball bat',
'baseball glove': '',
'skateboard': 'skateboard',
'surfboard': '',
'tennis racket': 'tennis racquet',
'bottle': 'wine bottle',
'wine glass': 'wine glass',
'cup': 'cup',
'fork': 'fork',
'knife': 'knife',
'spoon': 'spoon',
'bowl': '',
'banana': 'banana',
'apple': 'apple',
'sandwich': 'sandwich',
'orange': '',
'broccoli': 'broccoli',
'carrot': 'carrot',
'hot dog': 'hot dog',
'pizza': 'pizza',
'donut': 'donut',
'cake': 'cake',
'chair': 'chair',
'couch': 'couch',
'potted plant': 'house plant',
'bed': 'bed',
'dining table': 'table',
'toilet': 'toilet',
'tv': 'television',
'laptop': 'laptop',
'mouse': 'mouse',
'remote': 'remote control',
'keyboard': 'keyboard',
'cell phone': 'cell phone',
'microwave': 'microwave',
'oven': 'oven',
'toaster': 'toaster',
'sink': 'sink',
'refrigerator': '',
'book': 'book',
'clock': 'clock',
'vase': 'vase',
'scissors': 'scissors',
'teddy bear': 'teddy-bear',
'hair drier': '',
'toothbrush': 'toothbrush'
}
def detect_object(self, img):
# Input image
img = cv2.cvtColor(numpy.array(img), cv2.COLOR_BGR2RGB)
img_height, img_width, channels = img.shape
# Use the given image as input, which needs to be blob(s).
self.tensorflowNet.setInput(
cv2.dnn.blobFromImage(img,
size=(300, 300),
swapRB=True,
crop=False))
# Runs a forward pass to compute the net output.
networkOutput = self.tensorflowNet.forward()
# For mask rcnn model
# networkOutput, mask = self.tensorflowNet.forward(["detection_out_final", "detection_masks"])
'''
Loop over the detected objects
Detection Indexes:
0: (not used)
1: the identifier of the object's class ex. 5 = 'airplane'
2: the accuracy (score) of the object detected
3: dist of object from the left
4: dist of object from the top
5: dist of object from the right
6: dist of object from the bottom
'''
for detection in networkOutput[0, 0]:
score = float(detection[2])
if score > 0.5:
# Object dimensions
obj_left = detection[3] * img_width
obj_top = detection[4] * img_height
obj_right = detection[5] * img_width
obj_bottom = detection[6] * img_height
# Object name, scale, and x,y offet
name_of_object = self.classNames[detection[1]]
xy_scale = self.get_object_scale(obj_left, obj_right, obj_top,
obj_bottom, img_width,
img_height)
xy_normalized = self.normalize_object_coordinates(
obj_left, obj_top, img_width, img_height)
strokes = self.get_quickdraw_drawing(
self.tensorflow_to_quickdraw_hash[name_of_object])
if strokes is not None:
self.detected_objects.append({
"name": name_of_object,
"scale": xy_scale,
"normalized": xy_normalized,
"img_width": img_width,
"img_height": img_height,
"strokes": strokes
})
# Check for a person to be detected
if detection[1] == 1:
self.person_detected(obj_left, obj_right, obj_top,
obj_bottom, img_width, img_height)
# draw a red rectangle around detected objects
cv2.rectangle(img, (int(obj_left), int(obj_top)),
(int(obj_right), int(obj_bottom)), (0, 0, 255),
thickness=8)
# Resize the image
# scaled_width = 1000
# scaled_height = int(scaled_width * img_height / img_width)
# img = cv2.resize(img, (scaled_width, scaled_height), interpolation = cv2.INTER_AREA)
object_info = self.detected_objects
# Empty the detected objects for the next call
self.detected_objects = []
return img, object_info
def person_detected(self, obj_left, obj_right, obj_top, obj_bottom,
img_width, img_height):
# Remove face from detected objects
object_data = self.detected_objects.pop()
# Calculate new top and bottom heights
face_bottom = obj_bottom - ((obj_bottom - obj_top) * (2 / 3))
shirt_bottom = obj_bottom - ((obj_bottom - obj_top) * (1 / 3))
pants_bottom = obj_bottom
face_top = obj_top
shirt_top = obj_top + ((obj_bottom - obj_top) * (1 / 3))
pants_top = obj_top + ((obj_bottom - obj_top) * (2 / 3))
# Scale
face_scale = self.get_object_scale(obj_left, obj_right, face_top,
face_bottom, img_width, img_height)
shirt_scale = self.get_object_scale(obj_left, obj_right, shirt_top,
shirt_bottom, img_width,
img_height)
pants_scale = self.get_object_scale(obj_left, obj_right, pants_top,
pants_bottom, img_width,
img_height)
# Normalize
face_normalize = self.normalize_object_coordinates(
obj_left, face_top, img_width, img_height)
shirt_normalize = self.normalize_object_coordinates(
obj_left, shirt_top, img_width, img_height)
pants_normalize = self.normalize_object_coordinates(
obj_left, pants_top, img_width, img_height)
# Strokes
face_strokes = object_data["strokes"]
shirt_strokes = self.get_quickdraw_drawing("t-shirt")
pants_strokes = self.get_quickdraw_drawing("pants")
# Add objects
self.detected_objects.append({
"name": "face",
"scale": face_scale,
"normalized": face_normalize,
"img_width": img_width,
"img_height": img_height,
"strokes": face_strokes
})
self.detected_objects.append({
"name": "t-shirt",
"scale": shirt_scale,
"normalized": shirt_normalize,
"img_width": img_width,
"img_height": img_height,
"strokes": shirt_strokes
})
self.detected_objects.append({
"name": "pants",
"scale": pants_scale,
"normalized": pants_normalize,
"img_width": img_width,
"img_height": img_height,
"strokes": pants_strokes
})
def get_object_scale(self, obj_left, obj_right, obj_top, obj_bottom,
img_width, img_height):
scale_x = (obj_right - obj_left) / img_width
scale_y = (obj_bottom - obj_top) / img_height
return [scale_x, scale_y]
def normalize_object_coordinates(self, obj_left, obj_top, img_width,
img_height):
x_normalized = obj_left / img_width
y_normalized = obj_top / img_height
return [x_normalized, y_normalized]
'''
Example Input:
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lets say we want to normalize the cartoon point of (100,100) ->
cartoon_img_width = 255
cartoon_img_height = 255
img_width = 2000
img_height = 1300
canvas_width = 1200
canvas_height = 700
img_scale_x = found w/ get_object_scale() = 0.30
img_scale_y = found w/ get_object_scale() = 0.98
obj_left = 1000
obj_top = 20
obj_bottom = 1300
obj_right = 1600
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Determining the normalized coordinates for the cartoon drawing:
- Call normalize_object_coordinates() to get the normalized x and y coordinates for the object: x_norm = 0.5 | y_norm = 0.015
- x point scaled and normalized = ((cartoon_point_x / cartoon_img_width) * (img_scale_x * img_width)) + (x_norm*canvas_width) -> ((100/255)*.30*1200) + (.5*1200)
- y point scaled and normalized = ((cartoon_point_y / cartoon_img_height) * (img_scale_y * img_height)) + (y_norm*canvas_height) -> ((100/255)*0.98*700) + (.015*700)
'''
def get_quickdraw_drawing(self, name):
# Initialize a QuickDraw object to access the API
if name != "":
cur_object = self.qd.get_drawing(name)
else:
print("Not a valid QuickDraw image!")
return None
return cur_object.strokes
def __init__(self):
# Load a model imported from Tensorflow.
frozen_ssd_model = os.path.join(os.path.dirname(__file__), '../models',
'ssd_mobilenet_model',
'frozen_inference_graph.pb')
ssd_config = os.path.join(os.path.dirname(__file__), '../models',
'ssd_mobilenet_model',
'ssd_mobilenet_v1_coco_2017_11_17.pbtxt')
self.tensorflowNet = cv2.dnn.readNetFromTensorflow(
frozen_ssd_model, ssd_config)
# List of dictionaries containg detected objects information.
self.detected_objects = []
# QuckDraw object
cache_path = os.path.join(os.path.dirname(__file__), 'quickdrawcache')
self.qd = QuickDrawData(recognized=True,
max_drawings=1000,
cache_dir=cache_path)
# Label HashMap
self.classNames = {
0: 'background',
1: 'person',
2: 'bicycle',
3: 'car',
4: 'motorcycle',
5: 'airplane',
6: 'bus',
7: 'train',
8: 'truck',
9: 'boat',
10: 'traffic light',
11: 'fire hydrant',
13: 'stop sign',
14: 'parking meter',
15: 'bench',
16: 'bird',
17: 'cat',
18: 'dog',
19: 'horse',
20: 'sheep',
21: 'cow',
22: 'elephant',
23: 'bear',
24: 'zebra',
25: 'giraffe',
27: 'backpack',
28: 'umbrella',
31: 'handbag',
32: 'tie',
33: 'suitcase',
34: 'frisbee',
35: 'skis',
36: 'snowboard',
37: 'sports ball',
38: 'kite',
39: 'baseball bat',
40: 'baseball glove',
41: 'skateboard',
42: 'surfboard',
43: 'tennis racket',
44: 'bottle',
46: 'wine glass',
47: 'cup',
48: 'fork',
49: 'knife',
50: 'spoon',
51: 'bowl',
52: 'banana',
53: 'apple',
54: 'sandwich',
55: 'orange',
56: 'broccoli',
57: 'carrot',
58: 'hot dog',
59: 'pizza',
60: 'donut',
61: 'cake',
62: 'chair',
63: 'couch',
64: 'potted plant',
65: 'bed',
67: 'dining table',
70: 'toilet',
72: 'tv',
73: 'laptop',
74: 'mouse',
75: 'remote',
76: 'keyboard',
77: 'cell phone',
78: 'microwave',
79: 'oven',
80: 'toaster',
81: 'sink',
82: 'refrigerator',
84: 'book',
85: 'clock',
86: 'vase',
87: 'scissors',
88: 'teddy bear',
89: 'hair drier',
90: 'toothbrush'
}
# Tensorflow to QuickDraw HashMap
self.tensorflow_to_quickdraw_hash = {
'background': '',
'person': 'face',
'bicycle': 'bicycle',
'car': 'car',
'motorcycle': 'motorbike',
'airplane': 'airplane',
'bus': 'bus',
'train': 'train',
'truck': 'truck',
'boat': 'sailboat',
'traffic light': 'traffic light',
'fire hydrant': 'fire hydrant',
'stop sign': 'stop sign',
'parking meter': '',
'bench': 'bench',
'bird': 'bird',
'cat': 'cat',
'dog': 'dog',
'horse': 'horse',
'sheep': 'sheep',
'cow': 'cow',
'elephant': 'elephant',
'bear': 'bear',
'zebra': 'zebra',
'giraffe': 'giraffe',
'backpack': 'backpack',
'umbrella': 'umbrella',
'handbag': 'purse',
'tie': 'bowtie',
'suitcase': 'suitcase',
'frisbee': 'circle',
'skis': '',
'snowboard': '',
'sports ball': 'soccer ball',
'kite': 'scissors',
'baseball bat': 'baseball bat',
'baseball glove': '',
'skateboard': 'skateboard',
'surfboard': '',
'tennis racket': 'tennis racquet',
'bottle': 'wine bottle',
'wine glass': 'wine glass',
'cup': 'cup',
'fork': 'fork',
'knife': 'knife',
'spoon': 'spoon',
'bowl': '',
'banana': 'banana',
'apple': 'apple',
'sandwich': 'sandwich',
'orange': '',
'broccoli': 'broccoli',
'carrot': 'carrot',
'hot dog': 'hot dog',
'pizza': 'pizza',
'donut': 'donut',
'cake': 'cake',
'chair': 'chair',
'couch': 'couch',
'potted plant': 'house plant',
'bed': 'bed',
'dining table': 'table',
'toilet': 'toilet',
'tv': 'television',
'laptop': 'laptop',
'mouse': 'mouse',
'remote': 'remote control',
'keyboard': 'keyboard',
'cell phone': 'cell phone',
'microwave': 'microwave',
'oven': 'oven',
'toaster': 'toaster',
'sink': 'sink',
'refrigerator': '',
'book': 'book',
'clock': 'clock',
'vase': 'vase',
'scissors': 'scissors',
'teddy bear': 'teddy-bear',
'hair drier': '',
'toothbrush': 'toothbrush'
}
from flask import Flask, render_template, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from quickdraw import QuickDrawData
from sqlalchemy import func, cast, Float, ForeignKey
from sqlalchemy.dialects.postgresql import JSONB
config = configparser.ConfigParser()
config.read_file(open("config.ini"))
z = config["general"].getfloat("confidence_z") # 1.96 => 0.975 confidence
app = Flask(__name__)
app.config.from_pyfile("app.cfg")
app.secret_key = os.urandom(32)
db = SQLAlchemy(app)
qd = QuickDrawData(cache_dir=config["general"]["dataset_dir"],
print_messages=False)
def uuid_gen() -> str:
return str(uuid.uuid4()).replace("-", "")
# https://www.evanmiller.org/how-not-to-sort-by-average-rating.html
def ci_lower_bound(pos, neg):
n = pos + neg
if n == 0:
return 0
return ((pos + z**2 / 2) / n - z *
((pos * neg) / n + z**2 / 4)**0.5 / n) / (1 + z**2 / n)
from quickdraw import QuickDrawData
if __name__ == '__main__':
quickdraw = QuickDrawData()
print(quickdraw.drawing_names)
n = 10
for i in range(n * 2):
draw = quickdraw.get_drawing("bicycle")
draw.image.save("datasets/trainA/train_bicycle{}.gif".format(i))
for i in range(n):
draw = quickdraw.get_drawing("bicycle")
draw.image.save("datasets/testA/test_bicycle{}.gif".format(i))
for i in range(n * 2):
draw = quickdraw.get_drawing("campfire")
draw.image.save("datasets/trainB/train_campfire{}.gif".format(i))
for i in range(n):
draw = quickdraw.get_drawing("campfire")
draw.image.save("datasets/testB/test_campfire{}.gif".format(i))
def draw_objects(request):
qd = QuickDrawData()
objects = request.GET.get('objects')
objects = objects.replace("'", "")
list = objects.strip("][").split(', ')
return render(request, 'polls/drawing.html', {'object': list[0]})
def main():
qgd = QuickDrawData()
label_names = qgd.drawing_names
total_num_labels = len(label_names)
im_res = 255
batch_size = 100
label_list = ["ant", "bear", "bee", "bird", "butterfly", "cat", "cow", "crab", "crocodile", "dog"]
train_iter, test_iter = load_data(label_list=label_list, batch_size=batch_size)
# Training
class Reshape(nn.Module):
def forward(self, x):
return x.view(-1,65025)
net = nn.Sequential(nn.Flatten(),
nn.Linear(65025, 1000),
nn.ReLU(),
nn.Linear(1000, 10))
def init_weights(m):
if type(m) == nn.Linear:
torch.nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights)
device = torch.device("cuda:0")
net.to(device)
optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
loss = nn.CrossEntropyLoss()
num_epochs = 20
for epoch in range(num_epochs):
train_loss_sum = train_num_correct_preds = num_examples = 0
for i, (X, y) in enumerate(train_iter):
# show_images(X.reshape(batch_size, im_res, im_res), 2, 10, [label_list[int(i.item())] for i in y])
net.train()
optimizer.zero_grad()
X, y = X.to(device), y.to(device)
y_hat = net(X)
l = loss(y_hat, y)
# print(f"loss={l:.3f}", y_hat, y, X.shape, X.reshape(-1, 65025).shape)
# break
l.backward()
optimizer.step()
with torch.no_grad():
train_loss_sum += l * X.shape[0]
if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
y_hat = y_hat.argmax(axis=1)
cmp = y_hat.type(y.dtype) == y
train_num_correct_preds += float(cmp.type(y.dtype).sum())
num_examples += X.shape[0]
train_loss = train_loss_sum / num_examples
train_acc = train_num_correct_preds / num_examples
if (i + 1) % 10 == 0:
print(f"epoch {epoch + 1}, iteration {i + 1}: train_loss={train_loss:.3f}, train_acc={train_acc:.3f}")
test_acc = eval_test_acc(net, test_iter, device)
print(f"epoch {epoch + 1}: test_acc={test_acc:.3f}")
print(f"Finished training: train_loss={train_loss:.3f}, train_acc={train_acc:.3f}")
from quickdraw import QuickDrawData
qd = QuickDrawData()
anvil = qd.get_drawing("anvil")
stroke_no = 0
for stroke in anvil.strokes:
for x, y in stroke:
# x = xy[0]
# y = xy[1]
print("stroke={} x={} y={}".format(stroke_no, x, y))
stroke_no += 1
def visualize_the_matrix(number_of_categories):
for obj in matrix_info:
row_source = obj[0]
for i in range(3):
column_target = (obj[1])[i]
the_id = (obj[2])[i]
most_similar_source_id = (obj[3])[i]
# Find the most similar target sketches.
qd = QuickDrawData()
doodle = qd.get_drawing(column_target)
while not doodle.key_id == the_id:
doodle = qd.get_drawing(column_target)
found = True
if found:
DEFAULT_SIZE_WHITE_CHANNEL = (300, 300, 1)
canvas = np.ones(DEFAULT_SIZE_WHITE_CHANNEL,
dtype="uint8") * 255
cv2.namedWindow('Window')
my_stroke_list = doodle.image_data
for N in my_stroke_list:
x_list = N[0]
y_list = N[1]
for point in range((len(x_list) - 1)):
cv2.line(canvas, (x_list[point], y_list[point]),
(x_list[point + 1], y_list[point + 1]),
(0, 0, 0), 2)
cv2.imwrite(
"./png_sketches/trial_pngs" + "source_" + row_source +
"_" + str(i) + ".png", canvas)
for i in range(3):
column_target = (obj[1])[i]
the_id = (obj[2])[i]
most_similar_source_id = (obj[3])[i]
# Find the most similar target sketches.
qd = QuickDrawData()
doodle = qd.get_drawing(row_source)
while not doodle.key_id == most_similar_source_id:
doodle = qd.get_drawing(row_source)
found = True
if found:
DEFAULT_SIZE_WHITE_CHANNEL = (300, 300, 1)
canvas = np.ones(DEFAULT_SIZE_WHITE_CHANNEL,
dtype="uint8") * 255
cv2.namedWindow('Window')
my_stroke_list = doodle.image_data
for N in my_stroke_list:
x_list = N[0]
y_list = N[1]
for point in range((len(x_list) - 1)):
cv2.line(canvas, (x_list[point], y_list[point]),
(x_list[point + 1], y_list[point + 1]),
(0, 0, 0), 2)
cv2.imwrite(
"./png_sketches/trial_pngs" + "source_" + row_source +
"_" + str(i) + "_sourceimage.png", canvas)
excel = xlsxwriter.Workbook("./png_sketches/" + "matrix_six_with_targets" +
".xlsx")
worksheet = excel.add_worksheet()
worksheet.set_default_row(300)
worksheet.set_column('A:ZZ', 50)
row_index = -1
column_empty = True
for source_categ in reference_dict.keys():
row_index += 1
column_index = -1
for ordered in range(6):
column_index += 1
if ordered < 3:
pic = "./png_sketches/trial_pngs" + "source_" + source_categ + "_" + str(
ordered) + ".png"
worksheet.insert_image(row_index + 1, column_index + 1, pic)
if column_empty:
worksheet.write(0, column_index + 1,
("target_similar" + str(ordered + 1)))
else:
pic = "./png_sketches/trial_pngs" + "source_" + source_categ + "_" + str(
ordered - 3) + "_sourceimage.png"
worksheet.insert_image(row_index + 1, column_index + 1, pic)
if column_empty:
worksheet.write(0, column_index + 1,
("source_similar_to" + str(ordered - 2)))
column_empty = False
worksheet.write(row_index + 1, 0, source_categ)
excel.close()
def test_get_drawing_group():
qd = QuickDrawData()
assert isinstance(qd.get_drawing_group("anvil"), QuickDrawDataGroup)
def getTree():
qd = QuickDrawData()
return qd.get_drawing("tree")
def test_drawing_names():
qd = QuickDrawData()
assert len(qd.drawing_names) == 345
