示例#1
0
def renderman_render(config,returnfh = False):
    config = config.to_dict()
    
    params_list = [{}]
    param = params_list[0]
    if 'bg_id' in config:
        param['bg_id'] = config.pop('bg_id')
    if 'bg_phi' in config:
        param['bg_phi'] = config.pop('bg_phi')
    if 'bg_psi' in config:
        param['bg_phi'] = config.pop('bg_psi')
    if 'kenv' in config:
        param['kenv'] = config.pop('kenv')
    if 'res' in config:
        param['res_x'] = param['res_y'] = config['res']
    use_canonical = config.pop('use_canonical',False)
    if use_canonical:
        v = get_canonical_view(config['model_id'])
        if v:
            config['rotations'] = [{'rxy':v['rxy'],'rxz':v['rxz'],'ryz':v['ryz']},
                                   {'rxy':config.pop('rxy',0),'rxz':config.pop('rxz',0),'ryz':config.pop('ryz',0)}]
    param['model_params'] = [config]   

    orig_dir = os.getcwd()
    os.chdir(os.path.join(os.environ['HOME'] , 'render_wd'))
    tmp = tempfile.mkdtemp()
    renderer.render(tmp,params_list)
    imagefile = [os.path.join(tmp,x) for x in os.listdir(tmp) if x.endswith('.tif')][0]
    os.chdir(orig_dir)
     
    fh = open(imagefile)
    if returnfh:
        return fh
    else:
        return fh.read()
示例#2
0
def cou(pose_est, pose_gt, model, im_size, K):
    """
    Complement over Union, i.e. the inverse of the Intersection over Union used
    in the PASCAL VOC challenge - by Everingham et al. (IJCV 2010).

    :param pose_est: Estimated pose given by a dictionary:
    {'R': 3x3 rotation matrix, 't': 3x1 translation vector}.
    :param pose_gt: The ground truth pose given by a dictionary (as pose_est).
    :param model: Object model given by a dictionary where item 'pts'
    is nx3 ndarray with 3D model points.
    :param im_size: Test image size.
    :param K: Camera matrix.
    :return: Error of pose_est w.r.t. pose_gt.
    """

    # Render depth images of the model in the estimated and the ground truth pose
    d_est = renderer.render(model, im_size, K, pose_est['R'], pose_est['t'],
                            clip_near=100, clip_far=10000, mode='depth')

    d_gt = renderer.render(model, im_size, K, pose_gt['R'], pose_gt['t'],
                           clip_near=100, clip_far=10000, mode='depth')

    # Masks of the rendered model and their intersection and union
    mask_est = d_est > 0
    mask_gt = d_gt > 0
    inter = np.logical_and(mask_gt, mask_est)
    union = np.logical_or(mask_gt, mask_est)

    union_count = float(union.sum())
    if union_count > 0:
        e = 1.0 - inter.sum() / union_count
    else:
        e = 1.0
    return e
示例#3
0
def add(hostname, stats, upstat):
    'Update node data accumulator.'
    # update with newer information
    if hostname in nodes:
        for key in stats:
            nodes[hostname][key] = stats[key]
    else:
        nodes[hostname] = stats
    nodes[hostname]['up']='up'

    # incorporate info about down nodes/missing monitord installs
    for hostname in upstat:
        if hostname in nodes:
            nodes[hostname]['up'] = upstat[hostname]
        else:
            nodes[hostname] = {'up':upstat[hostname]}

    # track how many updates we've received total
    for key in stats:
        if key in updates:
            updates[key]+=1
        else:
            updates[key]=1

    # render
    renderer.render(nodes, updates)
    
    # save data in case server goes down
    cPickle.dump(nodes, open(CACHE_FILE, 'wb'))
