Beispiel #1
0
            map(lambda x: int(x * 255),
                list(cmap(1. * i / faller['dist']))[:-1])
            for i in range(faller['dist'])
        ]

    def run(self):

        cells = self.np.zeros((self.width, self.height, 3),
                              dtype=self.np.uint8)
        # render the fallers on
        remove = []
        for f in self.fallers:
            f['y'] += f['speed']

            for i in xrange(f['dist']):
                try:
                    if int(f['y']) - i >= 0:
                        cells[f['x'], int(f['y']) - i] = f['cols'][i]
                except IndexError, e:
                    pass
            if f['y'] - f['dist'] > self.height:
                remove.append(f)
                self.fallers.append(self.make_faller())
        map(self.fallers.remove, remove)
        return cells


if __name__ == "__main__":
    from demo import show
    show(Runner, fps=24)
Beispiel #2
0
        output2_opencl = cl.Buffer(self.ctx, mf.WRITE_ONLY, output2.nbytes)
        output_opencl = cl.Buffer(self.ctx, mf.WRITE_ONLY, output.nbytes)
        self.prg.mandelbrot(self.queue, output.shape, None, q_opencl,
                            self.lut_opencl, output_opencl, output2_opencl,
                            maxiter).wait()
        cl.enqueue_copy(self.queue, output2, output2_opencl)
        # return self.lut[output2]

        cl.enqueue_copy(self.queue, output, output_opencl).wait()
        return output, output2

    def run(self):
        start = self.time.time()
        self.cells = self.mandelbrot_set3(self.xmin,
                                          self.xmax,
                                          self.ymin,
                                          self.ymax,
                                          width=self.width,
                                          height=self.height)
        # print "calculating", self.time.time() - start, self.cells.shape
        self.update_pos()

        return self.cells, "{:.2f} - {:.2f}\n{:.2f} - {:.2f}".format(
            self.xmin, self.xmax, self.ymin, self.ymax)


if __name__ == "__main__":
    from demo import show

    show(Runner, fps=90, rows=900, cols=900, scale=1)
Beispiel #3
0
import numpy as np
from demo import read, show
from skimage import transform

img = read("../matlab_example/imgs/0401.tif")
#tf_rotate = transform.SimilarityTransform(rotation=np.deg2rad(30))
#img = transform.warp(img, tf_rotate)
#tf_shift = transform.SimilarityTransform(translation=[60, 60])
#img = transform.warp(img, tf_shift)

show(img, cmap='gray')

fft2 = np.fft.fft2(img)
show(np.abs(fft2), cmap='gray')

shift2center = np.fft.fftshift(fft2)
show(np.abs(fft2), cmap='gray')

log_fft2 = np.log(1 + np.abs(fft2))
show(np.abs(log_fft2), cmap='gray')

log_shift2center = np.log(1 + np.abs(shift2center))
show(np.abs(log_shift2center), cmap='gray')
Beispiel #4
0
# coding: utf-8
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
from skimage import io, util
from skimage import data
from scipy.ndimage import convolve, laplace, sobel
from scipy.signal import medfilt
from demo import read, show

I = read('imgs/lenna.tif')
show(I, 'raw_image', 'gray')

# apply laplace filter
I1 = laplace(I)
show(I1, 'after applying laplace filter', 'gray')

# apply a gussian filter
I2 = sobel(I)
show(I2, 'after applying sobel filter', 'gray')
Beispiel #5
0
    def run(self):
        # return self.plasma_gpu()
        np = self.np
        w = self.width
        h = self.height
        step = 5
        if not self.use_cl:
            half_len = self.half_len
            img = np.empty((self.width, self.height, 3), dtype=np.uint8)
            denom = self.denom.next()
            for y in xrange(0, self.height):
                for x in xrange(0, self.width):
                    col = int(half_len + (
                        half_len * np.sin(np.sqrt((x - w / 2.0) **2 + (y - h / 2.0) **2) / denom)))
                    if col + self.step < len(self.cols):
                        img[x][y] = self.cols[(col + self.step)]
                    else:
                        img[x][y] = self.cols[len(self.cols) - (col + self.step)]
        else:
            img = self.plasma_gpu()
        self.step += step
        self.step %= len(self.cols)

        return img


