Example #1
0
 def popup_fetch_image(self, region, returnkey):
     '''handle popup menu fetchImage'''
     if region is None:
         return
     fullres = (returnkey == 'fetchImageFull')
     frame_time = cuav_util.parse_frame_time(region.filename)
     self.image_requests[frame_time] = fullres
Example #2
0
    def add_regions(self, regions, thumbs, filename, pos=None):
        '''add some regions'''
        for i in range(len(regions)):
            r = regions[i]
            (x1,y1,x2,y2) = r.tuple()

            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]
            rsize = max(x2+1-x1,y2+1-y1)
            tsize = cuav_util.image_width(full_thumb)
            if rsize < tsize:
                thumb = cuav_util.SubImage(full_thumb, ((tsize-self.thumb_size)//2,
                                                        (tsize-self.thumb_size)//2,
                                                        self.thumb_size,
                                                        self.thumb_size))
            else:
                thumb = cv.CreateImage((self.thumb_size, self.thumb_size),8,3)
                cv.Resize(full_thumb, thumb)

            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):
                self.slipmap.add_object(mp_slipmap.SlipThumbnail("region %u" % ridx, (lat,lon),
                                                                 img=thumb,
                                                                 layer=2, border_width=1, border_colour=(255,0,0),
                                                                 popup_menu=self.popup_menu))

        self.image_mosaic.set_image(self.mosaic, bgr=True)
Example #3
0
    def add_regions(self, regions, thumbs, filename, pos=None):
        '''add some regions'''
        for i in range(len(regions)):
            r = regions[i]
            (x1,y1,x2,y2) = r.tuple()

            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]
            rsize = max(x2+1-x1,y2+1-y1)
            tsize = cuav_util.image_width(full_thumb)
            if rsize < tsize:
                thumb = cuav_util.SubImage(full_thumb, ((tsize-self.thumb_size)//2,
                                                        (tsize-self.thumb_size)//2,
                                                        self.thumb_size,
                                                        self.thumb_size))
            else:
                thumb = cv.CreateImage((self.thumb_size, self.thumb_size),8,3)
                cv.Resize(full_thumb, thumb)

            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])

            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):
                self.slipmap.add_object(mp_slipmap.SlipThumbnail("region %u" % ridx, (lat,lon),
                                                                 img=thumb,
                                                                 layer=2, border_width=1, border_colour=(255,0,0),
                                                                 popup_menu=self.popup_menu))

        self.image_mosaic.set_image(self.mosaic, bgr=True)
Example #4
0
def scan_image_directory(dirname):
    '''scan a image directory, extracting frame_time and filename
    as a list of tuples'''
    ret = []
    if opts.jpeg:
        pattern = '*.jpg'
    else:
        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
Example #5
0
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)
Example #6
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(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")

    for f in files:
        frame_time = cuav_util.parse_frame_time(f)
        if mpos:
            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_full(im_8bit, im_full)
            im_640 = numpy.zeros((480, 640, 3), dtype="uint8")
            scanner.downsample(im_full, im_640)
        else:
            im_full = cv.LoadImage(f)
            im_640 = cv.CreateImage((640, 480), 8, 3)
            cv.Resize(im_full, im_640)
            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_full(im_full)
            else:
                regions = scanner.scan(img_scan)
            count += 1
        regions = cuav_region.RegionsConvert(regions)
        t1 = time.time()

        if opts.filter:
            regions = cuav_region.filter_regions(im_full, regions, frame_time=frame_time, min_score=opts.minscore)

        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, quality=opts.quality
            )
            chameleon.save_file("composite.jpg", composite)
            thumbs = cuav_mosaic.ExtractThumbs(cv.LoadImage("composite.jpg"), 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()
                if opts.fullres:
                    x1 *= 2
                    y1 *= 2
                    x2 *= 2
                    y2 *= 2
                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
        print ("%s scan %.1f fps  %u regions [%u/%u]" % (f, count / total_time, region_count, scan_count, num_files))
Example #7
0
    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)
                self.slipmap.add_object(slobj)

        self.image_mosaic.set_image(self.mosaic)
        if self.autorefresh:
            self.re_sort(printsort=False)
            self.redisplay_mosaic()
        if self.topfifty:
            self.re_sort(printsort=False)
            self.redisplay_mosaic()
            self.topfiftyonly()
Example #8
0
    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()