示例#4
0
def vsd(pose_est, pose_gt, model, depth_test, delta, tau, K):
    """
    Visible Surface Discrepancy.

    :param pose_est: Estimated pose given by a dictionary:
    {'R': 3x3 rotation matrix, 't': 3x1 translation vector}.
    :param pose_gt: The ground truth pose given by a dictionary (as pose_est).
    :param model: Object model given by a dictionary where item 'pts'
    is nx3 ndarray with 3D model points.
    :param depth_test: Depth image of the test scene.
    :param delta: Tolerance used for estimation of the visibility masks.
    :param tau: Misalignment tolerance.
    :return: Error of pose_est w.r.t. pose_gt.
    """

    im_size = (depth_test.shape[1], depth_test.shape[0])

    # Render depth images of the model in the estimated and the ground truth pose
    depth_est = renderer.render(model, im_size, K, pose_est['R'], pose_est['t'],
                                clip_near=100, clip_far=10000, mode='depth')

    depth_gt = renderer.render(model, im_size, K, pose_gt['R'], pose_gt['t'],
                               clip_near=100, clip_far=10000, mode='depth')

    # Convert depth images to distance images
    dist_test = misc.depth_im_to_dist_im(depth_test, K)
    dist_gt = misc.depth_im_to_dist_im(depth_gt, K)
    dist_est = misc.depth_im_to_dist_im(depth_est, K)

    # Visibility mask of the model in the ground truth pose
    visib_gt = visibility.estimate_visib_mask_gt(dist_test, dist_gt, delta)

    # Visibility mask of the model in the estimated pose
    visib_est = visibility.estimate_visib_mask_est(dist_test, dist_est, visib_gt, delta)

    # Intersection and union of the visibility masks
    visib_inter = np.logical_and(visib_gt, visib_est)
    visib_union = np.logical_or(visib_gt, visib_est)

    # Pixel-wise matching cost
    costs = np.abs(dist_gt[visib_inter] - dist_est[visib_inter])
    costs *= (1.0 / tau)
    costs[costs > 1.0] = 1.0

    # costs_vis = np.ones(dist_gt.shape)
    # costs_vis[visib_inter] = costs
    # import matplotlib.pyplot as plt
    # plt.matshow(costs_vis)
    # plt.colorbar()
    # plt.show()

    # Visible Surface Discrepancy
    visib_union_count = visib_union.sum()
    visib_comp_count = visib_union_count - visib_inter.sum()
    if visib_union_count > 0:
        e = (costs.sum() + visib_comp_count) / visib_union_count
    else:
        e = 1.0
    return e
示例#5
0
def main():
    points = POINTS
    stack = []

    angles = [0,  np.pi * 0.5, np.pi, np.pi * 1.5]
    axies = ["x", "y", "z"]

    print render(points, 17)
示例#6
0
    def results(self):
        """ Process the scraped triples for the deed. """
        
        def cc0_filter(license_name):
            return CC0_SELECTOR.has_license(str(license_name))

        # look through all license relations to check for dual-licensing
        licenses = metadata.get_license_uri(self.subject, self.triples) or []
        if type(licenses) in (str, unicode):
            licenses = [licenses]
        cc0 = (filter(cc0_filter, licenses) or [None])[0]
        
        regist = metadata.registration(
            self.subject, self.triples, self.license_uri)

        # empty values are represented by None
        results = {
            'waiver': cc0,
            'registration': renderer.render('registration.html', regist),
            'title': metadata.get_title(self.subject, self.triples),
            'norms': metadata.get_norms(self.subject, self.triples),
            'curator': metadata.get_publisher(self.subject, self.triples),
            'creator': metadata.get_creator(self.subject, self.triples),
            'curator_title': '',
            'creator_title': '',
            'curator_literal': False,
            'creator_literal': False,
            }

        results['curator_title'] = metadata.get_title(results['curator'], self.triples) or \
                                   metadata.get_name(results['curator'], self.triples)
        results['creator_title'] = metadata.get_title(results['creator'], self.triples) or \
                                   metadata.get_name(results['creator'], self.triples)
        
        if results['curator'] and not \
               (urlparse(results['curator']).scheme and \
                urlparse(results['curator']).netloc):
            results['curator_literal'] = True
        
        if results['creator'] and  not \
               (urlparse(results['creator']).scheme and \
                urlparse(results['creator']).netloc):
            results['creator_literal'] = True
        
        # escape and strip whitespaces
        for k,v in results.items():
            if type(v) in (str, unicode):
                results[k] = ' '.join(''.join(cgi.escape(v).split('\\n')).split())

        results['marking'] = renderer.render(
            'pd_marking.html',
            dict(results,
                 work=self.subject,
                 mark_uri=self.cclicense.uri,
                 mark_title=self.cclicense.title(self.lang)))
        
        return results