if __name__ == "__main__":
    from demo import show

    show(Runner, fps=90, rows=1000, cols=2000, scale=1)
Beispiel #6
0
        if self.facing:
            col1, col2 = [
                self.colors[self.np.random.choice(self.colors.shape[0],
                                                  self.board_dimensions[0] / 2,
                                                  replace=False)]
                for _ in [1, 2]
            ]
            col1.sort(0)
            col2.sort(0)
            if self.face_in:
                col = self.np.concatenate([col1[::-1], col2])
            else:
                col = self.np.concatenate([col1, col2[::-1]])

        else:
            col = self.colors[self.np.random.choice(self.colors.shape[0],
                                                    self.board_dimensions[0],
                                                    replace=False)]
        for idx, i in enumerate(col):
            self.pixels[idx][0] = i
        if not self.facing and self.sorted:
            self.pixels.sort(0)

        return self.pixels


if __name__ == "__main__":
    from demo import show

    show(Runner)
Beispiel #7
0
        # sky = [206, 237, 255]
        sky = next(self.sky_colours)
        pixels = np.full((self.dims[0], self.dims[1], 3),
                         water,
                         dtype=np.uint8)
        pixels[:, 0:13] = sky
        self.update_things()
        for thing in self.things + self.current_players.values():
            template = self.things_templates[thing['type']]
            if thing['type'] == 'boat':
                colour = thing['colour']
            else:
                colour = template['colours']
            grid = template['template']
            xpos = thing['xpos']
            ypos = thing['ypos']
            for y, row in enumerate(grid):
                y = np.int(np.floor(ypos + y))
                for x, pix in enumerate(row):
                    if pix != 0:
                        col = colour[pix - 1]
                        x = np.int((xpos + x) % self.dims[0])
                        pixels[x, y] = col
        return pixels


if __name__ == "__main__":
    from demo import show

    show(Runner, fps=30, rows=17, cols=165, scale=8)
Beispiel #8
0
            self.colors = np.random.randint(0, 255, [9012, 3])
        self.pixels = self.np.zeros((self.board_dimensions[0], self.board_dimensions[1], 3)).astype(self.np.uint8)

    def run(self):
        # shift everything to the left, put a new random column on the end

        self.pixels = self.np.roll(self.pixels, 1, 1)
        if self.facing:
            col1, col2 = [self.colors[self.np.random.choice(self.colors.shape[0], self.board_dimensions[0]/2, replace=False)] for _ in [1,2]]
            col1.sort(0)
            col2.sort(0)
            if self.face_in:
                col = self.np.concatenate([col1[::-1],col2])
            else:
                col = self.np.concatenate([col1,col2[::-1]])

        else:
            col = self.colors[self.np.random.choice(self.colors.shape[0], self.board_dimensions[0], replace=False)]
        for idx, i in enumerate(col):
            self.pixels[idx][0] = i
        if not self.facing and self.sorted:
            self.pixels.sort(0)

        return self.pixels


if __name__ == "__main__":
    from demo import show

    show(Runner)
                'dlObject': 'TON_T1_G.42',
                'lbWeeks': 't',
                'lbDays': '1-7;1;2;3;4;5;6;7',
                'dlPeriod': '1-34;1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31;32;33;34;',
                'RadioType': 'flinders_location_list;cyon_reports_list_url;dummy',
                'bGetTimetable': 'View Timetable',
            }
            for hidden_input in BeautifulSoup(full_day_soup, 'html.parser').find_all('input', {'type': 'hidden'}):
                tt_data[hidden_input['name']] = hidden_input['value']
            now = datetime.now()
            tt_text = s.post(default_url, data=tt_data).text
            soup = BeautifulSoup(tt_text, 'html.parser')
            rows = soup.find('tbody').find_all('tr')
            for row in rows:
                cells = row.find_all('td')
                day = int(cells[2].p.text)
                title = cells[1].text
                if day != now.weekday():
                    continue
                time_start = int(cells[3].p.text.split(':')[0])
                time_end = int(cells[4].p.text.split(':')[0])
                if time_start <= now.hour < time_end:
                    return " {} - {}:00 to {}:00 ".format(title, time_start, time_end)

        return "Hello!"


