def capture_threadfunc(self):
'''image capture thread, via monitoring the
link for changed linked filenames'''
prev_image = None
self.scan_queue = multiproc.Queue()
while not self.unload_event.wait(0.05):
try:
filename = os.path.realpath(self.camera_settings.imagefile)
if not self.camera_settings.ignoretimestamps:
filetime = cuav_util.parse_frame_time(filename)
else:
filetime = float(time.time())
except Exception:
filename = None
pass
#ensure all items are valid and the queue isn't overfilled > 100
if filename != None and prev_image != filename and filetime != None and self.scan_queue.qsize() < 100:
self.scan_queue.put((filetime, filename))
self.imagefilenamemapping[str(filetime)] = filename
self.capture_count += 1
prev_image = filename
if self.is_armed:
stopfile = self.camera_settings.imagefile + ".stop"
if os.path.exists(stopfile):
print("Removing stopfile")
os.unlink(self.camera_settings.imagefile + ".stop")
def capture_threadfunc(self):
'''image capture thread, via monitoring the
link for changed linked filenames'''
prev_image = None
self.scan_queue = multiproc.Queue()
while not self.unload_event.wait(0.05):
try:
filename = os.path.realpath(self.camera_settings.imagefile)
if not self.camera_settings.ignoretimestamps:
filetime = cuav_util.parse_frame_time(filename)
else:
filetime = float(time.time())
except Exception:
filename = None
pass
#ensure all items are valid and the queue isn't overfilled > 100
if filename != None and prev_image != filename and filetime != None and self.scan_queue.qsize(
) < 100:
self.scan_queue.put((filetime, filename))
self.imagefilenamemapping[str(filetime)] = filename
self.capture_count += 1
prev_image = filename
if self.is_armed:
stopfile = self.camera_settings.imagefile + ".stop"
if os.path.exists(stopfile):
print("Removing stopfile")
os.unlink(self.camera_settings.imagefile + ".stop")
def test_camera_thumbs(mpstate, image_file):
'''Send some thumbnails to the view via the camera_air module'''
loadedModuleAir = camera_air.init(mpstate)
parms = "/data/ChameleonArecort/params.json"
loadedModuleAir.cmd_camera(["set", "camparms", parms])
loadedModuleAir.cmd_camera(["set", "imagefile", image_file])
loadedModuleAir.cmd_camera(["set", "minscore", "0"])
loadedModuleAir.cmd_camera(["set", "gcs_address", "127.0.0.1:14000:15000:45, 127.0.0.1:14500:15500:60000"])
loadedModuleGround = camera_ground.init(mpstate)
loadedModuleGround.cmd_camera(["set", "camparms", parms])
loadedModuleGround.cmd_camera(["set", "air_address", "127.0.0.1:15000:14000:45, 127.0.0.1:15500:14500:60000"])
loadedModuleGround.cmd_camera(["view"])
#start the image stream and modules
capture_thread = sim_camera()
time.sleep(0.05)
loadedModuleAir.cmd_camera(["start"])
time.sleep(2.0)
#and request a fullsize image
filename = os.path.join(os.getcwd(), 'tests', 'testdata', 'raw2016111223465160Z.png')
frame_time = cuav_util.parse_frame_time(filename)
loadedModuleGround.mosaic.image_requests[frame_time] = 'fetchImageFull'
time.sleep(2.0)
loadedModuleAir.unload()
loadedModuleGround.unload()
capture_thread.join(1.0)
#and do the asserts
assert loadedModuleAir.region_count > 0
assert loadedModuleGround.region_count > 0
assert loadedModuleGround.thumb_count > 0
assert loadedModuleGround.image_count > 0
def parse_gamma_time(fname, gamma):
'''get GMT capture_time from filename and gamma hash'''
(root, ext) = os.path.splitext(os.path.basename(fname))
if root.lower().startswith("raw"):
root = root[3:]
if root in gamma:
return gamma[root]
return cuav_util.parse_frame_time(fname)
def parse_gamma_time(fname, gamma):
"""get GMT capture_time from filename and gamma hash"""
(root, ext) = os.path.splitext(os.path.basename(fname))
if root.lower().startswith("raw"):
root = root[3:]
if root in gamma:
return gamma[root]
return cuav_util.parse_frame_time(fname)
def scan_image_directory(dirname):
'''scan a image directory, extracting frame_time and filename
as a list of tuples'''
ret = []
pattern = '*.pgm'
for f in glob.iglob(os.path.join(dirname, pattern)):
ret.append(ImageFile(cuav_util.parse_frame_time(f), f))
ret.sort(key=lambda f: f.frame_time)
return ret
def test_do_playback():
#Check if we're running under Windows:
if sys.platform.startswith('win'):
print("This script is not compatible with Windows")
return
logfile = os.path.join('.', 'tests', 'testdata', 'flight.tlog')
outfile = os.path.join('.', 'cur_camera.png')
images = []
image_a = os.path.join('.', 'tests', 'testdata', 'raw2016111223465120Z.png')
images.append(playback.ImageFile(cuav_util.parse_frame_time(image_a), image_a))
image_b = os.path.join('.', 'tests', 'testdata', 'raw2016111223465160Z.png')
images.append(playback.ImageFile(cuav_util.parse_frame_time(image_b), image_b))
image_c = os.path.join('.', 'tests', 'testdata', 'raw2016111223465213Z.png')
images.append(playback.ImageFile(cuav_util.parse_frame_time(image_c), image_c))
playback.playback(os.path.join('.', 'tests', 'testdata', 'flight.tlog'), images, "127.0.0.1:14550", 57600, None, 40, 'cur_camera.png')
assert os.path.isfile(outfile)
os.remove(outfile)
def scan_image_directory(dirname):
'''scan a image directory, extracting frame_time and filename
as a list of tuples'''
ret = []
pattern = '*.pgm'
for f in glob.iglob(os.path.join(dirname, pattern)):
ret.append(ImageFile(cuav_util.parse_frame_time(f), f))
ret.sort(key=lambda f: f.frame_time)
return ret
def scan_image_directory(dirname):
'''scan a image directory, extracting frame_time and filename
as a list of tuples'''
ret = []
types = ('*.png', '*.jpeg', '*.jpg')
for tp in types:
for f in glob.iglob(os.path.join(dirname, tp)):
ret.append(ImageFile(cuav_util.parse_frame_time(f), f))
ret.sort(key=lambda f: f.frame_time)
return ret
def scan_image_directory(dirname, mavpos):
'''scan a image directory, extracting frame_time and filename
as a list of tuples'''
ret = []
types = ('*.png', '*.jpeg', '*.jpg')
for tp in types:
for f in glob.iglob(os.path.join(dirname, tp)):
bname = os.path.basename(f)
if bname in mavpos:
ret.append(ImageFile(cuav_util.parse_frame_time(f), f, mavpos[bname]))
ret.sort(key=lambda f: f.frame_time)
return ret
def capture(h, timeout, img):
global continuous_mode, trigger_time, frame_rate, frame_counter, fake, last_frame_time
tnow = time.time()
due = trigger_time + (1.0 / frame_rate)
if tnow < due:
time.sleep(due - tnow)
timeout -= int(due * 1000)
# wait for a new image to appear
filename = os.path.realpath(fake)
frame_time = cuav_util.parse_frame_time(filename)
while frame_time == last_frame_time and timeout > 0:
timeout -= 10
time.sleep(0.01)
filename = os.path.realpath(fake)
frame_time = cuav_util.parse_frame_time(filename)
if last_frame_time == frame_time:
raise chameleon.error("timeout waiting for fake image")
last_frame_time = frame_time
try:
fake_img = load_image(filename)
except Exception, msg:
raise chameleon.error("missing %s" % fake)
def capture(h, timeout, img):
global continuous_mode, trigger_time, frame_rate, frame_counter, fake, last_frame_time
tnow = time.time()
due = trigger_time + (1.0/frame_rate)
if tnow < due:
time.sleep(due - tnow)
timeout -= int(due*1000)
# wait for a new image to appear
filename = os.path.realpath(fake)
frame_time = cuav_util.parse_frame_time(filename)
while frame_time == last_frame_time and timeout > 0:
timeout -= 10
time.sleep(0.01)
filename = os.path.realpath(fake)
frame_time = cuav_util.parse_frame_time(filename)
if last_frame_time == frame_time:
raise chameleon.error("timeout waiting for fake image")
last_frame_time = frame_time
try:
fake_img = load_image(filename)
except Exception, msg:
raise chameleon.error('missing %s' % fake)
def process(args):
'''process a set of files'''
count = 0
files = []
types = ('*.png', '*.jpeg', '*.jpg')
if os.path.isdir(args.files):
for tp in types:
files.extend(glob.glob(os.path.join(args.files, tp)))
else:
files.append(args.files)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
mpos = mav_position.MavInterpolator(gps_lag=args.gps_lag)
mpos.set_logfile(os.path.join(os.getcwd(), args.mavlog))
frame_time = 0
poshash = {}
for f in files:
#timestamp is in filename
timestamp = (os.path.splitext(os.path.basename(f))[0])
m = re.search("\d", timestamp)
if m :
timestamp = timestamp[m.start():]
frame_time = cuav_util.parse_frame_time(f)
try:
if args.roll_stabilised:
roll = 0
else:
roll = None
pos = mpos.position(frame_time, roll=roll)
except mav_position.MavInterpolatorException as e:
print(e)
pos = None
if pos:
poshash[os.path.basename(f)] = pos
dirname = os.path.dirname(f)
mavpos = os.path.join(dirname, "mavpos.dat")
open(mavpos,"w").write(pickle.dumps(poshash))
print("Wrote %s with %u entries" % (mavpos, len(poshash)))
def process(args):
'''process a set of files'''
count = 0
files = []
types = ('*.png', '*.jpeg', '*.jpg')
if os.path.isdir(args.files):
for tp in types:
files.extend(glob.glob(os.path.join(args.files, tp)))
else:
files.append(args.files)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
mpos = mav_position.MavInterpolator(gps_lag=args.gps_lag)
mpos.set_logfile(os.path.join(os.getcwd(), args.mavlog))
frame_time = 0
poshash = {}
for f in files:
#timestamp is in filename
timestamp = (os.path.splitext(os.path.basename(f))[0])
m = re.search("\d", timestamp)
if m:
timestamp = timestamp[m.start():]
frame_time = cuav_util.parse_frame_time(f)
try:
if args.roll_stabilised:
roll = 0
else:
roll = None
pos = mpos.position(frame_time, roll=roll)
except mav_position.MavInterpolatorException as e:
print(e)
pos = None
if pos:
poshash[os.path.basename(f)] = pos
dirname = os.path.dirname(f)
mavpos = os.path.join(dirname, "mavpos.dat")
open(mavpos, "w").write(pickle.dumps(poshash))
print("Wrote %s with %u entries" % (mavpos, len(poshash)))
def test_camera_image_request(mpstate, image_file):
'''image request via the block_xmit'''
loadedModule = camera_air.init(mpstate)
parms = "/data/ChameleonArecort/params.json"
loadedModule.cmd_camera(["set", "camparms", parms])
loadedModule.cmd_camera(["set", "imagefile", image_file])
loadedModule.cmd_camera(["set", "minscore", "0"])
loadedModule.cmd_camera(["set", "gcs_address", "127.0.0.1:14550:14560:2000000"])
filename = os.path.join(os.getcwd(), 'tests', 'testdata', 'raw2016111223465160Z.png')
pkt = cuav_command.ImageRequest(cuav_util.parse_frame_time(filename), True)
buf = cPickle.dumps(pkt, cPickle.HIGHEST_PROTOCOL)
capture_thread = sim_camera()
time.sleep(0.05)
loadedModule.cmd_camera(["start"])
time.sleep(0.8)
loadedModule.cmd_camera(["status"])
#don't load the block xmit until afterwards
b1 = block_xmit.BlockSender(dest_ip='127.0.0.1', port = 14550, dest_port = 14560)
b1.tick()
b1.send(buf)
#b1.tick()
time.sleep(0.1)
blkret = []
while True:
try:
b1.tick()
blk = cPickle.loads(str(b1.recv(0.01, True)))
#only want paricular packets - discard all the heartbeats, etc
if isinstance(blk, cuav_command.ImagePacket):
blkret.append(blk)
break
time.sleep(0.05)
except cPickle.UnpicklingError:
continue
loadedModule.cmd_camera(["stop"])
loadedModule.unload()
capture_thread.join(1.0)
assert len(blkret) == 1
#not sure if the last or 2nd last packed will contain the image - depends on the exact thread timing
assert isinstance(blkret[0], cuav_command.ImagePacket)
assert blkret[0].jpeg is not None
def test_camera_thumbs(mpstate, image_file):
'''Send some thumbnails to the view via the camera_air module'''
loadedModuleAir = camera_air.init(mpstate)
parms = "/data/ChameleonArecort/params.json"
loadedModuleAir.cmd_camera(["set", "camparms", parms])
loadedModuleAir.cmd_camera(["set", "imagefile", image_file])
loadedModuleAir.cmd_camera(["set", "minscore", "0"])
loadedModuleAir.cmd_camera([
"set", "gcs_address",
"127.0.0.1:14000:15000:45, 127.0.0.1:14500:15500:60000"
])
loadedModuleGround = camera_ground.init(mpstate)
loadedModuleGround.cmd_camera(["set", "camparms", parms])
loadedModuleGround.cmd_camera([
"set", "air_address",
"127.0.0.1:15000:14000:45, 127.0.0.1:15500:14500:60000"
])
loadedModuleGround.cmd_camera(["view"])
#start the image stream and modules
capture_thread = sim_camera()
time.sleep(0.05)
loadedModuleAir.cmd_camera(["start"])
time.sleep(2.0)
#and request a fullsize image
filename = os.path.join(os.getcwd(), 'tests', 'testdata',
'raw2016111223465160Z.png')
frame_time = cuav_util.parse_frame_time(filename)
loadedModuleGround.mosaic.image_requests[frame_time] = 'fetchImageFull'
time.sleep(2.0)
loadedModuleAir.unload()
loadedModuleGround.unload()
capture_thread.join(1.0)
#and do the asserts
assert loadedModuleAir.region_count > 0
assert loadedModuleGround.region_count > 0
assert loadedModuleGround.thumb_count > 0
assert loadedModuleGround.image_count > 0
def process(args):
"""process a set of files"""
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(file_list(a, ["jpg", "pgm", "png"]))
else:
if a.find("*") != -1:
files.extend(glob.glob(a))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=opts.service, elevation=True, title="Map")
icon = slipmap.icon("redplane.png")
slipmap.add_object(
mp_slipmap.SlipIcon("plane", (0, 0), icon, layer=3, rotation=0, follow=True, trail=mp_slipmap.SlipTrail())
)
for flag in opts.flag:
a = flag.split(",")
lat = a[0]
lon = a[1]
icon = "flag.png"
if len(a) > 2:
icon = a[2] + ".png"
icon = slipmap.icon(icon)
slipmap.add_object(
mp_slipmap.SlipIcon(
"icon - %s" % str(flag), (float(lat), float(lon)), icon, layer=3, rotation=0, follow=False
)
)
if opts.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(opts.mission)
plist = wp.polygon_list()
if len(plist) > 0:
for i in range(len(plist)):
slipmap.add_object(
mp_slipmap.SlipPolygon(
"Mission-%s-%u" % (opts.mission, i),
plist[i],
layer="Mission",
linewidth=2,
colour=(255, 255, 255),
)
)
if opts.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.gammalog is not None:
gamma = parse_gamma_log(opts.gammalog)
else:
gamma = None
if opts.kmzlog:
kmzpos = mav_position.KmlPosition(opts.kmzlog)
else:
kmzpos = None
if opts.triggerlog:
triggerpos = mav_position.TriggerPosition(opts.triggerlog)
else:
triggerpos = None
# create a simple lens model using the focal length
C_params = cam_params.CameraParams(lens=opts.lens, sensorwidth=opts.sensorwidth)
if opts.camera_params:
C_params.load(opts.camera_params)
if opts.target:
target = opts.target.split(",")
else:
target = [0, 0, 0]
camera_settings = MPSettings(
[
MPSetting("roll_stabilised", bool, opts.roll_stabilised, "Roll Stabilised"),
MPSetting("altitude", int, opts.altitude, "Altitude", range=(0, 10000), increment=1),
MPSetting("minalt", int, 30, "MinAltitude", range=(0, 10000), increment=1),
MPSetting("mpp100", float, 0.0977, "MPPat100m", range=(0, 10000), increment=0.001),
MPSetting("rotate180", bool, opts.rotate_180, "rotate180"),
MPSetting("filter_type", str, "compactness", "Filter Type", choice=["simple", "compactness"]),
MPSetting("target_lattitude", float, float(target[0]), "target latitude", increment=1.0e-7),
MPSetting("target_longitude", float, float(target[1]), "target longitude", increment=1.0e-7),
MPSetting("target_radius", float, float(target[2]), "target radius", increment=1),
MPSetting("quality", int, 75, "Compression Quality", range=(1, 100), increment=1),
MPSetting("thumbsize", int, opts.thumbsize, "Thumbnail Size", range=(10, 200), increment=1),
MPSetting("minscore", int, opts.minscore, "Min Score", range=(0, 1000), increment=1, tab="Scoring"),
MPSetting(
"brightness", float, 1.0, "Display Brightness", range=(0.1, 10), increment=0.1, digits=2, tab="Display"
),
],
title="Camera Settings",
)
image_settings = MPSettings(
[
MPSetting("MinRegionArea", float, 0.05, range=(0, 100), increment=0.05, digits=2, tab="Image Processing"),
MPSetting("MaxRegionArea", float, 4.0, range=(0, 100), increment=0.1, digits=1),
MPSetting("MinRegionSize", float, 0.02, range=(0, 100), increment=0.05, digits=2),
MPSetting("MaxRegionSize", float, 3.0, range=(0, 100), increment=0.1, digits=1),
MPSetting("MaxRarityPct", float, 0.02, range=(0, 100), increment=0.01, digits=2),
MPSetting("RegionMergeSize", float, 1.0, range=(0, 100), increment=0.1, digits=1),
MPSetting("BlueEmphasis", bool, opts.blue_emphasis),
MPSetting("SaveIntermediate", bool, opts.debug),
],
title="Image Settings",
)
mosaic = cuav_mosaic.Mosaic(
slipmap,
C=C_params,
camera_settings=camera_settings,
image_settings=image_settings,
start_menu=True,
classify=opts.categories,
thumb_size=opts.mosaic_thumbsize,
)
joelog = cuav_joe.JoeLog(None)
if opts.view:
viewer = mp_image.MPImage(title="Image", can_zoom=True, can_drag=True)
for f in files:
if not mosaic.started():
print("Waiting for startup")
while not mosaic.started():
mosaic.check_events()
time.sleep(0.01)
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
if gamma is not None:
frame_time = parse_gamma_time(f, gamma)
else:
frame_time = cuav_util.parse_frame_time(f)
frame_time += opts.time_offset
if camera_settings.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += opts.time_offset
# update the plane icon on the map
if pos is not None:
slipmap.set_position("plane", (pos.lat, pos.lon), rotation=pos.yaw)
if camera_settings.altitude > 0:
pos.altitude = camera_settings.altitude
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f, rotate180=camera_settings.rotate180)
if im_orig is None:
continue
(w, h) = cuav_util.image_shape(im_orig)
if not opts.camera_params:
C_params.set_resolution(w, h)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
t0 = time.time()
img_scan = im_full
scan_parms = {}
for name in image_settings.list():
scan_parms[name] = image_settings.get(name)
scan_parms["SaveIntermediate"] = float(scan_parms["SaveIntermediate"])
scan_parms["BlueEmphasis"] = float(scan_parms["BlueEmphasis"])
if pos is not None:
(sw, sh) = cuav_util.image_shape(img_scan)
altitude = pos.altitude
if altitude < camera_settings.minalt:
altitude = camera_settings.minalt
scan_parms["MetersPerPixel"] = camera_settings.mpp100 * altitude / 100.0
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions, cuav_util.image_shape(img_scan), cuav_util.image_shape(im_full))
count += 1
t1 = time.time()
frame_time = pos.time
if pos:
for r in regions:
r.latlon = cuav_util.gps_position_from_image_region(r, pos, w, h, altitude=altitude)
if camera_settings.target_radius > 0 and pos is not None:
regions = cuav_region.filter_radius(
regions,
(camera_settings.target_lattitude, camera_settings.target_longitude),
camera_settings.target_radius,
)
regions = cuav_region.filter_regions(
im_full,
regions,
frame_time=frame_time,
min_score=camera_settings.minscore,
filter_type=camera_settings.filter_type,
)
scan_count += 1
if pos and len(regions) > 0:
altitude = camera_settings.altitude
if altitude <= 0:
altitude = None
joelog.add_regions(frame_time, regions, pos, f, width=w, height=h, altitude=altitude)
mosaic.add_image(pos.time, f, pos)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.view:
img_view = img_scan
(wview, hview) = cuav_util.image_shape(img_view)
mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(mat, (255, 0, 0))
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
viewer.set_title("Image: " + os.path.basename(f))
if opts.saveview:
cv.CvtColor(mat, mat, cv.CV_RGB2BGR)
cv.SaveImage("view-" + os.path.basename(f), mat)
total_time += t1 - t0
if t1 != t0:
print(
"%s scan %.1f fps %u regions [%u/%u]"
% (os.path.basename(f), count / total_time, region_count, scan_count, num_files)
)
# raw_input("hit ENTER when ready")
print("All images processed")
while True:
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
time.sleep(0.2)
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(glob.glob(os.path.join(a, '*.pgm')))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
joes = []
if opts.mavlog:
mpos = mav_position.MavInterpolator(gps_lag=opts.gps_lag)
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.boundary:
boundary = cuav_util.polygon_load(opts.boundary)
else:
boundary = None
if opts.mosaic:
slipmap = mp_slipmap.MPSlipMap(service='GoogleSat', elevation=True, title='Map')
icon = slipmap.icon('planetracker.png')
slipmap.add_object(mp_slipmap.SlipIcon('plane', (0,0), icon, layer=3, rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
C_params = cam_params.CameraParams(lens=opts.lens)
path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', '..',
'cuav', 'data', 'chameleon1_arecont0.json')
C_params.load(path)
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params)
if boundary is not None:
mosaic.set_boundary(boundary)
if opts.joe:
joes = cuav_util.polygon_load(opts.joe)
if boundary:
for i in range(len(joes)):
joe = joes[i]
if cuav_util.polygon_outside(joe, boundary):
print("Error: joe outside boundary", joe)
return
icon = slipmap.icon('flag.png')
slipmap.add_object(mp_slipmap.SlipIcon('joe%u' % i, (joe[0],joe[1]), icon, layer=4))
joelog = cuav_joe.JoeLog('joe.log')
if opts.view:
viewer = mp_image.MPImage(title='Image')
frame_time = 0
for f in files:
if mpos:
frame_time = cuav_util.parse_frame_time(f)
try:
if opts.roll_stabilised:
roll = 0
else:
roll = None
pos = mpos.position(frame_time, opts.max_deltat,roll=roll)
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
except mav_position.MavInterpolatorException as e:
print e
pos = None
else:
pos = None
# check for any events from the map
if opts.mosaic:
slipmap.check_events()
mosaic.check_events()
if f.endswith('.pgm'):
pgm = cuav_util.PGM(f)
im = pgm.array
if pgm.eightbit:
im_8bit = im
else:
im_8bit = numpy.zeros((960,1280,1),dtype='uint8')
if opts.gamma != 0:
scanner.gamma_correct(im, im_8bit, opts.gamma)
else:
scanner.reduce_depth(im, im_8bit)
im_full = numpy.zeros((960,1280,3),dtype='uint8')
scanner.debayer(im_8bit, im_full)
im_640 = numpy.zeros((480,640,3),dtype='uint8')
scanner.downsample(im_full, im_640)
else:
im_orig = cv.LoadImage(f)
(w,h) = cuav_util.image_shape(im_orig)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
img_scan = im_640
t0=time.time()
for i in range(opts.repeat):
if opts.fullres:
regions = scanner.scan(im_full)
regions = cuav_region.RegionsConvert(regions, 1280, 960)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions)
count += 1
t1=time.time()
if opts.filter:
regions = cuav_region.filter_regions(im_full, regions, frame_time=frame_time, min_score=opts.minscore,
filter_type=opts.filter_type)
scan_count += 1
# optionally link all the images with joe into a separate directory
# for faster re-running of the test with just joe images
if pos and opts.linkjoe and len(regions) > 0:
cuav_util.mkdir_p(opts.linkjoe)
if not cuav_util.polygon_outside((pos.lat, pos.lon), boundary):
joepath = os.path.join(opts.linkjoe, os.path.basename(f))
if os.path.exists(joepath):
os.unlink(joepath)
os.symlink(f, joepath)
if pos and len(regions) > 0:
joelog.add_regions(frame_time, regions, pos, f, width=1280, height=960, altitude=opts.altitude)
if boundary:
regions = cuav_region.filter_boundary(regions, boundary, pos)
region_count += len(regions)
if opts.mosaic and len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.compress:
jpeg = scanner.jpeg_compress(im_full, opts.quality)
jpeg_filename = f[:-4] + '.jpg'
if os.path.exists(jpeg_filename):
print('jpeg %s already exists' % jpeg_filename)
continue
chameleon.save_file(jpeg_filename, jpeg)
if opts.view:
if opts.fullres:
img_view = im_full
else:
img_view = img_scan
mat = cv.fromarray(img_view)
for r in regions:
(x1,y1,x2,y2) = r.tuple()
(w,h) = cuav_util.image_shape(img_view)
x1 = x1*w//1280
x2 = x2*w//1280
y1 = y1*h//960
y2 = y2*h//960
cv.Rectangle(mat, (max(x1-2,0),max(y1-2,0)), (x2+2,y2+2), (255,0,0), 2)
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
total_time += (t1-t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' % (
f, count/total_time, region_count, scan_count, num_files))
def popup_fetch_image(self, region, returnkey):
'''handle popup menu fetchImage'''
if region is None:
return
frame_time = cuav_util.parse_frame_time(region.filename)
self.image_requests[frame_time] = True
def add_regions(self, regions, thumbs, filename, pos=None):
'''add some regions'''
for i in range(len(regions)):
r = regions[i]
latlon = r.latlon
if latlon is None:
latlon = (None,None)
(lat, lon) = latlon
if self.boundary:
if (lat, lon) == (None,None):
# its pointing into the sky
continue
# if cuav_util.polygon_outside((lat,lon), self.boundary):
# # this region is outside the search boundary
# continue
# the thumbnail we have been given will be bigger than the size we want to
# display on the mosaic. Extract the middle of it for display
full_thumb = thumbs[i]
thumb = self.make_thumb(full_thumb, r, self.thumb_size)
ridx = len(self.regions)
self.regions.append(MosaicRegion(ridx, r, filename, pos, thumbs[i], thumb, latlon=(lat,lon)))
self.regions_sorted.append(self.regions[-1])
max_page = (len(self.regions_sorted)-1) // self.display_regions
self.image_mosaic.set_title("Mosaic (Page %u of %u)" % (self.page+1, max(max_page+1, 1)))
frame_time = cuav_util.parse_frame_time(filename)
if not frame_time in self.ridx_by_frame_time:
self.ridx_by_frame_time[frame_time] = [ridx]
else:
self.ridx_by_frame_time[frame_time].append(ridx)
self.display_mosaic_region(len(self.regions_sorted)-1)
if (lat,lon) != (None,None):
mapthumb = thumb
if self.map_thumb_size != self.thumb_size:
mapthumb = self.make_thumb(full_thumb,
r,
self.map_thumb_size)
slobj = mp_slipmap.SlipThumbnail("region %u" % ridx, (lat,lon),
img=cv2.cvtColor(mapthumb, cv2.COLOR_RGB2BGR),
layer=2,
border_width=1,
border_colour=(255,0,0),
popup_menu=self.popup_menu)
for m in self.allmaps:
m.add_object(slobj)
self.image_mosaic.set_image(self.mosaic)
if self.autorefresh:
self.re_sort(printsort=False)
self.redisplay_mosaic()
if not self.have_selected_region:
self.show_region(self.regions_sorted[0].ridx)
if self.topfifty:
self.re_sort(printsort=False)
self.redisplay_mosaic()
self.topfiftyonly()
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
if os.path.isdir(args.directory):
files.extend(file_list(args.directory, ['jpg', 'pgm', 'png']))
else:
if args.directory.find('*') != -1:
files.extend(glob.glob(args.directory))
else:
files.append(args.directory)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=args.service,
elevation=True,
title='Map')
icon = slipmap.icon('redplane.png')
slipmap.add_object(
mp_slipmap.SlipIcon('plane', (0, 0),
icon,
layer=3,
rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
for flag in args.flag:
a = flag.split(',')
lat = a[0]
lon = a[1]
icon = 'flag.png'
if len(a) > 2:
icon = a[2] + '.png'
icon = slipmap.icon(icon)
slipmap.add_object(
mp_slipmap.SlipIcon('icon - %s' % str(flag),
(float(lat), float(lon)),
icon,
layer=3,
rotation=0,
follow=False))
if args.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(args.mission.name)
plist = wp.polygon_list()
if len(plist) > 0:
for i in range(len(plist)):
slipmap.add_object(
mp_slipmap.SlipPolygon('Mission-%s-%u' %
(args.mission.name, i),
plist[i],
layer='Mission',
linewidth=2,
colour=(255, 255, 255)))
if args.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(args.mavlog.name)
else:
mpos = None
if args.gammalog is not None:
gamma = parse_gamma_log(args.gammalog)
else:
gamma = None
if args.kmzlog:
kmzpos = mav_position.KmlPosition(args.kmzlog.name)
else:
kmzpos = None
if args.triggerlog:
triggerpos = mav_position.TriggerPosition(args.triggerlog.name)
else:
triggerpos = None
# create a simple lens model using the focal length
if args.camera_params:
C_params = cam_params.CameraParams.fromfile(args.camera_params.name)
else:
C_params = cam_params.CameraParams(lens=args.lens,
sensorwidth=args.sensorwidth,
xresolution=args.xresolution,
yresolution=args.yresolution)
if args.target:
target = args.target.split(',')
else:
target = [0, 0, 0]
camera_settings = MPSettings([
MPSetting('roll_stabilised', bool, args.roll_stabilised,
'Roll Stabilised'),
MPSetting('altitude',
int,
args.altitude,
'Altitude',
range=(0, 10000),
increment=1),
MPSetting(
'minalt', int, 30, 'MinAltitude', range=(0, 10000), increment=1),
MPSetting('mpp100',
float,
0.0977,
'MPPat100m',
range=(0, 10000),
increment=0.001),
MPSetting('rotate180', bool, args.rotate_180, 'rotate180'),
MPSetting('filter_type',
str,
'compactness',
'Filter Type',
choice=['simple', 'compactness']),
MPSetting('target_lattitude',
float,
float(target[0]),
'target latitude',
increment=1.0e-7),
MPSetting('target_longitude',
float,
float(target[1]),
'target longitude',
increment=1.0e-7),
MPSetting('target_radius',
float,
float(target[2]),
'target radius',
increment=1),
MPSetting('quality',
int,
75,
'Compression Quality',
range=(1, 100),
increment=1),
MPSetting('thumbsize',
int,
args.thumbsize,
'Thumbnail Size',
range=(10, 200),
increment=1),
MPSetting('minscore',
int,
args.minscore,
'Min Score',
range=(0, 1000),
increment=1,
tab='Scoring'),
MPSetting('brightness',
float,
1.0,
'Display Brightness',
range=(0.1, 10),
increment=0.1,
digits=2,
tab='Display'),
],
title='Camera Settings')
image_settings = MPSettings([
MPSetting('MinRegionArea',
float,
0.05,
range=(0, 100),
increment=0.05,
digits=2,
tab='Image Processing'),
MPSetting('MaxRegionArea',
float,
4.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('MinRegionSize',
float,
0.02,
range=(0, 100),
increment=0.05,
digits=2),
MPSetting('MaxRegionSize',
float,
3.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('MaxRarityPct',
float,
0.02,
range=(0, 100),
increment=0.01,
digits=2),
MPSetting('RegionMergeSize',
float,
1.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('BlueEmphasis', bool, args.blue_emphasis),
MPSetting('SaveIntermediate', bool, args.debug)
],
title='Image Settings')
mosaic = cuav_mosaic.Mosaic(slipmap,
C=C_params,
camera_settings=camera_settings,
image_settings=image_settings,
start_menu=True,
classify=args.categories,
thumb_size=args.mosaic_thumbsize)
joelog = cuav_joe.JoeLog(None)
if args.view:
viewer = mp_image.MPImage(title='Image', can_zoom=True, can_drag=True)
start_time = time.time()
for f in files:
if not mosaic.started():
print("Waiting for startup")
if args.start:
mosaic.has_started = True
while not mosaic.started():
mosaic.check_events()
time.sleep(0.01)
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
if gamma is not None:
frame_time = parse_gamma_time(f, gamma)
else:
frame_time = cuav_util.parse_frame_time(f)
frame_time += args.time_offset
if camera_settings.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += args.time_offset
# update the plane icon on the map
if pos is not None:
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
if camera_settings.altitude > 0:
pos.altitude = camera_settings.altitude
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f, rotate180=camera_settings.rotate180)
if im_orig is None:
continue
(w, h) = cuav_util.image_shape(im_orig)
if False:
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = im_orig
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
t0 = time.time()
img_scan = im_full
scan_parms = {}
for name in image_settings.list():
scan_parms[name] = image_settings.get(name)
scan_parms['SaveIntermediate'] = float(scan_parms['SaveIntermediate'])
scan_parms['BlueEmphasis'] = float(scan_parms['BlueEmphasis'])
if pos is not None:
(sw, sh) = cuav_util.image_shape(img_scan)
altitude = pos.altitude
if altitude < camera_settings.minalt:
altitude = camera_settings.minalt
scan_parms[
'MetersPerPixel'] = camera_settings.mpp100 * altitude / 100.0
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions,
cuav_util.image_shape(img_scan),
cuav_util.image_shape(im_full))
count += 1
t1 = time.time()
frame_time = pos.time
if pos:
for r in regions:
r.latlon = cuav_util.gps_position_from_image_region(
r, pos, w, h, altitude=altitude, C=C_params)
if camera_settings.target_radius > 0 and pos is not None:
regions = cuav_region.filter_radius(
regions, (camera_settings.target_lattitude,
camera_settings.target_longitude),
camera_settings.target_radius)
regions = cuav_region.filter_regions(
im_full,
regions,
frame_time=frame_time,
min_score=camera_settings.minscore,
filter_type=camera_settings.filter_type)
scan_count += 1
if pos and len(regions) > 0:
altitude = camera_settings.altitude
if altitude <= 0:
altitude = None
joelog.add_regions(frame_time,
regions,
pos,
f,
width=w,
height=h,
altitude=altitude)
mosaic.add_image(pos.time, f, pos)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(
cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if args.view:
img_view = img_scan
(wview, hview) = cuav_util.image_shape(img_view)
mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(mat, (255, 0, 0))
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
viewer.set_title('Image: ' + os.path.basename(f))
if args.saveview:
cv.CvtColor(mat, mat, cv.CV_RGB2BGR)
cv.SaveImage('view-' + os.path.basename(f), mat)
total_time += (t1 - t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' %
(os.path.basename(f), count / total_time, region_count,
scan_count, num_files))
#raw_input("hit ENTER when ready")
print("All images processed (%u seconds)" % (time.time() - start_time))
while True:
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
time.sleep(0.2)
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(file_list(a, ['jpg', 'pgm', 'png']))
else:
if a.find('*') != -1:
files.extend(glob.glob(a))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=opts.service, elevation=True, title='Map')
icon = slipmap.icon('redplane.png')
slipmap.add_object(mp_slipmap.SlipIcon('plane', (0,0), icon, layer=3, rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
if opts.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(opts.mission)
boundary = wp.polygon()
slipmap.add_object(mp_slipmap.SlipPolygon('mission', boundary, layer=1,
linewidth=1, colour=(255,255,255)))
if opts.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.kmzlog:
kmzpos = mav_position.KmlPosition(opts.kmzlog)
else:
kmzpos = None
if opts.triggerlog:
triggerpos = mav_position.TriggerPosition(opts.triggerlog)
else:
triggerpos = None
# create a simple lens model using the focal length
C_params = cam_params.CameraParams(lens=opts.lens, sensorwidth=opts.sensorwidth)
if opts.camera_params:
C_params.load(opts.camera_params)
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params)
joelog = cuav_joe.JoeLog(None)
if opts.view:
viewer = mp_image.MPImage(title='Image', can_zoom=True, can_drag=True)
scan_parms = {
'MinRegionArea' : opts.min_region_area,
'MaxRegionArea' : opts.max_region_area,
'MinRegionSize' : opts.min_region_size,
'MaxRegionSize' : opts.max_region_size,
'MaxRarityPct' : opts.max_rarity_pct,
'RegionMergeSize' : opts.region_merge,
'SaveIntermediate' : float(opts.debug)
}
if opts.filter_type == 'compactness':
calculate_compactness = True
print("Using compactness filter")
else:
calculate_compactness = False
for f in files:
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
frame_time = cuav_util.parse_frame_time(f) + opts.time_offset
if opts.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += opts.time_offset
# update the plane icon on the map
if pos is not None:
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
if opts.altitude is not None:
pos.altitude = opts.altitude
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f)
(w,h) = cuav_util.image_shape(im_orig)
if not opts.camera_params:
C_params.set_resolution(w, h)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
t0=time.time()
if opts.fullres:
img_scan = im_full
else:
img_scan = im_640
if pos is not None:
(sw,sh) = cuav_util.image_shape(img_scan)
mpp = cuav_util.meters_per_pixel(pos, C=C_params)
if mpp is not None:
scan_parms['MetersPerPixel'] = mpp * (w/float(sw))
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions, cuav_util.image_shape(img_scan), cuav_util.image_shape(im_full), calculate_compactness)
count += 1
t1=time.time()
frame_time = pos.time
regions = cuav_region.filter_regions(im_full, regions, frame_time=frame_time,
min_score=opts.minscore, filter_type=opts.filter_type)
scan_count += 1
mosaic.add_image(pos.time, f, pos)
if pos and len(regions) > 0:
joelog.add_regions(frame_time, regions, pos, f, width=w, height=h, altitude=opts.altitude)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.view:
img_view = img_scan
(wview,hview) = cuav_util.image_shape(img_view)
mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(mat, (255,0,0))
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
viewer.set_title('Image: ' + os.path.basename(f))
total_time += (t1-t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' % (
os.path.basename(f), count/total_time, region_count, scan_count, num_files))
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(glob.glob(os.path.join(a, '*.jpg')))
files.extend(glob.glob(os.path.join(a, '*.pgm')))
files.extend(glob.glob(os.path.join(a, '*.png')))
else:
if a.find('*') != -1:
files.extend(glob.glob(a))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service='GoogleSat', elevation=True, title='Map')
icon = slipmap.icon('planetracker.png')
slipmap.add_object(mp_slipmap.SlipIcon('plane', (0,0), icon, layer=3, rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
if opts.grid:
slipmap.add_object(mp_slipmap.SlipGrid('grid', layer=1, linewidth=1, colour=(255,255,0)))
if opts.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(opts.mission)
boundary = wp.polygon()
slipmap.add_object(mp_slipmap.SlipPolygon('mission', boundary, layer=1,
linewidth=1, colour=(255,255,255)))
if opts.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(opts.mavlog)
else:
mpos = None
# create a simple lens model using the focal length
C_params = cam_params.CameraParams(lens=opts.lens)
if opts.camera_params:
C_params.load(opts.camera_params)
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params)
joelog = cuav_joe.JoeLog(None)
if opts.view:
viewer = mp_image.MPImage(title='Image')
for f in files:
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
frame_time = cuav_util.parse_frame_time(f) + opts.time_offset
if opts.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += opts.time_offset
# update the plane icon on the map
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f)
(w,h) = cuav_util.image_shape(im_orig)
if (w,h) != (1280,960):
im_full = cv.CreateImage((1280, 960), 8, 3)
cv.Resize(im_orig, im_full)
cv.ConvertScale(im_full, im_full, scale=0.3)
else:
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
img_scan = im_640
t0=time.time()
regions = scanner.scan(img_scan)
count += 1
regions = cuav_region.RegionsConvert(regions)
t1=time.time()
frame_time = pos.time
regions = cuav_region.filter_regions(im_full, regions, frame_time=frame_time,
min_score=opts.minscore, filter_type=opts.filter_type)
scan_count += 1
mosaic.add_image(pos.time, f, pos)
if pos and len(regions) > 0:
joelog.add_regions(frame_time, regions, pos, f, width=1280, height=960, altitude=opts.altitude)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.view:
img_view = img_scan
mat = cv.fromarray(img_view)
for r in regions:
(x1,y1,x2,y2) = r.tuple()
(w,h) = cuav_util.image_shape(img_view)
x1 = x1*w//1280
x2 = x2*w//1280
y1 = y1*h//960
y2 = y2*h//960
cv.Rectangle(mat, (max(x1-2,0),max(y1-2,0)), (x2+2,y2+2), (255,0,0), 2)
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
total_time += (t1-t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' % (
os.path.basename(f), count/total_time, region_count, scan_count, num_files))
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(file_list(a, ['jpg', 'pgm', 'png']))
else:
if a.find('*') != -1:
files.extend(glob.glob(a))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=opts.service, elevation=True, title='Map')
icon = slipmap.icon('redplane.png')
slipmap.add_object(mp_slipmap.SlipIcon('plane', (0,0), icon, layer=3, rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
for flag in opts.flag:
a = flag.split(',')
lat = a[0]
lon = a[1]
icon = 'flag.png'
if len(a) > 2:
icon = a[2] + '.png'
icon = slipmap.icon(icon)
slipmap.add_object(mp_slipmap.SlipIcon('icon - %s' % str(flag), (float(lat),float(lon)), icon, layer=3, rotation=0, follow=False))
if opts.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(opts.mission)
boundary = wp.polygon()
slipmap.add_object(mp_slipmap.SlipPolygon('mission', boundary, layer=1,
linewidth=1, colour=(255,255,255)))
if opts.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.gammalog is not None:
gamma = parse_gamma_log(opts.gammalog)
else:
gamma = None
if opts.kmzlog:
kmzpos = mav_position.KmlPosition(opts.kmzlog)
else:
kmzpos = None
if opts.triggerlog:
triggerpos = mav_position.TriggerPosition(opts.triggerlog)
else:
triggerpos = None
# create a simple lens model using the focal length
C_params = cam_params.CameraParams(lens=opts.lens, sensorwidth=opts.sensorwidth)
if opts.camera_params:
C_params.load(opts.camera_params)
camera_settings = MPSettings(
[ MPSetting('roll_stabilised', bool, opts.roll_stabilised, 'Roll Stabilised'),
MPSetting('altitude', int, opts.altitude, 'Altitude', range=(0,10000), increment=1),
MPSetting('minalt', int, 30, 'MinAltitude', range=(0,10000), increment=1),
MPSetting('mpp100', float, 0.0977, 'MPPat100m', range=(0,10000), increment=0.001),
MPSetting('filter_type', str, 'simple', 'Filter Type',
choice=['simple', 'compactness']),
MPSetting('quality', int, 75, 'Compression Quality', range=(1,100), increment=1),
MPSetting('thumbsize', int, opts.thumbsize, 'Thumbnail Size', range=(10, 200), increment=1),
MPSetting('minscore', int, opts.minscore, 'Min Score', range=(0,1000), increment=1, tab='Scoring'),
MPSetting('brightness', float, 1.0, 'Display Brightness', range=(0.1, 10), increment=0.1,
digits=2, tab='Display')
],
title='Camera Settings'
)
image_settings = MPSettings(
[ MPSetting('MinRegionArea', float, 0.15, range=(0,100), increment=0.05, digits=2, tab='Image Processing'),
MPSetting('MaxRegionArea', float, 2.0, range=(0,100), increment=0.1, digits=1),
MPSetting('MinRegionSize', float, 0.1, range=(0,100), increment=0.05, digits=2),
MPSetting('MaxRegionSize', float, 2, range=(0,100), increment=0.1, digits=1),
MPSetting('MaxRarityPct', float, 0.02, range=(0,100), increment=0.01, digits=2),
MPSetting('RegionMergeSize', float, 3.0, range=(0,100), increment=0.1, digits=1),
MPSetting('SaveIntermediate', bool, opts.debug)
],
title='Image Settings')
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params,
camera_settings=camera_settings,
image_settings=image_settings,
start_menu=True,
classify=opts.categories,
thumb_size=opts.mosaic_thumbsize)
joelog = cuav_joe.JoeLog(None)
if opts.view:
viewer = mp_image.MPImage(title='Image', can_zoom=True, can_drag=True)
if camera_settings.filter_type == 'compactness':
calculate_compactness = True
print("Using compactness filter")
else:
calculate_compactness = False
for f in files:
if not mosaic.started():
print("Waiting for startup")
while not mosaic.started():
mosaic.check_events()
time.sleep(0.01)
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
if gamma is not None:
frame_time = parse_gamma_time(f, gamma)
else:
frame_time = cuav_util.parse_frame_time(f)
frame_time += opts.time_offset
if camera_settings.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += opts.time_offset
# update the plane icon on the map
if pos is not None:
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
if camera_settings.altitude > 0:
pos.altitude = camera_settings.altitude
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f)
(w,h) = cuav_util.image_shape(im_orig)
if not opts.camera_params:
C_params.set_resolution(w, h)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
t0=time.time()
img_scan = im_full
scan_parms = {}
for name in image_settings.list():
scan_parms[name] = image_settings.get(name)
scan_parms['SaveIntermediate'] = float(scan_parms['SaveIntermediate'])
if pos is not None:
(sw,sh) = cuav_util.image_shape(img_scan)
altitude = pos.altitude
if altitude < camera_settings.minalt:
altitude = camera_settings.minalt
scan_parms['MetersPerPixel'] = camera_settings.mpp100 * altitude / 100.0
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions, cuav_util.image_shape(img_scan), cuav_util.image_shape(im_full), calculate_compactness)
count += 1
t1=time.time()
frame_time = pos.time
regions = cuav_region.filter_regions(im_full, regions, frame_time=frame_time,
min_score=camera_settings.minscore,
filter_type=camera_settings.filter_type)
scan_count += 1
if pos and len(regions) > 0:
altitude = camera_settings.altitude
if altitude <= 0:
altitude = None
joelog.add_regions(frame_time, regions, pos, f, width=w, height=h,
altitude=altitude)
mosaic.add_image(pos.time, f, pos)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.view:
img_view = img_scan
(wview,hview) = cuav_util.image_shape(img_view)
mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(mat, (255,0,0))
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
viewer.set_title('Image: ' + os.path.basename(f))
total_time += (t1-t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' % (
os.path.basename(f), count/total_time, region_count, scan_count, num_files))
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
if os.path.isdir(args.directory):
files.extend(file_list(args.directory, ['jpg', 'jpeg', 'png']))
else:
if args.directory.find('*') != -1:
files.extend(glob.glob(args.directory))
else:
files.append(args.directory)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=args.service, elevation=True, title='Map')
if args.vehicle_type == "Copter":
icon = slipmap.icon('redcopter.png')
else:
icon = slipmap.icon('redplane.png')
slipmap.add_object(mp_slipmap.SlipIcon('plane', (0,0), icon, layer=3, rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
for flag in args.flag:
a = flag.split(',')
lat = a[0]
lon = a[1]
icon = 'flag.png'
if len(a) > 2:
icon = a[2] + '.png'
icon = slipmap.icon(icon)
slipmap.add_object(mp_slipmap.SlipIcon('icon - %s' % str(flag), (float(lat),float(lon)), icon, layer=3, rotation=0, follow=False))
if args.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(args.mission.name)
plist = wp.polygon_list()
if len(plist) > 0:
for i in range(len(plist)):
slipmap.add_object(mp_slipmap.SlipPolygon('Mission-%s-%u' % (args.mission.name,i), plist[i], layer='Mission',
linewidth=2, colour=(255,255,255)))
if args.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(args.mavlog.name)
else:
mpos = None
if args.gammalog is not None:
gamma = parse_gamma_log(args.gammalog)
else:
gamma = None
if args.kmzlog:
kmzpos = mav_position.KmlPosition(args.kmzlog.name)
else:
kmzpos = None
if args.triggerlog:
triggerpos = mav_position.TriggerPosition(args.triggerlog.name)
else:
triggerpos = None
# create a simple lens model using the focal length
if args.camera_params:
C_params = cam_params.CameraParams.fromfile(args.camera_params.name)
else:
im_orig = cv2.imread(files[0])
(w,h) = cuav_util.image_shape(im_orig)
C_params = cam_params.CameraParams(lens=args.lens, sensorwidth=args.sensorwidth, xresolution=w, yresolution=h)
if args.target:
target = args.target.split(',')
else:
target = [0,0,0]
camera_settings = MPSettings(
[ MPSetting('roll_stabilised', bool, args.roll_stabilised, 'Roll Stabilised'),
MPSetting('pitch_stabilised', bool, args.pitch_stabilised, 'Pitch Stabilised'),
MPSetting('roll_offset', float, args.roll_offset, 'Roll Offset'),
MPSetting('pitch_offset', float, args.pitch_offset, 'Pitch Offset'),
MPSetting('altitude', int, args.altitude, 'Altitude', range=(0,10000), increment=1),
MPSetting('minalt', int, 30, 'MinAltitude', range=(0,10000), increment=1),
MPSetting('mpp100', float, 0.0977, 'MPPat100m', range=(0,10000), increment=0.001),
MPSetting('rotate180', bool, False, 'rotate180'),
MPSetting('filter_type', str, 'simple', 'Filter Type',
choice=['simple']),
MPSetting('target_lattitude', float, float(target[0]), 'target latitude', increment=1.0e-7),
MPSetting('target_longitude', float, float(target[1]), 'target longitude', increment=1.0e-7),
MPSetting('target_radius', float, float(target[2]), 'target radius', increment=1),
MPSetting('quality', int, 75, 'Compression Quality', range=(1,100), increment=1),
MPSetting('thumbsize', int, args.thumbsize, 'Thumbnail Size', range=(10, 200), increment=1),
MPSetting('RegionHue', int, ags.targethue, 'Target Hue (0 to disable)', range=(0,180), increment=1, tab='Imaging'),
MPSetting('map_thumbsize', int, args.map_thumbsize, 'Map Thumbnail Size', range=(10, 200), increment=1),
MPSetting('minscore', int, args.minscore, 'Min Score', range=(0,1000), increment=1, tab='Scoring'),
MPSetting('brightness', float, 1.0, 'Display Brightness', range=(0.1, 10), increment=0.1,
digits=2, tab='Display'),
],
title='Camera Settings'
)
image_settings = MPSettings(
[ MPSetting('MinRegionArea', float, 0.15, range=(0,100), increment=0.05, digits=2, tab='Image Processing'),
MPSetting('MaxRegionArea', float, 1.0, range=(0,100), increment=0.1, digits=1),
MPSetting('MinRegionSize', float, 0.2, range=(0,100), increment=0.05, digits=2),
MPSetting('MaxRegionSize', float, 1.0, range=(0,100), increment=0.1, digits=1),
MPSetting('MaxRarityPct', float, 0.02, range=(0,100), increment=0.01, digits=2),
MPSetting('RegionMergeSize', float, 1.0, range=(0,100), increment=0.1, digits=1),
MPSetting('SaveIntermediate', bool, args.debug)
],
title='Image Settings')
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params,
camera_settings=camera_settings,
image_settings=image_settings,
start_menu=True,
classify=args.categories,
thumb_size=args.mosaic_thumbsize,
map_thumb_size=args.map_thumbsize)
joelog = cuav_joe.JoeLog(None)
if args.view:
viewer = mp_image.MPImage(title='Image', can_zoom=True, can_drag=True)
start_time = time.time()
for f in files:
if not mosaic.started():
print("Waiting for startup")
if args.start:
mosaic.has_started = True
while not mosaic.started():
mosaic.check_events()
time.sleep(0.01)
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
if gamma is not None:
frame_time = parse_gamma_time(f, gamma)
else:
frame_time = cuav_util.parse_frame_time(f)
frame_time += args.time_offset
if camera_settings.roll_stabilised:
roll = 0
else:
roll = None
if camera_settings.pitch_stabilised:
pitch = 0
else:
pitch = None
try:
pos = mpos.position(frame_time, roll=roll, pitch=pitch,
roll_offset=camera_settings.roll_offset,
pitch_offset=camera_settings.pitch_offset)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += args.time_offset
# update the vehicle icon on the map
if pos is not None:
slipmap.set_position("plane", (pos.lat, pos.lon), rotation=pos.yaw)
if camera_settings.altitude > 0:
pos.altitude = camera_settings.altitude
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
#im_orig = cuav_util.LoadImage(f, rotate180=camera_settings.rotate180)
im_orig = cv2.imread(f)
if im_orig is None:
continue
(w,h) = cuav_util.image_shape(im_orig)
if args.downsample:
im_full = cv2.resize(im_orig, (0,0), fx=0.5, fy=0.5)
else:
im_full = im_orig
count = 0
total_time = 0
t0=time.time()
img_scan = im_full
scan_parms = {}
for name in image_settings.list():
scan_parms[name] = image_settings.get(name)
scan_parms['SaveIntermediate'] = float(scan_parms['SaveIntermediate'])
if pos is not None:
(sw,sh) = cuav_util.image_shape(img_scan)
altitude = pos.altitude
if altitude < camera_settings.minalt:
altitude = camera_settings.minalt
scan_parms['MetersPerPixel'] = camera_settings.mpp100 * altitude / 100.0
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions, cuav_util.image_shape(img_scan), cuav_util.image_shape(im_full))
count += 1
t1=time.time()
frame_time = pos.time
regions = cuav_region.filter_regions(im_full, regions, min_score=camera_settings.minscore,
filter_type=camera_settings.filter_type,
target_hue=camera_settings.RegionHue)
if pos:
for r in regions:
r.latlon = cuav_util.gps_position_from_image_region(r, pos, w, h, altitude=altitude, C=C_params)
if camera_settings.target_radius > 0 and pos is not None:
regions = cuav_region.filter_radius(regions, (camera_settings.target_lattitude,
camera_settings.target_longitude),
camera_settings.target_radius)
scan_count += 1
if pos and len(regions) > 0:
joelog.add_regions(frame_time, regions, pos, f)
mosaic.add_image(pos.time, f, pos)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_region.CompositeThumbnail(im_full, regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
thumbsRGB = []
#colour space conversion
for thumb in thumbs:
thumbsRGB.append(cv2.cvtColor(thumb, cv2.COLOR_BGR2RGB))
mosaic.add_regions(regions, thumbsRGB, f, pos)
if args.view:
img_view = img_scan
(wview,hview) = cuav_util.image_shape(img_view)
for r in regions:
r.draw_rectangle(img_view, (255,0,0))
#cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
img_view = cv2.cvtColor(img_view, cv2.COLOR_BGR2RGB)
viewer.set_image(img_view)
viewer.set_title('Image: ' + os.path.basename(f))
total_time += (t1-t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' % (
os.path.basename(f), count/total_time, region_count, scan_count, num_files))
#raw_input("hit ENTER when ready")
print("All images processed (%u seconds)" % (time.time() - start_time))
while True:
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
time.sleep(0.2)
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(file_list(a, ['jpg', 'pgm', 'png']))
else:
if a.find('*') != -1:
files.extend(glob.glob(a))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=opts.service,
elevation=True,
title='Map')
icon = slipmap.icon('redplane.png')
slipmap.add_object(
mp_slipmap.SlipIcon('plane', (0, 0),
icon,
layer=3,
rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
if opts.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(opts.mission)
boundary = wp.polygon()
slipmap.add_object(
mp_slipmap.SlipPolygon('mission',
boundary,
layer=1,
linewidth=1,
colour=(255, 255, 255)))
if opts.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.kmzlog:
kmzpos = mav_position.KmlPosition(opts.kmzlog)
else:
kmzpos = None
if opts.triggerlog:
triggerpos = mav_position.TriggerPosition(opts.triggerlog)
else:
triggerpos = None
# create a simple lens model using the focal length
C_params = cam_params.CameraParams(lens=opts.lens,
sensorwidth=opts.sensorwidth)
if opts.camera_params:
C_params.load(opts.camera_params)
camera_settings = MPSettings([
MPSetting('roll_stabilised', bool, True, 'Roll Stabilised'),
MPSetting(
'altitude', int, 0, 'Altitude', range=(0, 10000), increment=1),
MPSetting('filter_type',
str,
'simple',
'Filter Type',
choice=['simple', 'compactness']),
MPSetting('fullres', bool, False, 'Full Resolution'),
MPSetting('quality',
int,
75,
'Compression Quality',
range=(1, 100),
increment=1),
MPSetting('thumbsize',
int,
60,
'Thumbnail Size',
range=(10, 200),
increment=1),
MPSetting('minscore',
int,
75,
'Min Score',
range=(0, 1000),
increment=1,
tab='Scoring'),
MPSetting('brightness',
float,
1.0,
'Display Brightness',
range=(0.1, 10),
increment=0.1,
digits=2,
tab='Display')
],
title='Camera Settings')
image_settings = MPSettings([
MPSetting('MinRegionArea',
float,
0.15,
range=(0, 100),
increment=0.05,
digits=2,
tab='Image Processing'),
MPSetting('MaxRegionArea',
float,
2.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('MinRegionSize',
float,
0.1,
range=(0, 100),
increment=0.05,
digits=2),
MPSetting(
'MaxRegionSize', float, 2, range=(0, 100), increment=0.1,
digits=1),
MPSetting('MaxRarityPct',
float,
0.02,
range=(0, 100),
increment=0.01,
digits=2),
MPSetting('RegionMergeSize',
float,
3.0,
range=(0, 100),
increment=0.1,
digits=1),
MPSetting('SaveIntermediate', bool, False)
],
title='Image Settings')
mosaic = cuav_mosaic.Mosaic(slipmap,
C=C_params,
camera_settings=camera_settings,
image_settings=image_settings,
start_menu=True)
joelog = cuav_joe.JoeLog(None)
if opts.view:
viewer = mp_image.MPImage(title='Image', can_zoom=True, can_drag=True)
if camera_settings.filter_type == 'compactness':
calculate_compactness = True
print("Using compactness filter")
else:
calculate_compactness = False
for f in files:
if not mosaic.started():
print("Waiting for startup")
while not mosaic.started():
mosaic.check_events()
time.sleep(0.01)
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
frame_time = cuav_util.parse_frame_time(f) + opts.time_offset
if camera_settings.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += opts.time_offset
# update the plane icon on the map
if pos is not None:
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
if camera_settings.altitude > 0:
pos.altitude = camera_settings.altitude
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f)
(w, h) = cuav_util.image_shape(im_orig)
if not opts.camera_params:
C_params.set_resolution(w, h)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
t0 = time.time()
if camera_settings.fullres:
img_scan = im_full
else:
img_scan = im_640
scan_parms = {}
for name in image_settings.list():
scan_parms[name] = image_settings.get(name)
scan_parms['SaveIntermediate'] = float(scan_parms['SaveIntermediate'])
if pos is not None:
(sw, sh) = cuav_util.image_shape(img_scan)
mpp = cuav_util.meters_per_pixel(pos, C=C_params)
if mpp is not None:
scan_parms['MetersPerPixel'] = mpp * (w / float(sw))
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions,
cuav_util.image_shape(img_scan),
cuav_util.image_shape(im_full),
calculate_compactness)
count += 1
t1 = time.time()
frame_time = pos.time
regions = cuav_region.filter_regions(
im_full,
regions,
frame_time=frame_time,
min_score=camera_settings.minscore,
filter_type=camera_settings.filter_type)
scan_count += 1
mosaic.add_image(pos.time, f, pos)
if pos and len(regions) > 0:
altitude = camera_settings.altitude
if altitude <= 0:
altitude = None
joelog.add_regions(frame_time,
regions,
pos,
f,
width=w,
height=h,
altitude=altitude)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(
cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.view:
img_view = img_scan
(wview, hview) = cuav_util.image_shape(img_view)
mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(mat, (255, 0, 0))
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
viewer.set_title('Image: ' + os.path.basename(f))
total_time += (t1 - t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' %
(os.path.basename(f), count / total_time, region_count,
scan_count, num_files))
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = []
for a in args:
if os.path.isdir(a):
files.extend(file_list(a, ['jpg', 'pgm', 'png']))
else:
if a.find('*') != -1:
files.extend(glob.glob(a))
else:
files.append(a)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
slipmap = mp_slipmap.MPSlipMap(service=opts.service,
elevation=True,
title='Map')
icon = slipmap.icon('redplane.png')
slipmap.add_object(
mp_slipmap.SlipIcon('plane', (0, 0),
icon,
layer=3,
rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
if opts.mission:
from pymavlink import mavwp
wp = mavwp.MAVWPLoader()
wp.load(opts.mission)
boundary = wp.polygon()
slipmap.add_object(
mp_slipmap.SlipPolygon('mission',
boundary,
layer=1,
linewidth=1,
colour=(255, 255, 255)))
if opts.mavlog:
mpos = mav_position.MavInterpolator()
mpos.set_logfile(opts.mavlog)
else:
mpos = None
if opts.kmzlog:
kmzpos = mav_position.KmlPosition(opts.kmzlog)
else:
kmzpos = None
if opts.triggerlog:
triggerpos = mav_position.TriggerPosition(opts.triggerlog)
else:
triggerpos = None
# create a simple lens model using the focal length
C_params = cam_params.CameraParams(lens=opts.lens,
sensorwidth=opts.sensorwidth)
if opts.camera_params:
C_params.load(opts.camera_params)
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params)
joelog = cuav_joe.JoeLog(None)
if opts.view:
viewer = mp_image.MPImage(title='Image', can_zoom=True, can_drag=True)
scan_parms = {
'MinRegionArea': opts.min_region_area,
'MaxRegionArea': opts.max_region_area,
'MinRegionSize': opts.min_region_size,
'MaxRegionSize': opts.max_region_size,
'MaxRarityPct': opts.max_rarity_pct,
'RegionMergeSize': opts.region_merge
}
for f in files:
if mpos:
# get the position by interpolating telemetry data from the MAVLink log file
# this assumes that the filename contains the timestamp
frame_time = cuav_util.parse_frame_time(f) + opts.time_offset
if opts.roll_stabilised:
roll = 0
else:
roll = None
try:
pos = mpos.position(frame_time, roll=roll)
except Exception:
print("No position available for %s" % frame_time)
# skip this frame
continue
elif kmzpos is not None:
pos = kmzpos.position(f)
elif triggerpos is not None:
pos = triggerpos.position(f)
else:
# get the position using EXIF data
pos = mav_position.exif_position(f)
pos.time += opts.time_offset
# update the plane icon on the map
if pos is not None:
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
# check for any events from the map
slipmap.check_events()
mosaic.check_events()
im_orig = cuav_util.LoadImage(f)
(w, h) = cuav_util.image_shape(im_orig)
if not opts.camera_params:
C_params.set_resolution(w, h)
im_full = im_orig
im_640 = cv.CreateImage((640, 480), 8, 3)
cv.Resize(im_full, im_640, cv.CV_INTER_NN)
im_640 = numpy.ascontiguousarray(cv.GetMat(im_640))
im_full = numpy.ascontiguousarray(cv.GetMat(im_full))
count = 0
total_time = 0
t0 = time.time()
if opts.fullres:
img_scan = im_full
else:
img_scan = im_640
if pos is not None:
(sw, sh) = cuav_util.image_shape(img_scan)
mpp = cuav_util.meters_per_pixel(pos, C=C_params)
if mpp is not None:
scan_parms['MetersPerPixel'] = mpp * (w / float(sw))
regions = scanner.scan(img_scan, scan_parms)
else:
regions = scanner.scan(img_scan)
regions = cuav_region.RegionsConvert(regions,
cuav_util.image_shape(img_scan),
cuav_util.image_shape(im_full))
count += 1
t1 = time.time()
frame_time = pos.time
regions = cuav_region.filter_regions(im_full,
regions,
frame_time=frame_time,
min_score=opts.minscore,
filter_type=opts.filter_type)
scan_count += 1
mosaic.add_image(pos.time, f, pos)
if pos and len(regions) > 0:
joelog.add_regions(frame_time,
regions,
pos,
f,
width=w,
height=h,
altitude=opts.altitude)
region_count += len(regions)
if len(regions) > 0:
composite = cuav_mosaic.CompositeThumbnail(
cv.GetImage(cv.fromarray(im_full)), regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if opts.view:
img_view = img_scan
(wview, hview) = cuav_util.image_shape(img_view)
mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(mat, (255, 0, 0))
cv.CvtColor(mat, mat, cv.CV_BGR2RGB)
viewer.set_image(mat)
viewer.set_title('Image: ' + os.path.basename(f))
total_time += (t1 - t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' %
(os.path.basename(f), count / total_time, region_count,
scan_count, num_files))
def process(args):
'''process a set of files'''
global slipmap, mosaic
scan_count = 0
files = scan_image_directory(args.imagedir)
files.sort()
num_files = len(files)
print("num_files=%u" % num_files)
region_count = 0
joes = []
if args.mavlog:
mpos = mav_position.MavInterpolator(gps_lag=args.gps_lag)
mpos.set_logfile(args.mavlog)
else:
mpos = None
if args.boundary:
boundary = cuav_util.polygon_load(args.boundary)
else:
boundary = None
if args.mosaic:
slipmap = mp_slipmap.MPSlipMap(service='GoogleSat', elevation=True, title='Map')
icon = slipmap.icon('redplane.png')
slipmap.add_object(mp_slipmap.SlipIcon('plane', (0,0), icon, layer=3, rotation=0,
follow=True,
trail=mp_slipmap.SlipTrail()))
if args.camera_params:
C_params = cam_params.CameraParams.fromfile(args.camera_params.name)
else:
im_orig = cv2.imread(files[0])
(w,h) = cuav_util.image_shape(im_orig)
C_params = cam_params.CameraParams(lens=args.lens, sensorwidth=args.sensorwidth, xresolution=w, yresolution=h)
mosaic = cuav_mosaic.Mosaic(slipmap, C=C_params)
if boundary is not None:
mosaic.set_boundary(boundary)
if args.joe:
joes = cuav_util.polygon_load(args.joe)
if boundary:
for i in range(len(joes)):
joe = joes[i]
if cuav_util.polygon_outside(joe, boundary):
print("Error: joe outside boundary", joe)
return
icon = slipmap.icon('flag.png')
slipmap.add_object(mp_slipmap.SlipIcon('joe%u' % i, (joe[0],joe[1]), icon, layer=4))
joelog = cuav_joe.JoeLog('joe.log')
if args.view:
viewer = mp_image.MPImage(title='Image')
frame_time = 0
scan_parms = {
'MinRegionArea' : args.min_region_area,
'MaxRegionArea' : args.max_region_area,
'MinRegionSize' : args.min_region_size,
'MaxRegionSize' : args.max_region_size,
'MaxRarityPct' : args.max_rarity_pct,
'RegionMergeSize' : args.region_merge,
'SaveIntermediate' : float(0),
#'SaveIntermediate' : float(args.debug),
'MetersPerPixel' : args.meters_per_pixel100 * args.altitude / 100.0
}
filenum = 0
for f in files:
filenum += 1
if mpos:
frame_time = cuav_util.parse_frame_time(f)
try:
if args.roll_stabilised:
roll = 0
else:
roll = None
pos = mpos.position(frame_time, args.max_deltat,roll=roll)
slipmap.set_position('plane', (pos.lat, pos.lon), rotation=pos.yaw)
except mav_position.MavInterpolatorException as e:
print(e)
pos = None
else:
pos = None
# check for any events from the map
if args.mosaic:
slipmap.check_events()
mosaic.check_events()
im_orig = cv2.imread(f)
(w,h) = cuav_util.image_shape(im_orig)
im_full = im_orig
im_half = cv2.resize(im_orig, (0,0), fx=0.5, fy=0.5)
im_half = numpy.ascontiguousarray(im_half)
im_full = numpy.ascontiguousarray(im_full)
count = 0
total_time = 0
if args.fullres:
img_scan = im_full
else:
img_scan = im_half
t0=time.time()
for i in range(args.repeat):
regions = scanner.scan(img_scan, scan_parms)
regions = cuav_region.RegionsConvert(regions, cuav_util.image_shape(img_scan), cuav_util.image_shape(im_full))
count += 1
t1=time.time()
if args.filter:
regions = cuav_region.filter_regions(im_full, regions, min_score=args.minscore,
filter_type=args.filter_type)
if len(regions) > 0 and args.debug:
composite = cuav_region.CompositeThumbnail(im_full, regions, thumb_size=args.thumb_size)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
thumb_num = 0
for thumb in thumbs:
print("thumb %u score %f" % (thumb_num, regions[thumb_num].score))
cv2.imwrite('%u_thumb%u.jpg' % (filenum,thumb_num), thumb)
thumb_num += 1
scan_count += 1
# optionally link all the images with joe into a separate directory
# for faster re-running of the test with just joe images
if pos and args.linkjoe and len(regions) > 0:
cuav_util.mkdir_p(args.linkjoe)
if not cuav_util.polygon_outside((pos.lat, pos.lon), boundary):
joepath = os.path.join(args.linkjoe, os.path.basename(f))
if os.path.exists(joepath):
os.unlink(joepath)
os.symlink(f, joepath)
if pos and len(regions) > 0:
joelog.add_regions(frame_time, regions, pos, f, width=w, height=h, altitude=args.altitude, C=C_params)
if boundary:
regions = cuav_region.filter_boundary(regions, boundary, pos)
region_count += len(regions)
if args.mosaic and len(regions) > 0 and pos:
composite = cuav_region.CompositeThumbnail(im_full, regions)
thumbs = cuav_mosaic.ExtractThumbs(composite, len(regions))
mosaic.add_regions(regions, thumbs, f, pos)
if args.view:
if args.fullres:
img_view = im_full
else:
img_view = img_scan
#mat = cv.fromarray(img_view)
for r in regions:
r.draw_rectangle(img_view, colour=(255,0,0), linewidth=min(max(w/600,1),3), offset=max(w/200,1))
img_view = cv2.cvtColor(img_view, cv2.COLOR_BGR2RGB)
viewer.set_image(img_view)
total_time += (t1-t0)
if t1 != t0:
print('%s scan %.1f fps %u regions [%u/%u]' % (
f, count/total_time, region_count, scan_count, num_files))