示例#7
0
 def _render_statuses(self):
     db_data = self.db.get_all_status()
     if db_data:
         data = []
         print('开始读取{0}的消息列表数据...'.format(self.target_id))
         for dt in db_data:
             data.append(json.loads(dt['data']))
         fileOut = os.path.join(self.output, self.target_id)
         print('开始导出{0}的消息列表为Html/Markdown/Txt...'.format(self.target_id))
         renderer.render(data, fileOut)
         print('已导出文件', fileOut + '.html|.md|.txt')
示例#8
0
def render(cloth, clothFile):
    layers.showOnlyLayer(0)
    layers.showLayersOfObject(cloth, True)

    bodyMasks.hideAllObjects(True)
    bodyMasks.hideObject("Gracz", False)
    bodyMasks.hideObject(cloth, False)

    bodyMasks.makePlayerMasked(True)
    renderer.render(cloth)
    bodyMasks.makePlayerMasked(False)
    renderer.merge(clothFile)
示例#9
0
 def _render_statuses(self):
     db_data = self.db.get_all_status()
     if db_data:
         data = []
         print('开始读取{0}的消息列表数据...'.format(self.target_id))
         for dt in db_data:
             data.append(json.loads(dt['data']))
         fileOut = os.path.join(
             self.output, self.target_id)
         print('开始导出{0}的消息列表为Html/Markdown/Txt...'.format(self.target_id))
         renderer.render(data, fileOut)
         print('已导出文件', fileOut+'.html|.md|.txt')
示例#10
0
def generate_single_image(config,outdir):
    orig_dir = os.getcwd()
    os.chdir(os.path.join(os.environ['HOME'] , 'render_wd'))
    tmp = tempfile.mkdtemp()
    renderer.render(tmp,[config])
    imagefile = [os.path.join(tmp,x) for x in os.listdir(tmp) if x.endswith('.tif')][0]
    os.chdir(orig_dir)
	
    image_string = open(imagefile).read()
		
    outfile = os.path.join(outdir,config['model_params'][0]['model_id'] + '.tif')
    F = open(outfile,'w')
    F.write(image_string)
    F.close()
示例#11
0
def build_schema_file(schema, properties):

    _vars = []

    for _property in properties:

        _type = properties[_property]['type']
        java_type = _openapi_type_to_java(_type)

        entry = {"java_type": java_type, "property_name": _property}

        _vars.append(entry)

    renderer.render(schema, schema_imports(), _vars)
示例#12
0
def realizer(fileName):
    outputFile = fileName + ".json"
    realizerLPName = fileName + "Sketch.lp"
    realOutJSON = fileName + "Real.json"

    buildLP(outputFile, realizerLPName)
    print "Start Realizer Clingo call"
    subprocess.call("clingo Realizer.lp slopeRealizer.lp RealizerGlue.lp " +
                    realizerLPName +
                    " --opt-strategy=usc,0 --parallel-mode=4 --outf=2 > " +
                    realOutJSON + " & exit 0",
                    shell=True)
    print "Clingo finished"
    parseList = parse(realOutJSON)
    renderer.render(parseList, fileName)