if __name__ == "__main__":
    from demo import show
    show(Runner, fps=24)
Beispiel #10
0
#     <h1>Video Streaming Demonstration</h1>
#     <img id="bg" src="/video_feed">
#   </body>
# </html>
#     """
#
#
# def gen(camera):
#     while 1:
#         frame = camera.run(None)[0]
#         frame = cv2.cvtColor(np.flipud(np.rot90(frame)), cv2.COLOR_RGB2BGR)
#
#         jpeg = cv2.imencode('.jpg', frame)[1]
#         # print jpeg
#         yield (b'--frame\r\n'
#                b'Content-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n\r\n')
#
#
# @app.route('/video_feed')
# def video_feed():
#     return Response(gen(Runner([480, 640])),
#                     mimetype='multipart/x-mixed-replace; boundary=frame')
#

if __name__ == "__main__":
    # app.run(host='0.0.0.0', debug=True)
    from demo import show

    show(Runner, fps=30, rows=480, cols=640, scale=2, withArgs=True)
    # show(Runner, fps=30, rows=17, cols=165, scale=9, withArgs=True)
Beispiel #11
0
#     <h1>Video Streaming Demonstration</h1>
#     <img id="bg" src="/video_feed">
#   </body>
# </html>
#     """
#
#
# def gen(camera):
#     while 1:
#         frame = camera.run(None)[0]
#         frame = cv2.cvtColor(np.flipud(np.rot90(frame)), cv2.COLOR_RGB2BGR)
#
#         jpeg = cv2.imencode('.jpg', frame)[1]
#         # print jpeg
#         yield (b'--frame\r\n'
#                b'Content-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n\r\n')
#
#
# @app.route('/video_feed')
# def video_feed():
#     return Response(gen(Runner([480, 640])),
#                     mimetype='multipart/x-mixed-replace; boundary=frame')
#

if __name__ == "__main__":
    # app.run(host='0.0.0.0', debug=True)
    from demo import show

    show(Runner, fps=30, rows=480, cols=640, scale=2, withArgs=True)
    # show(Runner, fps=30, rows=17, cols=165, scale=9, withArgs=True)
# coding: utf-8
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
from skimage import io, util
from skimage import data
from scipy.ndimage import convolve
from scipy.signal import medfilt
from demo import read, show

I = read('imgs/Fig0219.tif')
show(I, 'raw_image', 'gray')

# add random noisy
I1 = util.random_noise(I, mode='gaussian')
show(I1, 'after adding noisy', 'gray')

# apply a median filter
I2 = medfilt(I1)
show(I2, 'using median filter', 'gray')
Beispiel #13
0
# coding: utf-8
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
from skimage import io
from skimage import data
from scipy.ndimage import convolve
from demo import read, show

I = read('imgs/Fig0216.tif')
show(I, 'raw_image')

# get a filter
f = np.ones((31, 31))
# nearest is same as replicate in matlab
I1 = convolve(I, f, mode='nearest')
I2 = convolve(I, f, mode='mirror')
I3 = convolve(I, f, mode='constant', cval=0)
show(I1, 'using nearest padding')
show(I2, 'using mirror padding')
show(I3, 'using constant 0 padding')
Beispiel #14
0
import numpy as np
from demo import read, show
from scipy.misc import imread, imresize, imsave

img = read("../matlab_example/imgs/0401.tif")
img = imresize(img, (32, 32))
show(img, cmap='gray')

h, w = img.shape
# 生成一个同样大小的复数矩阵
F = np.zeros([h, w], 'complex128')
for u in range(h):
    for v in range(w):
        res = 0
        for x in range(h):
            for y in range(w):
                res += img[x, y] * np.exp(-1.j * 2 * np.pi *
                                          (u * x / h + v * y / w))
        F[u, v] = res
log_F = np.log(1 + np.abs(F))

show(np.abs(log_F), cmap='gray')
Beispiel #15
0
# coding: utf-8
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
from skimage import io, util
from skimage import data
from scipy.ndimage import convolve
from scipy.signal import medfilt
from demo import read, show

