def init_net(args):
dn.set_gpu(args.gpu)
net = dn.load_net(args.model.encode(), args.weights.encode(), 0)
dn.set_batch_network(net, 1)
dn.resize_network(net, args.imsize, args.imsize)
sys.stderr.write('Resized to %d x %d\n' %
(dn.network_width(net), dn.network_height(net)))
return net
def __init__(self, detector_num=0):
import darknet as dn
dn.set_gpu(int(constants.DARKNET_GPU))
self.detector_num = detector_num
self.net = dn.load_net(
py_util.encode(WEIGHT_PATH + 'yolov3-thor.cfg'),
py_util.encode(WEIGHT_PATH + 'yolov3-thor_final.weights'), 0)
self.meta = dn.load_meta(py_util.encode(WEIGHT_PATH + 'thor.data'))
self.count = 0
def __init__(self):
self.ocr_threshold = .4
self.ocr_weights = 'data/ocr/ocr-net.weights'.encode()
self.ocr_netcfg = 'data/ocr/ocr-net.cfg'.encode()
self.ocr_dataset = 'data/ocr/ocr-net.data'.encode()
self.ocr_net = dn.load_net(self.ocr_netcfg, self.ocr_weights, 0)
self.ocr_meta = dn.load_meta(self.ocr_dataset)
def load_net(cfg_filepath, weights_filepath, clear):
# type: (str, str, bool) -> object
"""
:param cfg_filepath: cfg file name
:param weights_filepath: weights file name
:param clear: True if you want to clear the weights otherwise False
:return: darknet network object
"""
return darknet.load_net(cfg_filepath, weights_filepath, clear)
def detect(cfg_file, weight_file, video_file):
dn.set_gpu(0)
net = dn.load_net(cfg_file, weight_file, 0)
meta = dn.load_meta("cfg/coco.data")
print("video: %s" % video_file)
cap = cv2.VideoCapture(video_file)
video_len = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
terminate, is_paused = False, False
idx = 0
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
video_writer = cv2.VideoWriter("gray_processed.mp4", fourcc, fps, (width, height))
while not terminate and cap.isOpened():
idx += 1
print("processing: %.4f%%" % (idx * 100.0 / video_len))
#print("debug")
if not is_paused:
ret, frame = cap.read()
if not ret:
break
boxes = dn.detect_np(net, meta, frame)
new_frame = my_plot(frame.copy(), boxes)
video_writer.write(new_frame)
"""
cv2.imshow('image', new_frame)
key = cv2.waitKey(1)
if key & 255 == 27: # ESC
print("terminating")
terminate = True
elif key & 255 == 32: # ' '
print("toggeling pause: " + str(not is_paused))
is_paused = not is_paused
elif key & 255 == 115: # 's'
print("stepping")
ret, frame = cap.read()
if not ret:
break
boxes = dn.detect_np(net, meta, frame)
is_paused = True
"""
cap.release()
video_writer.release()
def loadnet():
global net, meta
if (not tiny):
net = dn.load_net("cfg/yolov3.cfg", "yolov3.weights", 0)
meta = dn.load_meta("cfg/coco.data")
elif (tiny):
if (movie):
net = dn.load_net("../dataset_test/cfg/yolov3-tiny-kym-run.cfg",
"backup1/yolov3-tiny-kym-train.backup", 0)
meta = dn.load_meta("../dataset_test/cfg/kym_test.data")
else:
net = dn.load_net("../test_data/test_training/yolov2-tiny-kym.cfg",
"backup/yolov2-tiny-kym_30000.weights", 0)
meta = dn.load_meta("../test_data/test_training/kym_test.data")
else:
net = dn.load_net("cfg/yolov3.cfg", "yolov3.weights", 0)
meta = dn.load_meta("cfg/coco.data")
def __init__(self):
rospy.init_node('Exercise2', anonymous=True)
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("camera/rgb/image_raw", Image, self.imageCallback)
self.imageToProcess = None
cfgPath = "/home/alvaro/Escritorio/tfg/darknet/cfg/yolov3.cfg"
weightsPath = "/home/alvaro/Escritorio/tfg/darknet/yolov3.weights"
dataPath = "/home/alvaro/Escritorio/tfg/darknet/cfg/coco2.data"
self.net = dn.load_net(cfgPath, weightsPath, 0)
self.meta = dn.load_meta(dataPath)
self.fileName = 'predict.jpg'
def __init__(self, source):
self.DetectedImage = None
dn.set_gpu(0)
self.net = dn.load_net(
bytes(path + "cfg/yolov3-tiny.cfg", encoding='utf-8'),
bytes(path + "/yolov3-tiny.weights", encoding='utf-8'), 0)
self.meta = dn.load_meta(
bytes(path + "cfg/coco.data", encoding='utf-8'))
self.cap = cv2.VideoCapture(source)
self.cap.set(3, 1920)
self.cap.set(4, 1080)
def main(gpu_ind, data_path, output_path):
# setup GPU and load model
dn.set_gpu(gpu_ind)
net = dn.load_net(b"darknet/cfg/yolov3.cfg", b"darknet/yolov3.weights", 0)
meta = dn.load_meta(b"darknet/cfg/coco.data")
# delete old files and get data filenames
_prep_output_path(output_path)
data = _get_data_raw(data_path) # `data` is a generator
#_test_detector(net, meta, data, output_path)
_track(net, meta, data, output_path)
def __init__(self, tiny=False):
try: # keep only one instance design to avoid "out of memory"
self.meta = QuickDarknet.meta
self.net = QuickDarknet.net
return
except: # if no instance then go ahead
pass
dn.set_gpu(0)
if tiny: # tiny-weights would be faster but not precise enough
self.net = dn.load_net(
str.encode(os.path.join(dir, "cfg/yolov3-tiny.cfg")),
str.encode(os.path.join(dir, "weights/yolov3-tiny.weights")),
0)
else:
self.net = dn.load_net(
str.encode(os.path.join(dir, "cfg/yolov3.cfg")),
str.encode(os.path.join(dir, "weights/yolov3.weights")), 0)
self.meta = dn.load_meta(str.encode(os.path.join(dir,
"cfg/coco.data")))
QuickDarknet.meta = self.meta # save the instance to class static member
QuickDarknet.net = self.net
def __init__(self,
model=darknet_path + "cfg/tiny-yolo.cfg",
metas=darknet_path + "cfg/coco.data",
weights=darknet_path + "weights/tiny-yolo.weights"):
#Define the model, model's meta data and weights
self.model = model
self.metas = metas
self.weights = weights
#load the net
self.net = dn.load_net(model, weights)
self.meta = dn.load_meta(metas)
def __init__(self):
#define weights, data, cfg path and load net, paths should be in utf-8
base_path = os.getcwd()
## old model path
#data_path = 'darknet/data/globus_13.data'
#cfg_path = 'darknet/cfg/globus13-yolov3.cfg'
#weights_path = 'darknet/backup/globus13-yolov3_2000.weights'
data_path = 'darknet/data/globus_seed_wendel.data'
cfg_path = 'darknet/cfg/globus_seed_wendel.cfg'
weights_path = 'darknet/backup/globus_seed_wendel.weights'
#read reference images for orb comparison
with open('orb_reference_calculated3.pickle', 'rb') as handle:
self.class_orb_ref = pickle.load(handle)
#set orb variables
self.orb = cv2.ORB_create(nfeatures=500)
FLANN_INDEX_LSH = 6
index_params = dict(algorithm=FLANN_INDEX_LSH,
table_number=6,
key_size=12,
multi_probe_level=1)
search_params = dict() #checks=50 # or pass empty dictionary
self.flann = cv2.FlannBasedMatcher(index_params, search_params)
#read gtins and save them to a data structure
reader = csv.DictReader(open('test_shelf_list.csv', 'r'))
dict_l = []
self.dict_g = {}
self.dict_count = {}
for line in reader:
dict_l.append(line)
for coi in dict_l:
if coi['Product'] not in self.dict_g.keys():
self.dict_g[coi['Product']] = {coi['ORB']: coi['Barcode']}
else:
self.dict_g[coi['Product']].update(
{coi['ORB']: coi['Barcode']})
try:
self.dict_count[coi['Product']] += 1
except:
self.dict_count[coi['Product']] = 1
#load network and meta using darkflow library
self.net = dn.load_net(
os.path.join(base_path, cfg_path).encode('utf-8'),
os.path.join(base_path, weights_path).encode('utf-8'), 0)
self.meta = dn.load_meta(
os.path.join(base_path, data_path).encode('utf-8'))
def __init__(self, name, device):
threading.Thread.__init__(self, name=name)
self.device = device
if name == 'tiny_yolo':
self.net = darknet.load_net("darknet/cfg/tiny-yolo-voc.cfg",
"zoo/tiny-yolo-voc.weights", 0)
self.meta = darknet.load_meta("darknet/cfg/voc.data")
elif name == 'yolo_v2':
self.net = darknet.load_net("darknet/cfg/yolo.cfg",
"zoo/yolo.weights", 0)
self.meta = darknet.load_meta("darknet/cfg/coco.data")
else:
self.log().critical("unknown pipeline '%s'", name)
thread.interrupt_main()
return
self.running = threading.Event()
self.queue = Queue.Queue()
return
def __init__(self, args):
dn.set_gpu(0)
if args.object:
self.conf = .25
model = OBJECT
else:
self.conf = .8
model = HELMET
self.net = dn.load_net(model['cfg'].encode("ascii"),
model['weights'].encode("ascii"), 0, 1)
self.meta = dn.load_meta(model['data'].encode("ascii"))
self.dark_image = dn.make_image(dn.network_width(self.net),
dn.network_height(self.net), 3)
def simulate(self, from_scratch=False):
"""
Precompute the simulation to save time while running it.
Args:
from_scratch (bool): Recompute the entire simulation and don't use saved data
Returns:
None
"""
if from_scratch:
self.bbox_data = []
net = dn.load_net(self.cfg_path, self.weights_path, 0)
meta = dn.load_meta(self.data_path)
max_val = self.num_images
time_taken = []
for i in range(self.num_images + 1):
start = time.clock()
try:
if i < len(self.bbox_data):
continue
image = "{}{}.jpg".format(self.images_path, i)
result = dn.detect(net, meta, image)
time_taken.append(time.clock() - start)
coords = result[0][2]
x, y, w, h = [int(coord) for coord in coords]
self.bbox_data.append({
'image':
image,
'center': (x, y),
'width':
w,
'height':
h,
'top_left': (max(x - w // 2, 0), max(y - h // 2, 0)),
'bottom_right': (x + w // 2, y + h // 2)
})
pickle.dump(
self.bbox_data,
open('{}/bboxdata.p'.format(self.images_path), 'wb'))
print image
print self.bbox_data[i]
print "Saved array to image path"
print "-------------------------"
except Exception:
print "Error with image"
print "Done simulating"
if len(time_taken) > 0:
print "Average time take was " + str(
sum(time_taken) / len(time_taken)) + "seconds"
def TaskDarknet(self):
threading.Timer(3, self.TaskDarknet).start()
#dn.set_gpu(0)
if self.darknet == False:
self.net = dn.load_net(
"/home/minhwan/opencv/build/darknet/yolov3-tiny.cfg",
"/home/minhwan/opencv/build/darknet/yolov3-tiny.weights", 0)
#print(net)
self.meta = dn.load_meta(
"/home/minhwan/opencv/build/darknet/cfg/coco.data")
self.darknet = True
r = dn.detect(self.net, self.meta,
"/home/minhwan/opencv/build/darknet/data/dog.jpg")
print(r)
def __init__(self):
rospy.init_node('Activity', anonymous=True)
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("camera/rgb/image_raw", Image,
self.imageCallback)
self.pub = rospy.Publisher('yolo_topic', String, queue_size=10)
self.imageToProcess = None
cfgPath = "/home/alvaro/Escritorio/tfg/darknet/cfg/yolov3.cfg"
weightsPath = "/home/alvaro/Escritorio/tfg/darknet/yolov3.weights"
dataPath = "/home/alvaro/Escritorio/tfg/darknet/cfg/coco2.data"
self.net = dn.load_net(cfgPath, weightsPath, 0)
self.meta = dn.load_meta(dataPath)
self.fileName = 'predict.jpg'
self.rate = rospy.Rate(10)
def __init__(self):
#define weights, data, cfg path and load net, paths should be in utf-8
base_path = os.getcwd()
data_path2 = 'darknet/data/globus_tags.data'
cfg_path2 = 'darknet/cfg/globustags-yolov3.cfg'
weights_path2 = 'darknet/backup/globustags-yolov3.weights'
#TODO: add barcode and digit extraction
self.net2 = dn.load_net(
os.path.join(base_path, cfg_path2).encode('utf-8'),
os.path.join(base_path, weights_path2).encode('utf-8'), 0)
self.meta2 = dn.load_meta(
os.path.join(base_path, data_path2).encode('utf-8'))
def image_callback(msg):
global net_door, net_ball, meta_door, meta_ball, cam_param, det_flag, has_rev, netInitFinished, np_arr, start_time, cv_image
if netInitFinished == False:
model_name = 'all_640_xy'
steps = '170000'
base_dir = '/home/momenta/mc3/python/weight/weights-' + model_name
net_ball = dn.load_net(
os.path.join(base_dir, "yolov3-tiny-" + model_name + ".cfg"),
os.path.join(
base_dir,
"yolov3-tiny-" + model_name + "_" + steps + ".weights"), 0)
meta_ball = dn.load_meta(
os.path.join(base_dir, "voc-" + model_name + ".data"))
model_name = 'door'
steps = '250000'
base_dir = '/home/momenta/mc3/python/weight/weights-' + model_name
net_door = dn.load_net(
os.path.join(base_dir, "yolov3-tiny-" + model_name + ".cfg"),
os.path.join(
base_dir,
"yolov3-tiny-" + model_name + "_" + steps + ".weights"), 0)
meta_door = dn.load_meta(
os.path.join(base_dir, "voc-" + model_name + ".data"))
filename = "./cam_param/" + tb_name + "_bottom.yaml"
f = open(filename)
cam_param = yaml.load(f)
netInitFinished = True
t = time.time()
if det_flag:
det_flag = False
# np_arr = np.fromstring(msg.data, np.uint8)
cv_image = bridge.imgmsg_to_cv2(msg, "bgr8")
has_rev = True
def __init__(self):
threading.Thread.__init__(self)
print("[Threade] DARKNET")
sys.path.append(os.path.join(os.getcwd(), 'python/'))
import darknet as dn
import pdb
print("Import successfully...")
dn.set_gpu(0)
self.net = dn.load_net("cfg/yolov3.cfg".encode('utf-8'),
"backup/yolov3_3300.weights".encode('utf-8'), 0)
self.meta = dn.load_meta("cfg/coco.data".encode('utf-8'))
print(
"========================== WAITING... ============================"
)
def main():
dn.set_gpu(0)
net = dn.load_net("model_data/yolov3.cfg".encode('utf-8'),
"model_data/yolov3.weights".encode('utf-8'), 0)
meta = dn.load_meta("model_data/coco.data".encode('utf-8'))
# Configure depth and color streams
pipeline = rs.pipeline()
config = rs.config()
config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30)
config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 30)
# Start streaming
pipeline.start(config)
# try:
# while True:
# Wait for a coherent pair of frames: depth and color
frames = pipeline.wait_for_frames()
depth_frame = frames.get_depth_frame()
color_frame = frames.get_color_frame()
if not depth_frame or not color_frame:
# continue
pass
# Convert images to numpy arrays
depth_image = np.asanyarray(depth_frame.get_data())
color_image = np.asanyarray(color_frame.get_data())
image = Image.fromarray(color_image)
r = dn.detect(net, meta, image)
# print(r)
# Show images
cv2.namedWindow('RealSense', cv2.WINDOW_AUTOSIZE)
cv2.imshow('RealSense', depth_image)
cv2.imshow('color_image', color_image)
cv2.waitKey(0)
# if cv2.waitKey(1) == 27:
# break
# cv2.destroyAllWindows()
# finally:
# Stop streaming
pipeline.stop()
def image_callback(msg):
global start_t, g_dict, net, meta, cam_param, net_init, call_count, det_flag, has_rev
if net_init:
model_name = 'all_640'
steps = '180000'
base_dir = '/home/momenta/mc3/python/weight/weights-' + model_name
net = dn.load_net(
os.path.join(base_dir, "yolov3-tiny-" + model_name + ".cfg"),
os.path.join(
base_dir,
"yolov3-tiny-" + model_name + "_" + steps + ".weights"), 0)
meta = dn.load_meta(
os.path.join(base_dir, "voc-" + model_name + ".data"))
filename = "cam_top.yaml"
f = open(filename)
cam_param = yaml.load(f)
net_init = False
# commented by dongyan at 22:30
# call_count += 1
# if call_count%5 != 0:
# return
# stopped commented
np_arr = np.fromstring(msg.data, np.uint8)
image_np = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
g_isBallNear = isBallNear(image_np)
print "g_isBallNear, ", g_isBallNear
# if the ball is near, always push the ball
if g_isBallNear:
return
t = time.time() - start_t
if det_flag == True:
print "det_flag == true, "
g_dict = detect(net,
meta,
cam_param,
image_np,
isshow=True,
issave=True,
name=str(t))
has_rev = True
else:
g_dict = {"door": [], "football": [], "robot": [], "conf": []}
def genTestData(name, inpShape, outShape):
net = dn.load_net(name + '.cfg', '', 0)
inp = np.random.standard_normal(inpShape).astype(np.float32)
inpData = dn.c_array(dn.c_float, inp.flatten())
pred = dn.predict(net, inpData)
total = np.prod(outShape)
out = np.zeros([total], np.float32)
for i in range(total):
out[i] = pred[i]
out = out.reshape(outShape)
np.save(name + '_in.npy', inp)
np.save(name + '_out.npy', out)
def __init__(self, cfg, weight, meta, W, H, camera_offset, tcp):
self.net = darknet.load_net(cfg, weight, 0)
self.meta = darknet.load_meta(meta)
self.bridge = CvBridge()
# receiving image's resolution
self.W = W
self.H = H
# camera's position referencing base_link
self.CAMERA_OFFSET = camera_offset
# tcp
self.TCP = tcp
# Openpose Pose Detector
self.pose_detector = PoseDetector(thresh=0.5, visualize=True)
print('Detector loaded')
def main():
if 'posix' == os.name:
darknet_home_dir_path = '/home/sangwook/lib_repo/cpp/darknet_github'
else:
darknet_home_dir_path = 'D:/lib_repo/cpp/rnd/darknet_github'
#darknet_home_dir_path = 'D:/lib_repo/cpp/darknet_github'
net = darknet.load_net(
bytes(darknet_home_dir_path + '/cfg/yolov3.cfg', encoding='utf-8'),
bytes(darknet_home_dir_path + '/yolov3.weights', encoding='utf-8'), 0)
meta = darknet.load_meta(
bytes(darknet_home_dir_path + '/cfg/coco.data', encoding='utf-8'))
detections = darknet.detect(
net, meta,
bytes(darknet_home_dir_path + '/data/dog.jpg', encoding='utf-8'))
print('Detections =', detections)
def genTestData(name, inpShape, outShape):
net = dn.load_net(name + '.cfg', '', 0)
inp = np.random.standard_normal(inpShape).astype(np.float32)
inpData = dn.c_array(dn.c_float, inp.flatten())
pred = dn.predict(net, inpData)
total = np.prod(outShape)
out = np.zeros([total], np.float32)
for i in range(total):
out[i] = pred[i]
out = out.reshape(outShape)
np.save(name + '_in.npy', inp)
np.save(name + '_out.npy', out)
def image_deal_top(msg):
global net_top, meta_top, cam_param_top, det_flag_top, has_rev_top, netInitFinished_top,np_arr_top
if netInitFinished_top == False:
model_name = 'door'
steps = '330000'
base_dir = '/home/momenta/mc3/python/weight/weights-'+model_name
net_top = dn.load_net(os.path.join(base_dir,"yolov3-tiny-"+model_name+".cfg"),
os.path.join(base_dir,"yolov3-tiny-"+model_name+"_"+steps+".weights"), 0)
meta_top = dn.load_meta(os.path.join(base_dir,"voc-"+model_name+".data"))
filename="./cam_param/"+tb_name+"_top.yaml"
f = open(filename)
cam_param_top = yaml.load(f)
netInitFinished_top = True
if det_flag_top:
det_flag_top=False
np_arr_top = np.fromstring(msg.data, np.uint8)
has_rev_top = True
def __init__(
self,
config_path: str = str(DEF_CONF, encoding="ascii"),
weights_path: str = str(DEF_W, encoding="ascii"),
data_path: str = str(DEF_DATA, encoding="ascii"),
gpu_enabled: bool = True,
):
self._config_path = config_path.encode("ascii")
self._weights_path = weights_path.encode("ascii")
self._data_path = data_path.encode("ascii")
self._gpu_enabled = 0 if gpu_enabled else 1
dn.set_gpu(self._gpu_enabled)
self._net = dn.load_net(self._config_path, self._weights_path, 0)
self._metadata = dn.load_meta(self._data_path)
self._darknet_image = dn.make_image(dn.network_width(self._net),
dn.network_height(self._net), 3)
def __init__(self, detector_num=0):
import darknet as dn
dn.set_gpu(int(constants.DARKNET_GPU))
self.detector_num = detector_num
#self.net = dn.load_net(py_util.encode(WEIGHT_PATH + 'yolov3-thor.cfg'),
# py_util.encode(WEIGHT_PATH + 'yolov3-thor_final.weights'), 0)
#self.meta = dn.load_meta(py_util.encode(WEIGHT_PATH + 'thor.data'))
#self.net_custom = dn.load_net(py_util.encode(WEIGHT_PATH + 'yolov4-custom.cfg'),
# py_util.encode(WEIGHT_PATH + 'yolov4-custom_4000.weights'), 0)
#self.meta_custom = dn.load_meta(py_util.encode(WEIGHT_PATH + 'obj_less.data'))
self.net_origin = dn.load_net(
py_util.encode(WEIGHT_PATH + 'yolov4.cfg', 'ascii'),
py_util.encode(WEIGHT_PATH + 'yolov4.weights', 'ascii'), 0)
self.meta_origin = dn.load_meta(
py_util.encode(WEIGHT_PATH + 'coco.data', 'ascii'))
self.count = 0
def image_callback(msg):
global net, meta, cam_param, det_flag, has_rev, netInitFinished,np_arr
if netInitFinished == False:
model_name = 'all_640_xy'
steps = '140000'
base_dir = '/home/momenta/mc3/python/weight/weights-'+model_name
net = dn.load_net(os.path.join(base_dir,"yolov3-tiny-"+model_name+".cfg"),
os.path.join(base_dir,"yolov3-tiny-"+model_name+"_"+steps+".weights"), 0)
meta = dn.load_meta(os.path.join(base_dir,"voc-"+model_name+".data"))
filename="./cam_param/"+tb_name+"_bottom.yaml"
f = open(filename)
cam_param = yaml.load(f)
netInitFinished = True
if det_flag:
det_flag=False
np_arr = np.fromstring(msg.data, np.uint8)
has_rev = True
def __init__(self, darknet_path):
self.name = "YOLO-Recogniser"
# Cd to the correct folder
current_path = os.getcwd()
os.chdir(darknet_path)
# Load the darknet path
self.network = darknet.load_net("cfg/yolov3-tiny.cfg",
"yolov3-tiny.weights", 0)
self.metadata = darknet.load_meta("cfg/coco.data")
self.path = darknet_path
# Change back to current_path
os.chdir(current_path)
self.log("Created")
# Stupid python path shit.
# Instead just add darknet.py to somewhere in your python path
# OK actually that might not be a great idea, idk, work in progress
# Use at your own risk. or don't, i don't care
import sys, os
sys.path.append(os.path.join(os.getcwd(),'python/'))
import darknet as dn
net = dn.load_net("cfg/tiny-yolo.cfg", "tiny-yolo.weights", 0)
meta = dn.load_meta("cfg/coco.data")
r = dn.detect(net, meta, "data/dog.jpg")
print r
# And then down here you could detect a lot more images like:
r = dn.detect(net, meta, "data/eagle.jpg")
print r
r = dn.detect(net, meta, "data/giraffe.jpg")
print r
r = dn.detect(net, meta, "data/horses.jpg")
print r
r = dn.detect(net, meta, "data/person.jpg")
print r
# Stupid python path shit.
# Instead just add darknet.py to somewhere in your python path
# OK actually that might not be a great idea, idk, work in progress
# Use at your own risk. or don't, i don't care
import sys, os
sys.path.append(os.path.join(os.getcwd(),'python/'))
import darknet as dn
import pdb
dn.set_gpu(0)
net = dn.load_net("cfg/yolo-thor.cfg", "/home/pjreddie/backup/yolo-thor_final.weights", 0)
meta = dn.load_meta("cfg/thor.data")
r = dn.detect(net, meta, "data/bedroom.jpg")
print r
# And then down here you could detect a lot more images like:
r = dn.detect(net, meta, "data/eagle.jpg")
print r
r = dn.detect(net, meta, "data/giraffe.jpg")
print r
r = dn.detect(net, meta, "data/horses.jpg")
print r
r = dn.detect(net, meta, "data/person.jpg")
print r