示例#13
0
  def POST(self):
    you = require_you()
    params = web.input(name='')

    unique = True
    name = params['name']
    if name and name != you.get('name',None):
      slug = slugify(name)
      for row in dbview.users(db, startkey=slug, endkey=slug):
        if slug == row.key:
          unique = False
          break
    
      if unique:
        you['name'] = name
        you['slug'] = slug
    elif not name and 'name' in you:
      # blanking your name makes you anonymous, and makes your page inaccessible
      del you['name']
      del you['slug']

    db[you.id] = you

    if unique:
      web.redirect('/')
    else:
      return render('settings', errors="Sorry, that name's taken!", you=you)
示例#14
0
	def default(self, *args, **kwargs):
		req = cherrypy.request
		resp = cherrypy.response
		print args
		print
		status = 200
		try:
			if req.method == 'GET':
				obj = self.__st.get(args)
			if req.method == 'POST':
				obj = self.__st.post(args)
				status = 201
			if req.method == 'PUT':
				obj = self.__st.put(args)
			if req.method == 'DELETE':
				self.__st.delete(args)
				obj = None
				status = 204
		except fmwk.HTTPException as e:
			# TODO: return a body describing the error too
			raise cherrypy.HTTPError(e.httpCode)
		except KeyError:
			raise cherrypy.HTTPError(404)
		except NotImplementedError:
			# To play safe
			raise cherrypy.HTTPError(405)
		resp.headers['Content-Type'] = 'application/json'
		resp.status = status
		if obj is not None:
			body = renderer.render(obj)
			ret = json.dumps(body)
		else:
			ret = ''
		return ret
示例#15
0
def statistik_func():
    try:
        from database import Campaign, DataSet, get_campaign_and_data
        from plotting import alldata, operating_hours, statistics
        from renderer import render

        req_pth = os.path.join(os.path.expanduser("~"), "statistik.html")
        #req_pth = os.path.join("/tmp", "statistik.html")
        if os.path.isfile(req_pth):
            #return app.send_static_file(req_pth)
            with open(req_pth, 'r') as fle:
                return fle.read()

        ca, ds_s = get_campaign_and_data(
            se, "Ventilation i faelleskoekkenet 2017")

        js_resources, css_resources, plot_script, plot_divs = statistics(ds_s)

        page_title = ca.name
        page_header = ca.name
        page_text = "Desc"

        html = render(page_title, page_header, page_text, js_resources,
                      css_resources, plot_script, plot_divs)

        import io
        with io.open(req_pth, mode='w', encoding='utf-8') as f:
            f.write(html)
        return html

    except Exception as e:
        return str(e)
示例#16
0
def play_game(agent, render=False):
    game_board = Board()
    reward = 0
    while True:
        _, a_play = agent.get_action(game_board.as_state(),
                                     learning=True,
                                     printing=False)
        game_end, r = game_board.make_move(*a_play)
        reward += r
        if render:
            print(a_play)
            renderer.render(game_board)
        if game_end:
            if render:
                print("Total game reward:", reward)
            return reward
示例#17
0
    def on_get(self, req, resp):

        resp.status = falcon.HTTP_200

        headers.html(resp)

        resp.body = renderer.render("settings.html", {})
示例#18
0
文件: view.py 项目: bekbolot228/decor
def contact_handler(request, conn, match=True):
    template = "contacts.html"
    content = render(template)
    resp = """\
    HTTP/1.1 200 OK

    {0}
    """.format(content)
    send_response(resp, conn, match)
示例#19
0
def about_handler(request, conn, match=True, method=None):
    template = 'about.html'
    content = render(template)
    resp = """\
	HTTP/1.1 200 OK

	{}
	""".format(content)

    send_response(resp, conn, match)
示例#20
0
def translit_handler(request, conn, match=True, data={}):
    template = "translit.html"
    abc = render(template)
    resp = """\
    HTTP/1.1 200 OK

    {0}
    """.format(abc)

    send_response(resp, conn, match)
示例#21
0
def about_handler(request, conn, match=True, data={}):
    template = "about.html"
    abc = render(template)
    resp = """\
    HTTP/1.1 200 OK

    {0}
    """.format(abc)
    # write_to_db(match,data)
    send_response(resp, conn, match)
