def __call__(self, fname):
with Image.open(fname) as img:
img = img.convert('RGB')
img_size = Size(img.size[0], img.size[1])
if self.dataset == 'VOC':
#fname : '~/VOC/JPEGImages/002222.jpg'
with open(
os.path.join(fname[:-21], 'Annotations',
fname[-10:-4] + '.xml'), 'r') as f:
doc = lxml.etree.parse(f)
boxes = []
objects = doc.xpath('/annotation/object')
for obj in objects:
label = obj.xpath('name')[0].text
xmin = float(obj.xpath('bndbox/xmin')[0].text)
xmax = float(obj.xpath('bndbox/xmax')[0].text)
ymin = float(obj.xpath('bndbox/ymin')[0].text)
ymax = float(obj.xpath('bndbox/ymax')[0].text)
labels = self.label2idx[label]
center, size = abs2prop(
xmin, xmax, ymin, ymax,
img_size) # make gt to 0~1 important!!!!!!!!!!!!!!
box = Box(obj, labels, center, size)
boxes.append(box)
elif self.dataset == 'KITTI':
with open(
os.path.join(fname[:-18], 'label_2',
fname[-10:-4] + '.txt'), 'r') as fp:
objs = [line.split(' ') for line in fp.readlines()]
boxes = []
for obj in objs:
if not obj[0] == 'DontCare':
xmin = float(obj[4])
ymin = float(obj[5])
xmax = float(obj[6])
ymax = float(obj[7])
label = self.label2idx[obj[0]]
center, size = abs2prop(
xmin, xmax, ymin, ymax, img_size
) # Convert the absolute min-max box bound to proportional center-width bounds
# (/300 , /1300) -> (0~1, 0~1)
box = Box(obj[0], label, center, size)
boxes.append(box)
sample = Sample(fname, boxes, img_size)
return img, labels, sample
def initialize_screen(self):
self.screen = pygame.display.set_mode(
(self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
HWSURFACE | DOUBLEBUF | RESIZABLE, 32)
self.field_rect_outer = Rect(
self.FIELD_LIMITS[0], self.FIELD_LIMITS[1],
int(self.FIELD_SIZE[0] * self.zoom_factor),
int(self.FIELD_SIZE[1] * self.zoom_factor))
self.field_box = Box(surface=self.screen,
rect=self.field_rect_outer,
background_color=self.field_bgcolor)
self.field_rect = self.field_box.get_internal_rect()
def transform_box(box, orig_size, new_size, h_off, w_off):
#---------------------------------------------------------------------------
# Compute the new coordinates of the box
#---------------------------------------------------------------------------
xmin, xmax, ymin, ymax = prop2abs(box.center, box.size, orig_size)
xmin += w_off
xmax += w_off
ymin += h_off
ymax += h_off
#---------------------------------------------------------------------------
# Check if the center falls within the image
#---------------------------------------------------------------------------
width = xmax - xmin
height = ymax - ymin
new_cx = xmin + int(width / 2)
new_cy = ymin + int(height / 2)
if new_cx < 0 or new_cx >= new_size.w:
return None
if new_cy < 0 or new_cy >= new_size.h:
return None
center, size = abs2prop(xmin, xmax, ymin, ymax, new_size)
return Box(box.label, box.labelid, center, size)
def _load_target(self, image_id, img_size=None):
annotation_path = path.join(
config.DATA_PATH.format(name=self._NAME),
config.ANNOTATIONS_PATH.format(id_=image_id))
with open(annotation_path) as fp:
next(fp), next(fp) # Skip the first two rows
reader = csv.DictReader(fp,
fieldnames=("x1", "y1", "x2", "y2", "x3",
"y3", "x4", "y4", "category",
"difficult"),
delimiter=" ")
boxes = []
labels = []
for r in reader:
label_id = self._REVERSE_LABELS_DICT.get(r["category"])
if label_id is None:
continue
x1, y1, x2, y2, x3, y3, x4, y4 = [
float(r[k])
for k in ("x1", "y1", "x2", "y2", "x3", "y3", "x4", "y4")
]
x_min = min(x1, x2, x3, x4)
y_min = min(y1, y2, y3, y4)
x_max = max(x1, x2, x3, x4)
y_max = max(y1, y2, y3, y4)
boxes.append(Box(x_min, y_min, x_max, y_max))
labels.append(label_id)
return dict(boxes=boxes, labels=labels)
def __build_sample_list(self, root, annot_files, dataset_name):
image_root = root + '/JPEGImages/'
samples = []
for fn in tqdm(annot_files, desc=dataset_name, unit='samples'):
with open(fn, 'r') as f:
doc = lxml.etree.parse(f)
filename = image_root + doc.xpath(
'/annotation/filename')[0].text
if not os.path.exists(filename):
continue
img = cv2.imread(filename)
imgsize = Size(img.shape[1], img.shape[0])
boxes = []
objects = doc.xpath('/annotation/object')
for obj in objects:
label = obj.xpath('name')[0].text
if label == myObject:
xmin = int(float(obj.xpath('bndbox/xmin')[0].text))
xmax = int(float(obj.xpath('bndbox/xmax')[0].text))
ymin = int(float(obj.xpath('bndbox/ymin')[0].text))
ymax = int(float(obj.xpath('bndbox/ymax')[0].text))
center, size = abs2prop(xmin, xmax, ymin, ymax,
imgsize)
box = Box(label, self.lname2id[label], center, size)
boxes.append(box)
if not boxes:
continue
sample = Sample(filename, boxes, imgsize)
samples.append(sample)
return samples
def __call__(self, img, targets):
if self._symmetric:
scale_y = 1 + random.uniform(-self._scale, self._scale)
scale_x = scale_y
else:
scale_y = 1 + random.uniform(-self._scale, self._scale)
scale_x = 1 + random.uniform(-self._scale, self._scale)
H, W, C = img.shape
img = cv2.resize(img, None, fx=scale_x, fy=scale_y)
new_H, new_W, _ = img.shape
y_pad = H - new_H
x_pad = W - new_W
# When we scale, with a factor >1 some part of the image must be dropped,
# We handle this via a ._pad<0 and we make sure we drop the same amount on each side of the image
# ie the center of the image remains fixes
# Same for factors <1, describing padding of size ._pad>0 to be added
y_pad_1, y_pad_2 = ceil(y_pad/2.), floor(y_pad/2.)
x_pad_1, x_pad_2 = ceil(x_pad/2.), floor(x_pad/2.)
canvas = np.zeros((H, W, C))
canvas[max(y_pad_1,0):min(H-y_pad_2,H), max(x_pad_1,0):min(W-x_pad_2,W), :] = \
img[max(-y_pad_1,0):H-y_pad_1, max(-x_pad_1,0):W-x_pad_1, :]
img = canvas
targets["boxes"] *= [scale_x, scale_y, scale_x, scale_y]
targets["boxes"] += [x_pad/2, y_pad/2, x_pad/2, y_pad/2]
targets = clip_boxes(targets, Box(0,0,W,H))
return img, targets
def _crop_to_size(cls, image, target, recurs_cnt=0):
# Dota contains images of differnt size, but each pixel represents the same scale
# Make sure all images are at the same scale by croping to a maximum size
H, W = image.size[::-1] # PIL returns W, H
nH, nW = config.CROP_TO_SIZE
nH, nW = min(H, nH), min(W, nW)
offset_y, offset_x = random.randint(0,
H - nH), random.randint(0, W - nW)
new_image = image.crop(
(offset_x, offset_y, offset_x + nW, offset_y + nH))
new_boxes = [
Box(b.x_min - offset_x, b.y_min - offset_y, b.x_max - offset_x,
b.y_max - offset_y) for b in target["boxes"]
]
# Remove boxes outside the image
new_target = {"boxes": [], "labels": []}
for box, label in zip(new_boxes, target["labels"]):
if box.x_min >= 0 and box.y_min >= 0 and box.x_max <= nW and box.y_max <= nH:
new_target["boxes"].append(box)
new_target["labels"].append(label)
if not new_target["labels"]:
# We removed all boxes, retry
return cls._crop_to_size(image, target, recurs_cnt + 1)
else:
return new_image, new_target
def __call__(self, data, label, gt):
flip = data.transpose(Image.FLIP_LEFT_RIGHT)
boxes = []
for box in gt.boxes:
center = Point(1 - box.center.x, box.center.y)
box = Box(box.label, box.labelid, center, box.size)
boxes.append(box)
gt = Sample(gt.filename, boxes, gt.imgsize)
return flip, label, gt
def __call__(self, data, label, gt):
data = cv2.flip(data, 1)
boxes = []
for box in gt.boxes:
center = Point(1 - box.center.x, box.center.y)
box = Box(box.label, box.labelid, center, box.size)
boxes.append(box)
gt = Sample(gt.filename, boxes, gt.imgsize)
return data, label, gt
def __call__(self, data, label, gt):
#-----------------------------------------------------------------------
# Check whether to sample or not
#-----------------------------------------------------------------------
if not self.sample:
return data, label, gt
#-----------------------------------------------------------------------
# Retry sampling a couple of times
#-----------------------------------------------------------------------
source_boxes = anchors2array(gt.boxes, gt.imgsize)
box = None
box_arr = None
for _ in range(self.max_trials):
#-------------------------------------------------------------------
# Sample a bounding box
#-------------------------------------------------------------------
scale = random.uniform(self.min_scale, self.max_scale)
aspect_ratio = random.uniform(self.min_aspect_ratio,
self.max_aspect_ratio)
# make sure width and height will not be larger than 1
aspect_ratio = max(aspect_ratio, scale**2)
aspect_ratio = min(aspect_ratio, 1 / (scale**2))
width = scale * sqrt(aspect_ratio)
height = scale / sqrt(aspect_ratio)
cx = 0.5 * width + random.uniform(0, 1 - width)
cy = 0.5 * height + random.uniform(0, 1 - height)
center = Point(cx, cy)
size = Size(width, height)
#-------------------------------------------------------------------
# Check if the box satisfies the jaccard overlap constraint
#-------------------------------------------------------------------
box_arr = np.array(prop2abs(center, size, gt.imgsize))
overlap = compute_overlap(box_arr, source_boxes, 0)
if overlap.best and overlap.best.score >= self.min_jaccard_overlap:
box = Box(None, None, center, size)
break
if box is None:
return None
#-----------------------------------------------------------------------
# Crop the box and adjust the ground truth
#-----------------------------------------------------------------------
new_size = Size(box_arr[1] - box_arr[0], box_arr[3] - box_arr[2])
w_off = -box_arr[0]
h_off = -box_arr[2]
data = data[box_arr[2]:box_arr[3], box_arr[0]:box_arr[1]]
gt = transform_gt(gt, new_size, h_off, w_off)
return data, label, gt
def __build_sample_list(self, root, annot_files):
"""
Build a list of samples for the VOC dataset (either trainval or test)
"""
image_root = os.path.join(root, 'rgb-images')
samples = []
#-----------------------------------------------------------------------
# Process each annotated sample
#-----------------------------------------------------------------------
for fn in tqdm(annot_files, desc='ucf_24_frame', unit='samples'):
act = fn.split('/')[4]
video = fn.split('/')[5]
frame_id = fn.split('/')[-1][:-4]
image_path = os.path.join(image_root, act, video,
'{}.jpg'.format(frame_id))
#---------------------------------------------------------------
# Get the file dimensions
#---------------------------------------------------------------
if not os.path.exists(image_path):
continue
img = cv2.imread(image_path)
imgsize = Size(img.shape[1], img.shape[0])
#---------------------------------------------------------------
# Get boxes for all the objects
#---------------------------------------------------------------
boxes = []
with open(fn, 'r') as fin:
objects = fin.readlines()
for line in objects:
line = line[:-1]
#-----------------------------------------------------------
# Get the properties of the box and convert them to the
# proportional terms
#-----------------------------------------------------------
obj = line.split(' ')
label = int(obj[0]) - 1
xmin = int(float(obj[1]))
ymin = int(float(obj[2]))
xmax = int(float(obj[3]))
ymax = int(float(obj[4]))
center, size = abs2prop(xmin, xmax, ymin, ymax, imgsize)
box = Box(self.lid2name[label], label, center, size)
boxes.append(box)
if not boxes:
continue
sample = Sample(image_path, boxes, imgsize)
samples.append(sample)
return samples
def _build_sample_list(self, root, annot_files):
image_root = root + 'VOC_Jpeg/'
image_seg_root = root + 'VOC_Segmentation/'
samples = []
for fn in tqdm(annot_files, unit='samples'):
with open(fn, 'r') as f:
doc = lxml.etree.parse(f)
filename = image_root + doc.xpath(
'/annotation/filename')[0].text
with open(fn, 'r') as f1:
doc1 = lxml.etree.parse(f1)
seg_gt = image_seg_root + doc1.xpath(
'/annotation/filename')[0].text
seg_gt = seg_gt.replace('jpg', 'png')
seg_gt_to_compare = seg_gt
#---------------------------------------------------------------
# Get the file dimensions
#---------------------------------------------------------------
if not os.path.exists(filename):
continue
img = cv2.imread(filename)
img_seg_gt = cv2.imread(seg_gt)
imgsize = Size(img.shape[1], img.shape[0])
#---------------------------------------------------------------
# Get boxes for all the objects
#---------------------------------------------------------------
boxes = []
objects = doc.xpath('/annotation/object')
for obj in objects:
#-----------------------------------------------------------
# Get the properties of the box and convert them to the
# proportional terms
#-----------------------------------------------------------
label = obj.xpath('name')[0].text
xmin = int(float(obj.xpath('bndbox/xmin')[0].text))
xmax = int(float(obj.xpath('bndbox/xmax')[0].text))
ymin = int(float(obj.xpath('bndbox/ymin')[0].text))
ymax = int(float(obj.xpath('bndbox/ymax')[0].text))
center, size = abs2prop(xmin, xmax, ymin, ymax, imgsize)
box = Box(label, self.lname2id[label], center, size)
boxes.append(box)
if not boxes:
continue
sample = Sample(filename, boxes, imgsize, seg_gt,
seg_gt_to_compare)
samples.append(sample)
return samples
def __build_sample_list(self, root, dataset_name):
"""
Build a list of samples for the VOC dataset (either trainval or test)
"""
image_root = root + '/JPEGImages/'
annot_root = root + '/Annotations/'
annot_files = glob(annot_root + '/*xml')
samples = []
#-----------------------------------------------------------------------
# Process each annotated sample
#-----------------------------------------------------------------------
for fn in tqdm(annot_files, desc=dataset_name, unit='samples'):
with open(fn, 'r') as f:
doc = lxml.etree.parse(f)
filename = image_root + doc.xpath(
'/annotation/filename')[0].text
#---------------------------------------------------------------
# Get the file dimensions
#---------------------------------------------------------------
if not os.path.exists(filename):
continue
img = cv2.imread(filename)
imgsize = Size(img.shape[1], img.shape[0])
#---------------------------------------------------------------
# Get boxes for all the objects
#---------------------------------------------------------------
boxes = []
objects = doc.xpath('/annotation/object')
for obj in objects:
#-----------------------------------------------------------
# Get the properties of the box and convert them to the
# proportional terms
#-----------------------------------------------------------
label = obj.xpath('name')[0].text
xmin = int(float(obj.xpath('bndbox/xmin')[0].text))
xmax = int(float(obj.xpath('bndbox/xmax')[0].text))
ymin = int(float(obj.xpath('bndbox/ymin')[0].text))
ymax = int(float(obj.xpath('bndbox/ymax')[0].text))
center, size = abs2prop(xmin, xmax, ymin, ymax, imgsize)
box = Box(label, self.lname2id[label], center, size)
boxes.append(box)
if not boxes:
continue
sample = Sample(filename, boxes, imgsize)
samples.append(sample)
return samples
def initialize_screen(self):
self.screen = pygame.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
HWSURFACE | DOUBLEBUF | RESIZABLE, 32)
self.field_rect_outer = Rect(self.FIELD_LIMITS[0],
self.FIELD_LIMITS[1],
int(self.FIELD_SIZE[0]*self.zoom_factor),
int(self.FIELD_SIZE[1]*self.zoom_factor))
self.field_box = Box(surface=self.screen,
rect=self.field_rect_outer,
background_color=self.field_bgcolor
)
self.field_rect = self.field_box.get_internal_rect()
def __call__(self, img, targets):
H, W, C = img.shape
move_y = int(random.uniform(-self._rel_step, self._rel_step) * H)
move_x = int(random.uniform(-self._rel_step, self._rel_step) * W)
canvas = np.zeros((H, W, C), dtype=np.float)
canvas[max(move_y,0):min(H+move_y, H), max(move_x,0):min(W+move_x, W), :] = \
img[max(-move_y,0):min(H-move_y, H), max(-move_x,0):min(W-move_x, W), :]
img = canvas
targets["boxes"] += [move_x, move_y, move_x, move_y]
targets = clip_boxes(targets, Box(0,0,W,H))
return img, targets
def __build_sample_list(self, root,image_dir,info_dir):
"""
Build a list of samples for the VOC dataset (either trainval or test)
"""
samples = []
file = open(root+info_dir ,'r')
All = file.read()
file.close()
lines = All.split('\n')
print(len(lines))
#-----------------------------------------------------------------------
# Process each annotated sample
#-----------------------------------------------------------------------
i=0
while i<(len(lines)-1)/10:
#---------------------------------------------------------------
# Get the file dimensions
#---------------------------------------------------------------
filename = root+image_dir+lines[i]
img = cv2.imread(filename)
imgsize = Size(img.shape[1], img.shape[0])
#---------------------------------------------------------------
# Get boxes for all the objects
#---------------------------------------------------------------
boxes = []
i+=1
num_objects = int(lines[i])
if not num_objects:
i+=2
continue
i+=1
for obj in range(num_objects):
#-----------------------------------------------------------
# Get the properties of the box and convert them to the
# proportional terms
#-----------------------------------------------------------
label = 'face'
xmin = int(lines[i+obj].split()[0])-int(lines[i+obj].split()[2])/2
xmax = int(lines[i+obj].split()[0])+int(lines[i+obj].split()[2])/2
ymin = int(lines[i+obj].split()[1])-int(lines[i+obj].split()[3])/2
ymax = int(lines[i+obj].split()[1])+int(lines[i+obj].split()[3])/2
center, size = abs2prop(xmin, xmax, ymin, ymax, imgsize)
box = Box(label, self.lname2id[label], center, size)
boxes.append(box)
i+=num_objects
sample = Sample(filename, boxes, imgsize)
samples.append(sample)
return samples
def _match_batch_img_sizes(batch):
# Resize so that all images have the same size -> Varying sizes create memory leak in FasterRCNN
# nH = max(img.size[1] for img, _ in batch)
# nW = max(img.size[0] for img, _ in batch)
nH = nW = config.IMAGE_SIZE
new_batch = []
for image, target in batch:
H, W = image.size[::-1] # PIL returns W, H
scale_y, scale_x = nH / H, nW / W
image = image.resize((nW, nH))
target["boxes"] = [
Box(b.x_min * scale_x, b.y_min * scale_y, b.x_max * scale_x,
b.y_max * scale_y) for b in target["boxes"]
]
new_batch.append((image, target))
return new_batch
def _load_target(self, image_id, img_size=None):
annotation_path = self._annotation_path(image_id)
with open(annotation_path) as fp:
reader = csv.DictReader(fp, fieldnames=("label", "cx", "cy", "width", "height"), delimiter=" ")
boxes = []
labels = []
W, H = img_size
for r in reader:
cx, cy, w, h = float(r["cx"]), float(r["cy"]), float(r["width"]), float(r["height"])
x_min = max(cx*W - w*W/2, 0)
y_min = max(cy*H - h*H/2, 0)
x_max = min(cx*W + w*W/2, W)
y_max = min(cy*H + h*H/2, H)
boxes.append(Box(x_min, y_min, x_max, y_max))
labels.append(int(r["label"]))
return dict(boxes=boxes, labels=labels)
def decode_boxes(pred,
anchors,
confidence_threshold=0.01,
lid2name={},
detections_cap=200):
"""
Decode boxes from the neural net predictions.
Label names are decoded using the lid2name dictionary - the id to name
translation is not done if the corresponding key does not exist.
"""
#---------------------------------------------------------------------------
# Find the detections
#---------------------------------------------------------------------------
num_classes = pred.shape[1] - 4
bg_class = num_classes - 1
box_class = np.argmax(pred[:, :num_classes - 1], axis=1)
confidence = pred[np.arange(len(pred)), box_class]
if detections_cap is not None:
detections = np.argsort(confidence)[::-1][:detections_cap]
else:
detections = np.argsort(confidence)[::-1]
#---------------------------------------------------------------------------
# Decode coordinates of each box with confidence over a threshold
#---------------------------------------------------------------------------
boxes = []
for idx in detections:
confidence = pred[idx, box_class[idx]]
if confidence < confidence_threshold:
break
center, size = decode_location(pred[idx, num_classes:], anchors[idx])
cid = box_class[idx]
cname = None
if cid in lid2name:
cname = lid2name[cid]
det = (confidence, normalize_box(Box(cname, cid, center, size)))
boxes.append(det)
return boxes
def __call__(self, img, targets):
H, W, _ = img.shape
targets = clip_boxes(targets, Box(0, 0, W, H))
return img, targets
class Simulation(object):
"""
The main simulation entry point
"""
# basic defaults
SCREEN_WIDTH, SCREEN_HEIGHT = 700, 700
GRID_SIZE = 20, 20
FIELD_SIZE = 500, 500
FIELD_LIMITS = 0, 0, 600, 600
field_bgcolor = SIM_COLORS['white']
def __init__(self, params=None):
pygame.init()
if params is not None:
self.SCREEN_HEIGHT, self.SCREEN_WIDTH = int(float(params['display']['height']) * SCALE), \
int(float(params['display']['width']) * SCALE)
self.FIELD_LIMITS = int(float(params['field_top_left_x']) * SCALE), \
int(float(params['field_top_left_y']) * SCALE), \
int(float(params['field_bottom_right_x']) * SCALE), \
int(float(params['field_bottom_right_y']) * SCALE)
self.FIELD_SIZE = self.FIELD_LIMITS[2] - self.FIELD_LIMITS[
0], self.FIELD_LIMITS[3] - self.FIELD_LIMITS[1]
self.GRID_SIZE = int(float(params['cell']['width']) * SCALE), int(
float(params['cell']['height']) * SCALE)
# zoom and centering
self.offset = 0, 0
self.zoom_factor = 1.0
self._old_screen = self.SCREEN_WIDTH, self.SCREEN_HEIGHT
# setup the screen and the box field of play
self.initialize_screen()
# agents
self.agents = pygame.sprite.Group()
self.agent_image = pygame.image.load(
'assets/blueagent.bmp').convert_alpha()
self.controller = SocialForceController(self)
# self.controller = RandomController(self)
# time related items
self.clock = pygame.time.Clock()
self.paused = False
self.simulation_timer = Timer(10, self.simulation_update)
# create the grid
self.setup_grid()
# additional options (remove this)
self.options = dict(draw_grid=True)
# setup objects (waypoints, obstacles)
self.waypoints = dict()
self.obstacles = []
self._agent_count = 0
# initialize the time
self.time_passed = 0
def initialize_screen(self):
self.screen = pygame.display.set_mode(
(self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
HWSURFACE | DOUBLEBUF | RESIZABLE, 32)
self.field_rect_outer = Rect(
self.FIELD_LIMITS[0], self.FIELD_LIMITS[1],
int(self.FIELD_SIZE[0] * self.zoom_factor),
int(self.FIELD_SIZE[1] * self.zoom_factor))
self.field_box = Box(surface=self.screen,
rect=self.field_rect_outer,
background_color=self.field_bgcolor)
self.field_rect = self.field_box.get_internal_rect()
def setup_grid(self):
self.grid_nrows = self.FIELD_SIZE[1] / int(
self.GRID_SIZE[0] * self.zoom_factor)
self.grid_ncols = self.FIELD_SIZE[0] / int(
self.GRID_SIZE[1] * self.zoom_factor)
def get_agent_neighbors(self, agent, dist_range):
neighbors = []
for other in self.agents:
if not agent.id == other.id:
dist = agent.position.get_distance(other.position)
if dist <= dist_range:
neighbors.append(other)
return neighbors
def draw_grid(self):
for y in range(self.grid_nrows + 1):
pygame.draw.line(
self.screen, SIM_COLORS['light gray'],
(self.field_rect.left, self.field_rect.top +
y * int(self.GRID_SIZE[1] * self.zoom_factor) - 1),
(self.field_rect.right - 1, self.field_rect.top +
y * int(self.GRID_SIZE[1] * self.zoom_factor) - 1))
for x in range(self.grid_ncols + 1):
pygame.draw.line(
self.screen, SIM_COLORS['light gray'],
(self.field_rect.left +
x * int(self.GRID_SIZE[0] * self.zoom_factor) - 1,
self.field_rect.top),
(self.field_rect.left +
x * int(self.GRID_SIZE[0] * self.zoom_factor) - 1,
self.field_rect.bottom - 1))
def xy2coord(self, pos):
""" Convert a (x, y) pair to a (nrow, ncol) coordinate
"""
x, y = (pos[0] - self.field_rect.left, pos[1] - self.field_rect.top)
return int(y) / self.GRID_SIZE[1], int(x) / self.GRID_SIZE[0]
def coord2xy_mid(self, coord):
""" Convert a (nrow, ncol) coordinate to a (x, y) pair,
where x,y is the middle of the square at the coord
"""
nrow, ncol = coord
return (self.field_rect.left + ncol * self.GRID_SIZE[0] +
self.GRID_SIZE[0] / 2, self.field_rect.top +
nrow * self.GRID_SIZE[1] + self.GRID_SIZE[1] / 2)
def draw_background(self):
pygame.draw.rect(self.screen, SIM_COLORS['light gray'],
[0, 0, self.SCREEN_WIDTH, self.SCREEN_HEIGHT])
def draw(self):
self.draw_background()
self.field_box.draw()
if self.options['draw_grid']:
self.draw_grid()
for waypoint in self.waypoints:
self.waypoints[waypoint].draw()
for obstacle in self.obstacles:
obstacle.draw()
for agent in self.agents:
agent.draw()
def demo_populate_scene(self):
# agents
self.agents.add(
Agent(agent_id=0,
screen=self.screen,
game=self,
agent_image=self.agent_image,
field=self.field_rect,
init_position=(3, 1),
init_direction=(1, 1),
max_speed=1.8,
waypoints=[self.waypoints['stop'], self.waypoints['start']]))
self.agents.add(
Agent(agent_id=1,
screen=self.screen,
game=self,
agent_image=self.agent_image,
field=self.field_rect,
init_position=(3, 5),
init_direction=(1, 1),
max_speed=1.8,
waypoints=[self.waypoints['start'], self.waypoints['stop']]))
self.agents.add(
Agent(agent_id=2,
screen=self.screen,
game=self,
agent_image=self.agent_image,
field=self.field_rect,
init_position=(2, 2),
init_direction=(1, 1),
max_speed=1.14,
waypoints=[self.waypoints['start'], self.waypoints['stop']]))
def simulation_update(self):
for agent in self.agents:
agent.update(0.1)
self.controller.drive_single_step(agent, delta_time=0.1)
agent.draw()
self.draw()
def _process_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.paused = not self.paused
elif event.key == pygame.K_g:
if pygame.key.get_mods() & pygame.KMOD_CTRL:
self.options[
'draw_grid'] = not self.options['draw_grid']
elif event.key == pygame.K_PLUS or event.key == pygame.K_EQUALS:
#self.zoom_factor += 0.1
self.initialize_screen()
self.setup_grid()
elif event.key == pygame.K_MINUS:
#self.zoom_factor -= 0.1
self.initialize_screen()
self.setup_grid()
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
pass
elif event.type == VIDEORESIZE:
self._old_screen = self.SCREEN_WIDTH, self.SCREEN_HEIGHT
self.SCREEN_WIDTH, self.SCREEN_HEIGHT = event.dict['size']
self.offset = self.SCREEN_WIDTH - self._old_screen[
0], self.SCREEN_HEIGHT - self._old_screen[1]
#self.FIELD_LIMITS = self.FIELD_LIMITS[0]+self.offset[0], self.FIELD_LIMITS[1]+self.offset[1], \
# self.FIELD_LIMITS[2], self.FIELD_LIMITS[3]
#fx = (self.SCREEN_WIDTH / 2) - (self.FIELD_SIZE[0] / 2)
#fy = (self.SCREEN_HEIGHT / 2) - (self.FIELD_SIZE[1] / 2)
#self.FIELD_LIMITS = fx, fy, self.FIELD_LIMITS[2], self.FIELD_LIMITS[3]
self.initialize_screen()
self.setup_grid()
_total_time = 0
def run(self):
# initialize modules
pygame.init()
while True:
self.time_passed = self.clock.tick()
# self._total_time += self.time_passed
# if self._total_time < 1000:
# continue
# handle any events
self._process_events()
if not self.paused:
self.simulation_timer.update(self.time_passed)
# update the game surface
pygame.display.flip()
def add_agents(self, agent_dict):
for agent in agent_dict:
dx, dy = float(agent['dx']), float(agent['dy'])
x, y = float(agent['x']), float(agent['y'])
num = int(agent['n'])
a_type = int(agent['type'])
# spawn an agent in a random direction and position(within dx, dy)
direction = (randint(-1, 1), randint(-1, 1))
position = random_position(x, y, dx, dy)
waypoints = [awp['id'] for awp in agent['addwaypoint']]
rd = 0.3
for _ in xrange(num):
self.agents.add(
Agent(agent_id=self._agent_count,
atype=a_type,
screen=self.screen,
game=self,
agent_image=self.agent_image,
field=self.field_rect,
init_position=position,
init_direction=direction,
max_speed=normalvariate(1.34, 0.26),
radius=rd,
waypoints=[self.waypoints[wp] for wp in waypoints]))
self._agent_count += 1
# we are done here
# TODO - move the velocity stuff to a neat function
# TODO - find a suitable fatness distribution
def add_waypoints(self, waypoint_dict):
for waypoint in waypoint_dict:
w_id = waypoint['id']
radius = float(waypoint['radius'])
wtype = waypoint['type']
x, y = float(waypoint['x']), float(waypoint['y'])
self.waypoints.update({
w_id:
Waypoint(screen=self.screen,
wid=w_id,
wtype=wtype,
position=(x, y),
radius=radius)
})
def add_obstacles(self, obstacle_dict):
for obstacle in obstacle_dict:
o_id = obstacle['id']
p1 = float(obstacle['p1'])
p2 = float(obstacle['p2'])
p3 = float(obstacle['p3'])
p4 = float(obstacle['p4'])
o_type = obstacle['type'].title()
self.obstacles.append(
Obstacle(screen=self.screen,
oid=o_id,
otype=o_type,
params=(p1, p2, p3, p4)))
def quit(self):
sys.exit()
from utils import Box
from skimage.feature import hog
DATA_DIR = './images'
BOX_SIZE = Box(h=100, w=66).scale(2)
WINDOW_STEP = 20
SCALES = [0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6, 1.8, 2]
CV_FOLDS = 5
def features_extract_fn(img):
return hog(img,
orientations=16,
pixels_per_cell=(32, 32),
cells_per_block=(3, 3),
block_norm='L2-Hys')
def get_region_boxes(img,
pad=10,
erode_iters=3,
min_box_width=50,
min_aspect=0.7,
min_box_width_rel=0.1,
approx_factor=0.06,
bin_thresh=5,
min_box_height=20,
debug=False):
norm_img_src = preprocess_image(img, bin_thresh, False, debug)
# pad to make clear edges
src_img = cv2.copyMakeBorder(img,
pad,
pad,
pad,
pad,
cv2.BORDER_CONSTANT,
value=(0, ))
if debug:
cv2.imshow('orig image with black borders', src_img) # andrey
cv2.waitKey(0)
norm_img = cv2.copyMakeBorder(norm_img_src,
pad,
pad,
pad,
pad,
cv2.BORDER_CONSTANT,
value=(0, ))
if debug:
cv2.imshow('bw image with black borders', norm_img) # andrey
cv2.waitKey(0)
kernel = np.ones(shape=(3, 3))
norm_img = cv2.erode(norm_img, kernel, iterations=erode_iters)
if debug:
cv2.imshow('bw image after erosion', norm_img) # andrey
cv2.waitKey(0)
norm_img = cv2.dilate(norm_img, kernel, iterations=erode_iters)
if debug:
cv2.imshow('bw image after closing', norm_img) # andrey
cv2.waitKey(0)
#kernel = np.ones(shape=(3, 11))
#norm_img = cv2.erode(norm_img, kernel, iterations=erode_iters)
#if debug:
# cv2.imshow('bw image after erosion', norm_img) # andrey
# cv2.waitKey(0)
#norm_img = cv2.dilate(norm_img, kernel, iterations=erode_iters)
#if debug:
# cv2.imshow('bw image after closing', norm_img) # andrey
# cv2.waitKey(0)
#
#kernel = np.ones(shape=(11, 3))
#norm_img = cv2.erode(norm_img, kernel, iterations=erode_iters)
#if debug:
# cv2.imshow('bw image after erosion', norm_img) # andrey
# cv2.waitKey(0)
#norm_img = cv2.dilate(norm_img, kernel, iterations=erode_iters)
#if debug:
# cv2.imshow('bw image after closing', norm_img) # andrey
# cv2.waitKey(0)
regs = src_img.copy()
cnts = cv2.findContours(norm_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
#cnts = cv2.findContours(norm_img, cv2.RETR_LIST,cv2.CHAIN_APPROX_NONE)
# box_offset = 2 if erode_iters == 0 else 0
box_offset = 0
approx_factor_vec = np.array([0.02, 0.07])
boxes = []
for approx_factor in approx_factor_vec:
for c in cnts[1]:
p = cv2.arcLength(c, True)
if p >= (min_box_width + min_box_height):
approx = cv2.approxPolyDP(c, approx_factor * p, True)
len_check = len(approx)
if 4 <= len(approx) <= 8:
(x, y, w, h) = cv2.boundingRect(approx)
aspect = w / float(h)
hl_color = (255, 255, 0)
if aspect > min_aspect and w > min_box_width_rel * img.shape[
1] and w > min_box_width and h > min_box_height:
box = Box(
max(0, x - pad + box_offset),
max(0, y - pad + box_offset),
min(img.shape[1] - 1, x - pad + w - box_offset),
min(img.shape[0] - 1, y - pad + h - box_offset))
box.img_data = img[box.y1:box.y2, box.x1:box.x2]
boxes.append(box)
hl_color = (255, 0, 0)
cv2.rectangle(regs, (x, y), (x + w, y + h), hl_color,
2) # andrey
if debug:
cv2.imshow('image with bounding box',
regs) # andrey
cv2.waitKey(0)
else:
cv2.drawContours(regs, [approx], 0, (0, 255, 0),
2) # andrey
if debug:
cv2.imshow('image with contours', regs) # andrey
cv2.waitKey(0)
#show(regs)
return [src_img, norm_img, regs], boxes
def main(args):
print(f'Source region extraction tool version {__version__}')
a = ArgumentParser()
a.add_argument(
'input',
help=
'figure image file or image folder path or semicolon separated list of files or meta json lines file'
)
a.add_argument(
'--demo',
help='highlight source region on input images and save separately',
default=False,
action='store_true')
a.add_argument('-out', help='source regions output dir', default='out')
a.add_argument('-meta_out',
help='source regions output JSONL file',
default='regions.json')
args = a.parse_args(args)
demo_dir = args.out + '/demo'
print('Building a list of source files...')
if os.path.exists(demo_dir):
shutil.rmtree(demo_dir, ignore_errors=True)
if args.demo:
os.makedirs(demo_dir + '/', exist_ok=True)
if args.out:
if os.path.exists(args.out):
shutil.rmtree(args.out, ignore_errors=True)
try:
os.makedirs(args.out, exist_ok=True)
if args.demo:
os.makedirs(demo_dir + '/', exist_ok=True) # andrey
except:
pass
#if (args.input[-1]!='\\'):
articles = get_articles(args.input)
file_mapping = get_file_mapping(articles)
#else:
# file_mapping = {}
# for (dirpath, dirnames, filenames) in os.walk(args.input):
# for fnam in filenames:
# file_mapping[args.input+fnam] = ArticleImage(id=1,chain_id='0',filename=args.input+fnam,title='',page=1,idx_on_page=1,regions=[])
# break
if len(file_mapping) == 0:
print('No files found in specified sources')
exit(-1)
reg_id = 0
for i, filename in enumerate(file_mapping.keys()):
src_img = cv2.imread(filename)
if src_img is None:
print(f'Error reading file, skipping: {filename}')
continue
cur_id = 1
# extract with default settings
boxes, boxes2, boxes3, boxes3a, boxes4 = [], [], [], [], []
PerformDebug = False
annotations, boxes = get_region_boxes(src_img,
bin_thresh=5,
debug=PerformDebug)
cur_id = annotate_boxes(cur_id, boxes, (255, 0, 0))
# preset 2 to extract bordered regions
annotations2, boxes2 = get_region_boxes(src_img,
erode_iters=0,
bin_thresh=50,
debug=PerformDebug)
cur_id = annotate_boxes(cur_id, boxes2, (0, 255, 0))
# preset 3 with another threshold
annotations3, boxes3 = get_region_boxes(src_img,
erode_iters=0,
bin_thresh=100,
debug=PerformDebug)
cur_id = annotate_boxes(cur_id, boxes3, (0, 0, 255))
# preset 3a with another threshold
annotations3a, boxes3a = get_region_boxes(src_img,
erode_iters=0,
bin_thresh=150,
debug=PerformDebug)
cur_id = annotate_boxes(cur_id, boxes3a, (0, 0, 255))
# preset 4 - low threshold no morph
annotations4, boxes4 = get_region_boxes(src_img,
erode_iters=0,
debug=PerformDebug)
cur_id = annotate_boxes(cur_id, boxes4, (255, 0, 255))
#boxes = filter_boxes(boxes + boxes2 + boxes3 + boxes3a + boxes4)
all_boxes = boxes + boxes2 + boxes3 + boxes3a + boxes4
# Check the number of all boxes
if len(all_boxes) == 1: # add the entire image as a box
box = Box(0, 0, src_img.shape[1] - 1, src_img.shape[0] - 1)
box.img_data = src_img
all_boxes.append(box)
PerformDebug = False
updated_boxes = filter_boxes_updated(all_boxes,
src_img,
debug=PerformDebug)
# boxes = boxes + boxes2 + boxes3
if len(updated_boxes) == 0:
print(
f'Warning: {filename} no source regions detected, assuming single source region'
)
box = Box(0,
0,
src_img.shape[1] - 1,
src_img.shape[0] - 1,
id=cur_id)
box.img_data = src_img
updated_boxes.append(box)
# remove borders from regions
print(f'{filename} number of source regions: {len(updated_boxes)}')
for b in updated_boxes:
src_reg = b.img_data
assert src_reg.shape[:2] == b.img_data.shape[:2]
# crop borders on normalized reg (white/black borders)
PerformDebug = False
x1, x2, y1, y2 = crop_border(preprocess_image(b.img_data,
150,
otsu=True),
src_reg,
debug=PerformDebug)
sr = src_reg[y1:y2, x1:x2]
# sr = src_img[b.y1:b.y2, b.x1:b.x2]
reg_path = os.path.join(
args.out,
'.'.join(os.path.basename(filename).split('.')[:-1]) + '_' +
'R' + str(b.id) + '.png')
article_image = file_mapping[filename]
article_image.regions.append(
Region(id=reg_id,
chain_id=article_image.chain_id,
filename=os.path.abspath(reg_path),
box=(b.x1, b.y1, b.x2, b.y2),
matches=[],
title=os.path.basename(reg_path)))
reg_id += 1
#cv2.imshow('subimage', sr) # andrey
#cv2.waitKey(0)
cv2.imwrite(reg_path, sr)
if args.demo:
ref = src_img.copy()
for b in updated_boxes:
cv2.rectangle(ref, (b.x1, b.y1), (b.x2, b.y2),
color=(b.meta if b.meta is not None else
(255, 128, 100)),
thickness=2)
ResultImagePathToSave = os.path.join(
demo_dir,
'.'.join(os.path.basename(filename).split('.')[:-1]) + '.png')
cv2.imwrite(ResultImagePathToSave, ref)
cv2.imshow('image with bounding box', ref) # andrey
cv2.waitKey(0)
progress.report_progress(i + 1, len(file_mapping),
'Extracting regions')
#show(ref_imgs=annotations, title=f'{filename}')
#show(ref_imgs=annotations2, title=f'{filename} pass 2')
#show(ref_imgs=annotations3, title=f'{filename} pass 3')
#show(ref_imgs=annotations4, title=f'{filename} pass 4')
with open(args.meta_out, mode='w') as meta_file:
for a in articles:
meta_file.write(a.toJSON() + os.linesep)
cv2.rectangle(image, (box[0],box[1]), (box[2], box[3]), (255,0,0), 1)
color = (0,255,0) if text == "Live" else (0, 0, 255)
cv2.putText(image, text, (20, 50), cv2.FONT_HERSHEY_SIMPLEX, 2.0, color, lineType=cv2.LINE_AA)
def crop_boxes(image, box):
img = image[box[1]:box[3], box[0]:box[2]]
return img
while True:
ret1, frame1 = cap1.read()
ret2, frame2 = cap2.read()
if ret1 and ret2:
boxes1 = face_detector.DetectFaces(frame1)
boxes2 = face_detector.DetectFaces(frame2)
if boxes1 and boxes2:
exp_box1 = Box(boxes1[0][0], boxes1[0][1], boxes1[0][2]-boxes1[0][0], boxes1[0][3]-boxes1[0][1]).ExpandBox(1.5)
exp_box2 = Box(boxes2[0][0], boxes2[0][1], boxes2[0][2]-boxes2[0][0], boxes2[0][3]-boxes2[0][1]).ExpandBox(1.5)
sqr_box1 = exp_box1.SquareBox(1)
sqr_box2 = exp_box2.SquareBox(1)
crop1,_,_,_,_ = SmartCrop(frame1, sqr_box1)
crop2,_,_,_,_ = SmartCrop(frame2, sqr_box2)
crop1 = cv2.cvtColor(crop1, cv2.COLOR_BGR2GRAY)
crop2 = cv2.cvtColor(crop2, cv2.COLOR_BGR2GRAY)
crop1 = Resize(crop1, dst_size, dst_size)
crop2 = Resize(crop2, dst_size, dst_size)
resize_coef1 = dst_size / sqr_box1.width
resize_coef2 = dst_size / sqr_box2.width
resized_width = int(max(resize_coef1 * exp_box1.width, resize_coef2 * exp_box2.width))
def __call__(self, data, label, gt):
#-----------------------------------------------------------------------
# Check whether to sample or not
#-----------------------------------------------------------------------
if not self.sample:
return data, label, gt
#-----------------------------------------------------------------------
# Retry sampling a couple of times
#-----------------------------------------------------------------------
source_boxes = anchors2array(
gt.boxes, gt.imgsize) # get abs value(xmin,xmax,ymin,ymax)
box = None
box_arr = None
for _ in range(self.max_trials):
#-------------------------------------------------------------------
# Sample a bounding box
#-------------------------------------------------------------------
# min_scale=0.3, max_scale=1.0,
# min_aspect_ratio=0.5, max_aspect_ratio=2.0,
scale = random.uniform(self.min_scale, self.max_scale)
aspect_ratio = random.uniform(self.min_aspect_ratio,
self.max_aspect_ratio)
# make sure width and height will not be larger than 1
aspect_ratio = max(aspect_ratio, scale**2)
aspect_ratio = min(aspect_ratio, 1 / (scale**2))
width = scale * sqrt(aspect_ratio)
height = scale / sqrt(aspect_ratio)
cx = 0.5 * width + random.uniform(0, 1 - width)
cy = 0.5 * height + random.uniform(0, 1 - height)
center = Point(cx, cy)
size = Size(width, height)
#-------------------------------------------------------------------
# Check if the box satisfies the jaccard overlap constraint
#-------------------------------------------------------------------
box_arr = np.array(prop2abs(center, size, gt.imgsize))
overlap = compute_overlap(box_arr, source_boxes, 0)
if overlap.best and overlap.best.score >= self.min_jaccard_overlap:
box = Box(None, None, center, size)
break
if box is None:
return None
#-----------------------------------------------------------------------
# Crop the box and adjust the ground truth
#-----------------------------------------------------------------------
new_size = Size(box_arr[1] - box_arr[0], box_arr[3] - box_arr[2])
w_off = -box_arr[0]
h_off = -box_arr[2]
data = data.crop(
(box_arr[0], box_arr[2], box_arr[1], box_arr[3])
) # gt와 gt근처의 가상의 anchor를 잡은뒤, iou 0.1, 0.3, 0.5, 0.7, 0.9 이상이면 그 가상의 anchor부분을 crop하고 gt 좌표도 같이 변경
# 즉 일부로 gt와 iou 연관있는 그림부분을 crop함
gt = transform_gt(gt, new_size, h_off, w_off)
return data, label, gt # change gt and image_size
class Simulation(object):
"""
The main simulation entry point
"""
# basic defaults
SCREEN_WIDTH, SCREEN_HEIGHT = 700, 700
GRID_SIZE = 20, 20
FIELD_SIZE = 500, 500
FIELD_LIMITS = 0, 0, 600, 600
field_bgcolor = SIM_COLORS['white']
def __init__(self, params=None):
pygame.init()
if params is not None:
self.SCREEN_HEIGHT, self.SCREEN_WIDTH = int(float(params['display']['height']) * SCALE), \
int(float(params['display']['width']) * SCALE)
self.FIELD_LIMITS = int(float(params['field_top_left_x']) * SCALE), \
int(float(params['field_top_left_y']) * SCALE), \
int(float(params['field_bottom_right_x']) * SCALE), \
int(float(params['field_bottom_right_y']) * SCALE)
self.FIELD_SIZE = self.FIELD_LIMITS[2] - self.FIELD_LIMITS[0], self.FIELD_LIMITS[3] - self.FIELD_LIMITS[1]
self.GRID_SIZE = int(float(params['cell']['width']) * SCALE), int(float(params['cell']['height']) * SCALE)
# zoom and centering
self.offset = 0, 0
self.zoom_factor = 1.0
self._old_screen = self.SCREEN_WIDTH, self.SCREEN_HEIGHT
# setup the screen and the box field of play
self.initialize_screen()
# agents
self.agents = pygame.sprite.Group()
self.agent_image = pygame.image.load('assets/blueagent.bmp').convert_alpha()
self.controller = SocialForceController(self)
# self.controller = RandomController(self)
# time related items
self.clock = pygame.time.Clock()
self.paused = False
self.simulation_timer = Timer(10, self.simulation_update)
# create the grid
self.setup_grid()
# additional options (remove this)
self.options = dict(draw_grid=True)
# setup objects (waypoints, obstacles)
self.waypoints = dict()
self.obstacles = []
self._agent_count = 0
# initialize the time
self.time_passed = 0
def initialize_screen(self):
self.screen = pygame.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
HWSURFACE | DOUBLEBUF | RESIZABLE, 32)
self.field_rect_outer = Rect(self.FIELD_LIMITS[0],
self.FIELD_LIMITS[1],
int(self.FIELD_SIZE[0]*self.zoom_factor),
int(self.FIELD_SIZE[1]*self.zoom_factor))
self.field_box = Box(surface=self.screen,
rect=self.field_rect_outer,
background_color=self.field_bgcolor
)
self.field_rect = self.field_box.get_internal_rect()
def setup_grid(self):
self.grid_nrows = self.FIELD_SIZE[1] / int(self.GRID_SIZE[0]*self.zoom_factor)
self.grid_ncols = self.FIELD_SIZE[0] / int(self.GRID_SIZE[1]*self.zoom_factor)
def get_agent_neighbors(self, agent, dist_range):
neighbors = []
for other in self.agents:
if not agent.id == other.id:
dist = agent.position.get_distance(other.position)
if dist <= dist_range:
neighbors.append(other)
return neighbors
def draw_grid(self):
for y in range(self.grid_nrows + 1):
pygame.draw.line(
self.screen,
SIM_COLORS['light gray'],
(self.field_rect.left, self.field_rect.top + y * int(self.GRID_SIZE[1]*self.zoom_factor) - 1),
(self.field_rect.right - 1, self.field_rect.top + y * int(self.GRID_SIZE[1]*self.zoom_factor) - 1))
for x in range(self.grid_ncols + 1):
pygame.draw.line(
self.screen,
SIM_COLORS['light gray'],
(self.field_rect.left + x * int(self.GRID_SIZE[0]*self.zoom_factor) - 1, self.field_rect.top),
(self.field_rect.left + x * int(self.GRID_SIZE[0]*self.zoom_factor) - 1, self.field_rect.bottom - 1))
def xy2coord(self, pos):
""" Convert a (x, y) pair to a (nrow, ncol) coordinate
"""
x, y = (pos[0] - self.field_rect.left, pos[1] - self.field_rect.top)
return int(y) / self.GRID_SIZE[1], int(x) / self.GRID_SIZE[0]
def coord2xy_mid(self, coord):
""" Convert a (nrow, ncol) coordinate to a (x, y) pair,
where x,y is the middle of the square at the coord
"""
nrow, ncol = coord
return (
self.field_rect.left + ncol * self.GRID_SIZE[0] + self.GRID_SIZE[0] / 2,
self.field_rect.top + nrow * self.GRID_SIZE[1] + self.GRID_SIZE[1] / 2)
def draw_background(self):
pygame.draw.rect(self.screen, SIM_COLORS['light gray'], [0, 0, self.SCREEN_WIDTH, self.SCREEN_HEIGHT])
def draw(self):
self.draw_background()
self.field_box.draw()
if self.options['draw_grid']:
self.draw_grid()
for waypoint in self.waypoints:
self.waypoints[waypoint].draw()
for obstacle in self.obstacles:
obstacle.draw()
for agent in self.agents:
agent.draw()
def demo_populate_scene(self):
# agents
self.agents.add(
Agent( agent_id = 0,
screen = self.screen,
game = self,
agent_image = self.agent_image,
field = self.field_rect,
init_position = ( 3, 1),
init_direction = (1, 1),
max_speed = 1.8,
waypoints = [self.waypoints['stop'], self.waypoints['start']]
)
)
self.agents.add(
Agent( agent_id = 1,
screen = self.screen,
game = self,
agent_image = self.agent_image,
field = self.field_rect,
init_position = ( 3, 5),
init_direction = (1, 1),
max_speed = 1.8,
waypoints = [self.waypoints['start'], self.waypoints['stop']]
)
)
self.agents.add(
Agent( agent_id = 2,
screen = self.screen,
game = self,
agent_image = self.agent_image,
field = self.field_rect,
init_position = ( 2, 2),
init_direction = (1, 1),
max_speed = 1.14,
waypoints = [self.waypoints['start'], self.waypoints['stop']]
)
)
def simulation_update(self):
for agent in self.agents:
agent.update(0.1)
self.controller.drive_single_step(agent, delta_time=0.1)
agent.draw()
self.draw()
def _process_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.paused = not self.paused
elif event.key == pygame.K_g:
if pygame.key.get_mods() & pygame.KMOD_CTRL:
self.options['draw_grid'] = not self.options['draw_grid']
elif event.key == pygame.K_PLUS or event.key == pygame.K_EQUALS:
#self.zoom_factor += 0.1
self.initialize_screen()
self.setup_grid()
elif event.key == pygame.K_MINUS:
#self.zoom_factor -= 0.1
self.initialize_screen()
self.setup_grid()
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
pass
elif event.type == VIDEORESIZE:
self._old_screen = self.SCREEN_WIDTH, self.SCREEN_HEIGHT
self.SCREEN_WIDTH, self.SCREEN_HEIGHT = event.dict['size']
self.offset = self.SCREEN_WIDTH - self._old_screen[0], self.SCREEN_HEIGHT - self._old_screen[1]
#self.FIELD_LIMITS = self.FIELD_LIMITS[0]+self.offset[0], self.FIELD_LIMITS[1]+self.offset[1], \
# self.FIELD_LIMITS[2], self.FIELD_LIMITS[3]
#fx = (self.SCREEN_WIDTH / 2) - (self.FIELD_SIZE[0] / 2)
#fy = (self.SCREEN_HEIGHT / 2) - (self.FIELD_SIZE[1] / 2)
#self.FIELD_LIMITS = fx, fy, self.FIELD_LIMITS[2], self.FIELD_LIMITS[3]
self.initialize_screen()
self.setup_grid()
_total_time = 0
def run(self):
# initialize modules
pygame.init()
while True:
self.time_passed = self.clock.tick()
# self._total_time += self.time_passed
# if self._total_time < 1000:
# continue
# handle any events
self._process_events()
if not self.paused:
self.simulation_timer.update(self.time_passed)
# update the game surface
pygame.display.flip()
def add_agents(self, agent_dict):
for agent in agent_dict:
dx, dy = float(agent['dx']), float(agent['dy'])
x, y = float(agent['x']), float(agent['y'])
num = int(agent['n'])
a_type = int(agent['type'])
# spawn an agent in a random direction and position(within dx, dy)
direction = (randint(-1, 1), randint(-1, 1))
position = random_position(x, y, dx, dy)
waypoints = [awp['id'] for awp in agent['addwaypoint']]
rd = 0.3
for _ in xrange(num):
self.agents.add(Agent(
agent_id = self._agent_count,
atype = a_type,
screen = self.screen,
game = self,
agent_image = self.agent_image,
field = self.field_rect,
init_position = position,
init_direction = direction,
max_speed = normalvariate(1.34, 0.26),
radius = rd,
waypoints = [self.waypoints[wp] for wp in waypoints]
))
self._agent_count += 1
# we are done here
# TODO - move the velocity stuff to a neat function
# TODO - find a suitable fatness distribution
def add_waypoints(self, waypoint_dict):
for waypoint in waypoint_dict:
w_id = waypoint['id']
radius = float(waypoint['radius'])
wtype = waypoint['type']
x, y = float(waypoint['x']), float(waypoint['y'])
self.waypoints.update({w_id : Waypoint(screen=self.screen, wid=w_id, wtype=wtype, position=(x, y), radius=radius)})
def add_obstacles(self, obstacle_dict):
for obstacle in obstacle_dict:
o_id = obstacle['id']
p1 = float(obstacle['p1'])
p2 = float(obstacle['p2'])
p3 = float(obstacle['p3'])
p4 = float(obstacle['p4'])
o_type = obstacle['type'].title()
self.obstacles.append(Obstacle(screen=self.screen, oid=o_id, otype=o_type, params=(p1, p2, p3, p4)))
def quit(self):
sys.exit()