I = read('imgs/Fig0219.tif')
show(I, 'raw_image', 'gray')

# get an average filter

r = 10
f = np.full((r, r), 1 / r**2)

I1 = convolve(I, f)
show(I1, 'after applying average filter', 'gray')


def matlab_style_gauss2D(shape=(3, 3), sigma=0.5):
    """
    2D gaussian mask - should give the same result as MATLAB's
    fspecial('gaussian',[shape],[sigma])
    """
    m, n = [(ss - 1.) / 2. for ss in shape]
    y, x = np.ogrid[-m:m + 1, -n:n + 1]
    h = np.exp(-(x * x + y * y) / (2. * sigma * sigma))
    h[h < np.finfo(h.dtype).eps * h.max()] = 0
Beispiel #16
0
import numpy as np
from demo import read, show

raw_img = read("../matlab_example/imgs/0402.tif")
img = np.pad(raw_img, ((0, raw_img.shape[0]), (0, raw_img.shape[1])),
             'constant')
show(img, cmap='gray')

fft2 = np.fft.fft2(img)
shift2center = np.fft.fftshift(fft2)
show(np.log(1 + np.abs(shift2center)), cmap='gray')


def dftuv(m, n):
    u = np.array(list(range(0, m)))
    v = np.array(list(range(0, n)))
    u[m // 2:] -= m
    v[n // 2:] -= n
    u, v = np.meshgrid(u, v)
    return u**2 + v**2


sigma = 0.05 * img.shape[0]
d = dftuv(img.shape[0], img.shape[1])
h = np.exp(-d / (2 * (sigma**2)))

res = np.fft.fft2(raw_img, (img.shape[0], img.shape[1])) * h
res = np.fft.ifft2(res)

show(np.abs(res), cmap='gray')
Beispiel #17
0
            import urllib
            print("Downloading font")
            urllib.urlretrieve('https://www.dropbox.com/s/adt959l9bx0ojlj/slkscr.ttf?dl=1', 'slkscr.ttf')
            self.fnt = Font('slkscr.ttf', 16)

    def run(self):
        np = self.np
        now = self.dt.now()
        if now.minute != self.minute:
            self.np.random.shuffle(self.order)
            self.minute = now.minute
        message = now.strftime("%H:%M:%S")

        render = self.fnt.render_text(message)
        message = str(render).splitlines()
        pixels = np.zeros((self.height, max(self.width, render.width), 3), dtype=np.uint8)
        numcols = self.cols.shape[0]
        color = [(now.hour/24.*255, now.minute/60.*255, now.second/60. * 255)[i] for i in self.order]
        # color = [255,255,255]
        pad = 45 #self.width/2 - len(message[0])/2
        for y in range(render.height):
            for x in range(render.width):
                if message[y][x] == '#':
                    pixels[y+3, x+pad] = color
        return np.flipud(np.rot90(pixels, 1))


if __name__ == "__main__":
    from demo import show
    show(Runner, fps=30, rows=17, cols=165, scale=8)
Beispiel #18
0
                for i in xrange(self.regions):
                    d = np.hypot(self.points[i][0] - x, self.points[i][1] - y)
                    if d < dmin:
                        dmin = d
                        h = i
                im[x][y] = self.cols[h]
        return im

    def run(self):
        np = self.np
        # jitter = np.random.randint(0, 3, size=self.points.shape, dtype=np.int16) - 1
        xjitter = np.random.normal(1, 2, size=self.points.shape[0]).astype(dtype=np.int16)
        yjitter = np.random.normal(0, 1, size=self.points.shape[0]).astype(dtype=np.int16)
        self.points[:, 0] += xjitter
        self.points[:, 1] += yjitter
        self.points[:, 0] %= self.width
        self.points[:, 1] %= self.height
        if self.use_cl:
            out = self.voronoi_gpu()
            for p in self.points:
                out[p[0], p[1]] = self.lut[-1]
            return out
        return self.rand_voronoi()


if __name__ == "__main__":
    from demo import show

    # fps is 1/3 so that we get 3 seconds to admire the output before changing
    show(Runner, fps=60, cols=900, rows=900, scale=1)