示例#22
0
def translate_handler(request, conn, match=True, data={}):
    template = "translate.html"
    cont = render(template)
    resp = """\
    HTTP/1.1 200 OK

    {0}
    """.format(cont)
    # write_to_db(match, data)
    send_response(resp, conn, match)
示例#23
0
def about_handler(request, conn, match=True, data={}):
    template = "about.html"
    abc = render(template, {'this_is_variable': 'Бул өзгөрмөнүн ордуна барат'})
    resp = """\
    HTTP/1.1 200 OK

    {0}
    """.format(abc)

    send_response(resp, conn, match)
示例#24
0
文件: main.py 项目: lksnmnn/chevron
def main(template, data={}, **kwargs):
    with open(template, 'r') as template_file:
        if data != {}:
            data_file = open(data, 'r')
            data = json.load(data_file)
            data_file.close()

        args = {'template': template_file, 'data': data}

        args.update(kwargs)
        return render(**args)
示例#25
0
	def on_get(self, req, resp):
		current_user = users.get_current_user

		if current_user:
			raise falcon.redirects.HTTPFound('/home')

		resp.status = falcon.HTTP_200

		headers.html(resp)
		
		resp.body = renderer.render("index.html", {})
示例#26
0
def main(template, data={}, **kwargs):
    with io.open(template, 'r', encoding='utf-8') as template_file:
        if data != {}:
            data_file = io.open(data, 'r', encoding='utf-8')
            data = yaml.load(data_file, Loader=yaml.SafeLoader)
            data_file.close()

        args = {'template': template_file, 'data': data}

        args.update(kwargs)
        return render(**args)
示例#27
0
def contact_handler(request, conn, match=True, data={}):
    template = "contacts.html"
    content = render(template)
    resp = """\
    HTTP/1.1 200 OK

    {0}
    """.format(content)
    write_to_db(match, data)
    # translit(data,)
    send_response(resp, conn, match)
示例#28
0
def main(template, data={}, **kwargs):
    with io.open(template, 'r', encoding='utf-8') as template_file:
        if data != {}:
            data_file = io.open(data, 'r', encoding='utf-8')
            data = json.load(data_file)
            data_file.close()
            data['DOT_KEY'] = DOT_KEY
        args = {'template': template_file, 'data': data}

        args.update(kwargs)
        return render(**args)
示例#29
0
def main(template, data=None, **kwargs):
    with io.open(template, 'r', encoding='utf-8') as template_file:
        if data is not None:
            with io.open(data, 'r', encoding='utf-8') as data_file:
                data = json.load(data_file)
        else:
            data = {}

        args = {'template': template_file, 'data': data}

        args.update(kwargs)
        return render(**args)
示例#30
0
	def on_get(self, req, resp, collection_id):
		resp.status = falcon.HTTP_200

		headers.html(resp)

		current_user = users.get_current_user()

		template_data = {
			'collection': repositories.collections.read(current_user, collection_id)
		}
		
		resp.body = renderer.render("collections/view.html", template_data)
示例#31
0
	def on_get(self, request, response):
		user = users.get_current_user()

		collections = [repositories.collections.to_map(c) for c in repositories.collections.all_collections(user, sort=True)]

		template_data = {
			"collections" : collections,
		}

		headers.html(response)
		response.status = falcon.HTTP_200
		response.body = renderer.render("collections/list.html", template_data)
示例#32
0
    def on_get(self, req, resp, collection_id):
        resp.status = falcon.HTTP_200

        headers.html(resp)

        current_user = users.get_current_user()

        template_data = {
            'collection':
            repositories.collections.read(current_user, collection_id)
        }

        resp.body = renderer.render("collections/view.html", template_data)
示例#33
0
def aws_func(event, context):
    events = [Event(data) for data in get_latest_events_raw()]
    events = filter(lambda e: e.is_active(), events)
    events = events[::-1]

    if len(events) > 0:
        main_event = events.pop(0)
        main_event.fetch_full_picture()
    else:
        main_event = None

    html = render('event.html', main_event=main_event, rest_events=events)
    return {'html': html}
示例#34
0
	def render(self, R, t):
		ren, canvas = renderer.render(self.model, (960, 720), self.K, R, t,surf_color=(1,1,1,1), bg_color=(0, 0, 0, 0), mode='rgb+depth')
		self.canvas = canvas
		ren_rgb, ren_depth = ren
		yz_flip = np.eye(4, dtype=np.float32)
		yz_flip[1, 1], yz_flip[2, 2] = -1, -1

		mat_world2camera = np.dot(yz_flip, canvas.mat_view.T)
		mat_camera2world = np.linalg.inv(mat_world2camera)

		mat_rotation = mat_world2camera[:3, :3]
		vec_translation = mat_world2camera[:3, 3].reshape([3, 1])
		return ren_rgb, ren_depth, mat_rotation, vec_translation
示例#35
0
def main(template, data={}, **kwargs):
    with io.open(template, 'r', encoding='utf-8') as template_file:
        if data != {}:
            data_file = io.open(data, 'r', encoding='utf-8')
            data = json.load(data_file)
            data_file.close()

        args = {
            'template': template_file,
            'data': data
        }

        args.update(kwargs)
        return render(**args)
    def _serve_request(self, resource, start_response, query):
        output_format = query.get('format', [self.DEFAULT_OUTPUT_FORMAT])[0]
        renderer = self.RENDERERS[output_format]

        nb = self.nbreader.reads(open(resource).read())
        
        status = "200 OK"        
        response = renderer.render(nb)
        
        headers = [("Content-Type", self.CONTENT_TYPE[output_format]),
                   ("Content-Length", str(len(response)))]
        
        start_response(status, headers)
        return [response]
示例#37
0
def main(template, data=None, **kwargs):
    with io.open(template, "r", encoding="utf-8") as template_file:
        yaml_loader = kwargs.pop("yaml_loader", None) or "SafeLoader"

        if data is not None:
            with io.open(data, "r", encoding="utf-8") as data_file:
                data = _load_data(data_file, yaml_loader)
        else:
            data = {}

        args = {"template": template_file, "data": data}

        args.update(kwargs)
        return render(**args)
示例#38
0
 def results(self):
     """ Interprets the scraped data for its significance to a deed """
     # returns dictionaries with values to CCREL triples
     attrib = metadata.attribution(self.subject, self.triples)
     regist = metadata.registration(self.subject, self.triples, self.license_uri) 
     mPerms = metadata.more_permissions(self.subject, self.triples)
     
     # check if a dc:title exists, if there is a title, it will replace
     # any place where "this work" would normally appear in the deed popups
     title = metadata.get_title(self.subject, self.triples)
     
     results = {
         'attribution': {
             'details': renderer.render(
                 'attribution_details.html', {
                     'subject': self.subject,
                     'license': self.cclicense,
                     'title':title,
                     'attributionName': attrib['attributionName'],
                     'attributionURL': attrib['attributionURL'],
                     }),
             'marking': renderer.render(
                 'attribution_marking.html', {
                     'subject': self.subject,
                     'license': self.cclicense,
                     'title': title,
                     'attributionName': attrib['attributionName'],
                     'attributionURL': attrib['attributionURL'],
                     }),
             },
         'registration':     renderer.render('registration.html', regist),
         'more_permissions': renderer.render('more_permissions.html',
                                             dict(subject=self.subject, **mPerms)),
         
         }
     
     return results
示例#39
0
    def on_get(self, request, response):
        user = users.get_current_user()

        collections = [
            repositories.collections.to_map(c)
            for c in repositories.collections.all_collections(user, sort=True)
        ]

        template_data = {
            "collections": collections,
        }

        headers.html(response)
        response.status = falcon.HTTP_200
        response.body = renderer.render("collections/list.html", template_data)
示例#40
0
def main(template, data=None, **kwargs):
    with io.open(template, 'r', encoding='utf-8') as template_file:
        yaml_loader = kwargs.pop('yaml_loader', None) or 'SafeLoader'

        if data is not None:
            with io.open(data, 'r', encoding='utf-8') as data_file:
                data = _load_data(data_file, yaml_loader)
        else:
            data = {}

        args = {
            'template': template_file,
            'data': data
        }

        args.update(kwargs)
        return render(**args)
示例#41
0
def main_view(env, method):
    template = 'index.html'
    if method == "POST":
        try:
            request_body_size = int(env.get('CONTENT_LENGTH', 0))
        except (ValueError):
            request_body_size = 0
        request_body = env['wsgi.input'].read(request_body_size)
        data = parse_qs(request_body)

        link = data[b'link'][0].decode()
        email = data[b'email'][0].decode()
        create_query(link, email)
        send_link_mail.delay(email, link)

    response = render(template).encode('utf-8')
    return response
示例#42
0
    def on_get(self, req, response, public_id):

        collection = repositories.collections.read_public_collection(public_id)

        if collection == None or not collection.public:
            headers.text(response)
            response.status = falcon.HTTP_404
            response.body = "Unknown collection"
            return

        template_data = {
            'collection': collection,
        }

        headers.html(response)
        response.status = falcon.HTTP_200
        response.body = renderer.render("collections/public/view.html",
                                        template_data)
示例#43
0
	def on_get(self, req, response, public_id):

		collection = repositories.collections.read_public_collection(public_id)

		if collection == None or not collection.public:
			headers.text(response)
			response.status = falcon.HTTP_404
			response.body = "Unknown collection"
			return


		template_data = {
			'collection': collection,
		}

		headers.html(response)
		response.status = falcon.HTTP_200
		response.body = renderer.render("collections/public/view.html", template_data)
示例#44
0
文件: links.py 项目: rrees/link-drop
	def on_get(self, request, response, collection_id, link_index):

		link_idx = int(link_index)

		response.status = falcon.HTTP_200

		headers.html(response)

		current_user = users.get_current_user()

		collection = repositories.collections.read(current_user, collection_id)
		link = collection.links[link_idx]

		template_data = {
			'collection': collection,
			'link': link,
			'link_index': link_idx,
		}
		
		response.body = renderer.render("collections/links/view.html", template_data)
示例#45
0
    return tuple(int(i*100) for i in hsv_to_rgb(h, 0.8, 1))


@progress(iterations=MAX_X * MAX_Y)
def basic_mandelbrot(x, y):
    """
    Calculate and return the RGB colour for a given (x, y) pixel.
    :param x: The X coordinate of the pixel.
    :param y: The Y coordinate of the pixel.
    :return: A tuple (R,G,B) of values 0-255.
    """
    # Scale X and Y to the viewport bounded by (X1, Y1) and (X2, Y2).
    x = scaled(x, 0, MAX_Y, X1, X2)
    y = scaled(y, 0, MAX_Y, Y1, Y2)

    # Count the number of iterations to escape an arbitrary "bound".
    i = count_its(x, y, MAX_ITERATION)

    # Return a color based on this escape time.
    if i == MAX_ITERATION:
        return 0, 0, 0
    return color(i)


if __name__ == "__main__":
    from renderer import render
    filename = "mandelbrot.png"
    if "-o" in sys.argv:
        filename = sys.argv[-1]
    render(basic_mandelbrot, filename)
示例#46
0
 def GET(self):
   return render("settings", you=require_you())
示例#47
0
 def render(self):
     renderer.render()
     pygame.display.update()
import boto
import renderer


# would be nice if the following stuff were encapsulated in the library
# e.g. ls_models + ls_backgrounds

conn = boto.connect_s3()

bbucket = conn.get_bucket('dicarlocox-backgrounds')    
cache_bucket = conn.get_bucket('dicarlocox-3dmodels-renderedimages')
model_bucket = conn.get_bucket('dicarlocox-3dmodels-v1')

bg_list = [x.name for x in bbucket.list()]
model_list = [x.name for x in model_bucket.list()]
model_id_list = [ x.rstrip('.tar.gz') for x in model_list]


# this is where the 'real' stuff starts

models = []
models.append(  {   'bg_id' : bg_list[0],
                    'model_params' :
                        [ {'model_id' : model_id_list[0]} ]                         
                })

print(models)
                
renderer.render('/tmp', models)
示例#49
0
文件: game.py 项目: hedayaty/snake
def mainloop ():
	global items, gameover, clock, digplace
	global blocked, playerheads
	digit = 1
	clock = pygame.time.Clock()
	
	blocked = set(board.obstacles)
#	playerbodies = []
	for player in players:
		player.start ()

	# TODO: Trow more items on the board!
	digplace = place(str(digit))
	gameover = False
	playerheads = []

	while 1:
		clock.tick(10)

		# Render the screen
		renderer.render()

		for event in pygame.event.get():
			if event.type == pygame.QUIT: 
				return
			if event.type == pygame.KEYDOWN:
				if event.key == pygame.K_ESCAPE:
					return
				for player in players:
					player.usekey (event.key)

		if gameover:
			continue

		for player in players:	
			if player.dev == "ai" and player.playing:
				player.aimove()
			elif player.dev == "net":
				if player.playing:
					network.getkey (player)
				network.sendinfo (player, players, items)

		for player in players:
			if player.playing and player.dead == 0:
				blocked.add(player.gethead())
		playerheads = []
		dead = set()
		for player in players:
			if not player.playing:
				continue
			head = player.go()
			if head != None:
				playerheads.append(head) # Use this to detect head-to-head
			# Check if hit the wall or ther players
			if head in blocked:
				dead.add(player)
				if nlpr:
					for other in players:
						if other != player:
							if head in other.body:
								other.grow (len(player.body))
								other.score += len(player.body)

			# Check if hit any items
			elif items.has_key(head) :
				# TODO: Assumed items are only numbers
				del items[head]
				player.score += 10 * digit
				#player.grow(digit * 4)
				player.grow(digit * 10)
				digit += 1
				if digit < 10 or not numbersend:
					if digit == 10:
						digit = random.randint(1,6)
					digplace = place (str(digit))
				else:
					gameover = True
		# Detect head-to-head
		for player1 in players:
			if player1.playing and playerheads.count(player1.gethead()) > 1:
				dead.add(player1)

		# Now see who is dead	
		for player in list(dead):
			if player.die():
				if not cont:
					gameover = True

		if remplayers == 0:
			gameover = True
		
		if dead:
			if digit > 5:
				digit -= 4
			else:
				digit = 1
			items[digplace]["type"] = str(digit)
						
		# keep track of player bodies as obstacles as well
		#playerbodies = reduce(operator.add, (player.body[:] for player in players))		

		# Check for timer exppirations
		for loc in items.keys() :
			item = items[loc]
			item["timer"] -= 1
			if item["timer"] == 0 :
				type = item["type"]
				del items[loc]
				if type in otheritemtypes :
					place (random.choice(otheritemtypes))
				else: # It is number, put the same number somewhere else on the board
					digplace = place (type)
示例#50
0
文件: calculator.py 项目: Mause/haven
def do_render(possible):
    img = render(possible)

    filename = '{}.png'.format(determine_hash(possible))
    img.save(join('possibles', filename))
 def render(self,params_list):
     renderer.render(self.temp_dir,params_list,callback=self.callback)
示例#52
0
 def get(self):
     restaurants_query = Restaurant.all().order('-date')
     template_values = {
         'restaurants': restaurants_query
     }
     renderer.render(self, 'index.html', template_values)
示例#53
0
def form(name):
    form_db = config.db.get_db('')
    form_description = form_db['forms'][name]
    return renderer.render(name, form_description)