St Alfred's Hospital
[80, 0]
|
a junkyard
[81, 0]
|
the Elcomb Building
[82, 0]
|
Club Meatyard
[83, 0]
|
Mor Road
[84, 0]
|
Luffman Grove
[85, 0]
|
Club Farrel
[86, 0]
|
St Dunstan's Church
[87, 0]
|
Nash Park
[88, 0]
|
Barlow Avenue
[89, 0]
|
Underhill Square
[80, 1]
|
Moberly Library
[81, 1]
|
the Otero Building
[82, 1]
|
the Higgdon Museum
[83, 1]
|
a junkyard
[84, 1]
|
Cull Avenue Police Dept
[85, 1]
|
Tikanoff Park
[86, 1]
|
Mallard Towers
[87, 1]
|
a cemetery
[88, 1]
|
a junkyard
[89, 1]
|
Cowgall Avenue
[80, 2]
|
Lahey Towers
[81, 2]
|
Meetcham Drive Fire Station
[82, 2]
|
wasteland
[83, 2]
|
Devenish Avenue
[84, 2]
|
Sawtell Road
[85, 2]
|
Tinkler Plaza School
[86, 2]
|
the Floyd Monument
[87, 2]
|
a factory
[88, 2]
|
Attrell Avenue
[89, 2]
|
Darbey Cinema
[80, 3]
|
Hindmarsh Row Police Dept
[81, 3]
|
Standfast Plaza
[82, 3]
|
a junkyard
[83, 3]
|
Billinghurst Place Police Dept
[84, 3]
|
St Matheos's Church
[85, 3]
|
the Brain Museum
[86, 3]
|
the Garard Building
[87, 3]
|
Bargery Square
[88, 3]
|
the Wallbutton Building
[89, 3]
|
Thorp Towers
[80, 4]
|
the Bizzell Building
[81, 4]
|
Pask Walk
[82, 4]
|
wasteland
[83, 4]
|
a junkyard
[84, 4]
|
Lockwood Walk
[85, 4]
|
wasteland
[86, 4]
|
Salter Grove Railway Station
[87, 4]
|
Orome Avenue
[88, 4]
|
the Carlyle Building
[89, 4]
|
Wilmut Crescent
[80, 5]
|
St Alban's Hospital
[81, 5]
|
Milne Park
[82, 5]
|
the Devonshire Building
[83, 5]
|
a carpark
[84, 5]
|
the Guiday Monument
[85, 5]
|
a factory
[86, 5]
|
St Mark's Hospital
[87, 5]
|
a factory
[88, 5]
|
Gable Walk Fire Station
[89, 5]
|
St Helier's Hospital
[80, 6]
|
the Uglow Building
[81, 6]
|
the Upshall Monument
[82, 6]
|
the Parks Building
[83, 6]
|
Lindell Grove
[84, 6]
|
the Anstruther Building
[85, 6]
|
the Ablett Arms
[86, 6]
|
Sealy Grove
[87, 6]
|
the Cabble Monument
[88, 6]
|
the Starr Building
[89, 6]
|
Amatt Boulevard
[80, 7]
|
Club Hagan
[81, 7]
|
wasteland
[82, 7]
|
Wickett Place
[83, 7]
|
a factory
[84, 7]
|
Tompsett Library
[85, 7]
|
Spirrell Street
[86, 7]
|
Craske Park
[87, 7]
|
Fitzgerald Lane
[88, 7]
|
the Spenser Museum
[89, 7]
|
the Edridge Museum
[80, 8]
|
a carpark
[81, 8]
|
Woodland Cinema
[82, 8]
|
Club Knyps
[83, 8]
|
Woodman Grove
[84, 8]
|
Club Greene
[85, 8]
|
a factory
[86, 8]
|
the Rendell Monument
[87, 8]
|
Marcellus General Hospital
[88, 8]
|
a factory
[89, 8]
|
Attewill Way
[80, 9]
|
the Robotier Building
[81, 9]
|
the Fletcher Motel
[82, 9]
|
wasteland
[83, 9]
|
Pownall Cinema
[84, 9]
|
Doswell Lane
[85, 9]
|
Nichols Drive
[86, 9]
|
Clipper Grove Railway Station
[87, 9]
|
Nulty Auto Repair
[88, 9]
|
Brittan Walk
[89, 9]
|
|
Menu
City Map
Find Location
Route Finder
World View
Map Mirror
|


Chapter 12 Calculating class area from raster
12.1 Simple area and area fraction calculations on a classified raster
For this tutorial you will need to load the following packages:
library(raster)
library(sf)
library(tidyverse)
You will often come across the task of extracting the area each of your raster classes occupies within your entire raster area. There is a simple way of doing this using raster
and dplyr
. The output will be a comprehensive table. First let’s create some dummy data to work with:
12.1.1 Creating dummy data
raster(ncol=100, nrow=100, xmn=-10000, xmx=10000, ymn=-10000, ymx=10000)
x <-
res(x)<-100 # we are using a resolution of 100 x 100 so that each pixel is 1ha in size
#populate the raster with values
values(x)<-base::sample(5, ncell(x), replace = T, prob = c(10,30,20,5,35))
plot(x)
Our raster now contains 5 classes that could e.g. be land-use types such as forest, infrastructure or pasture. We additionally gave each class a probability of occurrence so that we can double check of our calculated areas are correct. In total, our raster x
has 4^{4} cells.
12.1.2 Preparing the raster for area calculation
To get area metrics, we need to transform the raster into a data frame:
%>%as.data.frame(xy = T, na.rm = T) rast_df<-x
To count each pixel, we can assign an extra column to this dataframe with an ID
1
to be able to tally all cells. Additionally, we are extracting the resolution of our raster as a variable to our environment to later calculate the area.
$ID<-1
rast_df
res(x)[1]
reso<-
head(rast_df)
## x y layer ID
## 1 -9950 9950 3 1
## 2 -9850 9950 5 1
## 3 -9750 9950 4 1
## 4 -9650 9950 4 1
## 5 -9550 9950 2 1
## 6 -9450 9950 2 1
The layer
column contains the class each pixel was assigned to. This will be universal for any raster you put in. ID
is the same for each row, this is only needed in the next step.
12.1.3 Compiling a comprehensive table
%>%group_by(layer)%>%
area<-rast_df summarise(pixelsum = sum(ID), area_ha = (pixelsum*reso^2)/10000)%>%
mutate(sumA = sum(pixelsum), per = 100*pixelsum/sumA)%>%
rename(class = layer)
## `summarise()` ungrouping output (override with `.groups` argument)
area
## # A tibble: 5 x 5
## class pixelsum area_ha sumA per
## <int> <dbl> <dbl> <dbl> <dbl>
## 1 1 4020 4020 40000 10.0
## 2 2 11978 11978 40000 29.9
## 3 3 7951 7951 40000 19.9
## 4 4 1930 1930 40000 4.82
## 5 5 14121 14121 40000 35.3
And there we go. Each class has it’s pixelsum
calculated, then using the sum we can calculate the area in ha (or else, here you can alternate the code). In this case the pixel sum matches our area_ha
because one pixel is already of size 1 ha. We can change the code to e.g. calculate area_km2
.
%>%group_by(layer)%>%
area_km2<-rast_df summarise(pixelsum = sum(ID), area_km2 = pixelsum/100)%>%
mutate(sumA = sum(pixelsum), per = 100*pixelsum/sumA)%>%
rename(class = layer)
## `summarise()` ungrouping output (override with `.groups` argument)
area_km2
## # A tibble: 5 x 5
## class pixelsum area_km2 sumA per
## <int> <dbl> <dbl> <dbl> <dbl>
## 1 1 4020 40.2 40000 10.0
## 2 2 11978 120. 40000 29.9
## 3 3 7951 79.5 40000 19.9
## 4 4 1930 19.3 40000 4.82
## 5 5 14121 141. 40000 35.3
Next we calculate the sum of all pixels (sumA
) using mutate()
to get the total raster area. This should in this case be the same as ncell(x)
(40000). To derive the percentage of the entire each class occupies, we just need to divide the pixelsum
of each class by the total sum and multiply by 100. This should match our probabilities we assigned for each class when filling the raster with values:
$per == summary(as.factor(values(x)))/400 area_km2
## 1 2 3 4 5
## TRUE TRUE TRUE TRUE TRUE
Enjoy trying it out on your own raster with some actual class ares!


|
Noise++
|
#include <NoiseThreadedPipeline.h>
Public Member Functions | |
| ThreadedPipeline (size_t numberOfThreads) | |
| virtual void | executeJobs () |
| virtual void | addJob (PipelineJob *job) |
| virtual | ~ThreadedPipeline () |
| NOISEPP_INLINE Element * | getElement (ElementID i) const |
| ElementID | getElementCount () const |
| void | setSeed (int seed) |
| int | getSeed () const |
| Cache * | createCache () const |
| NOISEPP_INLINE void | cleanCache (Cache *cache) const |
| void | freeCache (Cache *cache) const |
| ElementID | addElement (const Module *parent, Element *element) |
| ElementID | getElementID (const Module *module) const |
| ElementID | getElementID (const Module &module) const |
| Element * | getElementPtr (const Module *module) const |
| Element * | getElementPtr (const Module &module) const |
Protected Attributes | |
| std::vector< Element * > | mElements |
| std::map< const Module *, ElementID > | mElementIDs |
| PipelineJobQueue | mJobs |
In Noise++ the noise generation process is different to other libraries. Instead of calling a noise generation function from your module instances directly, you add your modules to a so called Pipeline. The pipeline internally creates pipeline elements from the specified noise modules. Then you either create a cache and start generating or add jobs to the pipeline to run them in several threads.
|
inline |
Constructor.
| numberOfThreads | The number of threads |
|
inlineinherited |
Adds the specified element to the pipeline.
This is used internally by modules.
|
inlinevirtual |
Adds a job to the queue.
Reimplemented from noisepp::Pipeline< Element >.
|
inlineinherited |
Cleans the specified cache.
You should call this each time you use it.
|
inlineinherited |
Creates a clean cache.
You need only one cache per pipeline and thread. You have to call this AFTER adding your modules or there will be memory acces errors. Don't forget to free the cache.
|
inlineinherited |
Returns the ID of the element belonging to the specified module or ELEMENTID_INVALID if not found.
|
inlineinherited |
Returns a pointer to the element belonging to the specified module or NULL if not found.
|
inlineinherited |
Sets the master seed value.
You have to call this BEFORE adding your modules or this will have no effect.


American Gods Season 3 Casts Danny Trejo, Wale
by Sundi RoseAdditional casting for Season 3 of American Gods is steadily ramping up, with Danny Trejo and Wale being the latest to join the Starz series.
According to EW, Trejo will guest-star as one of the many forms of Mr. World as the war between the Old Gods and the New continues to rage on. Meanwhile, rapper Wale will play an Orisha named Chango, who will prove very important to Shadow as a guide to his past.
Also joining the Season 3 cast is Saturday Night Live alum Julia Sweeney, who'll play Ann-Marie Hinzelmann and welcome the gods as they head to a place that is extremely important in the Neil Gaiman universe, Lakeside, Wisconsin. There, she recruits Lakeside’s Chief of Police Chad Mulligan (Eric Johnson).
All three of these new cast members will join fellow series newcomer Marilyn Manson, who will play Johan Wengren, the lead singer of a band called Blood Death.
Based on the Neil Gaiman novel of the same name, American Gods stars Ricky Whittle, Emily Browning, Pablo Schreiber, Crispin Glover, Bruce Langley, Yetide Badaki, Ian McShane, Mousa Kraish, Kahyun Kim, Demore Barnes, Orlando Jones and Chris Obi. Season 3 began filming on Oct. 9 and will premiere some time next year.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2TVhttps://www.cbr.com/category/tv/ListItem3TV Newshttps://www.cbr.com/category/tv/news-tv/ListItem4American Gods Season 3 Casts Danny Trejo, Walehttps://www.cbr.com/american-gods-danny-trejo-wale-season-3/


what do we bring to the table
We are proud of our creative ability, we strive to think outside the box and do our best to create new things that will get our customers noticed.
Our team is composed of members that have the highest level of passion for our work. If we didn't strive to build a team with the highest passion we would not be able to serve our customers to the standard that they deserve.
Our attention to detail is beyond compare as we make sure every aspect of your project is exactly what you are looking for.
Characters - Your target audience will become the characters in this story.
Setting - What is the perfect setting for your story, let us sit down and build the background for you
Plot - Let's build a plan to help your business be successful
Conflict - Let's make you stand out above the competition
Resolution - The final product will get you noticed and remembered
One of Indianas newest digital marketing and creative design companies.
At JK Productins we are
C.R.E.A.T.I.V.E.
Courage - We have the courage to think outside the box to help you get noticed
Reputation - We have built a great reputation with our clients and intend to keep it that way
Evolution - We are constantly evolving with the every growing technology to help us serve you better
Attention - We pay very close attention to every detail
Talent - We have some of the best upcoming talent in the industry
Ideas - We never stop thinking of new ideas
Vision - We will turn your vision into reality
Execution - We will execute your your project with precision and accuracy
Ready to Create Something Amazing? LET'S DO IT!


Activity List
- Ability to create Mash-ups: This activity will allow the DJ/user to play two
songs at a time. A lot of DJ’s today are creating “mash-ups,” which means taking two songs and
playing one over the other, creating a new sound. This activity will allow us to do that.
It will also allow the DJ/user to have a song “on-deck” for when the first song finishes.
The DJ can then fade out from the first and into the second song, making the transition smoother.
- Music Cloud: This activity will allow the DJ/user access to any song possible.
This music cloud is a database similar to Youtube, where DJ’s can stream songs not in their own
library, into their interface. It allows the user to be able to meet every single request by the
audience if he or she so chooses. DJ’s today only play what is in their library, but if an audience
member has a request not in the DJ’s library, he or she can get the song.
- Change the Volume: This is a very standard activity that is a must-have in an
interface. Changing the volume allows the user to make each song louder or quieter depending on
the audience’s preference.
- Changing the Pitch: This is also a very standard activity on a DJ interface.
Changing the pitch or frequency allows the user to “play” with the song. He can speed the song
up, or slow it down for a nice effect.
- Song Information: We think this feature would be valuable since a DJ picks
his next song based on several very tangible properties, along with a few intangible. We thought
it would be nice to give the DJ information they need, such as Song, Artist, Album, BPM, Genre,
Key, and a few customizeable attributes.
- Automation: Giving the DJ a few macro-like actions could speed up their workflow,
as well as freeing up their mind for more creative endevours.
- Sound Effects: Many of our interviewees said that effects such as hits, builds,
and fades were essential to grabbing the audiences attention. We plan to include a set, as well as
having the ability to add custom sounds. The interface should be quick and spur-of-the-moment.
- Equalizer: Along the same rationale as Sound Effects, the ability to control a
song's frequency range also allows for grabbing the audience's attention. It is a popular effect
throughout the industry.
- Pan Control: Independant control of a song's panning is also a popular effect
used to grab the audience's attention. This will be a dial-like widget that controls how much sound
is in each (L/R) speaker.
- Smart Library: If we're going to detect BPM and pitch, it would be wise to keep
this information in the library for later use. The library will be sortable by any of these parameters.
- Song Queuing: This feature will give the DJ the option of pre-composing a list of songs
to play, thus freeing some time for himself.


Select NVG XML file (or NVG JSON):
NVG JSON according to NVG JSON specification:
new NVG(file)
NVG GeoJSON according to GeoJSON specification:
toGeoJSON()
And put it on a simple Open Layers map:


Bulma is a modern CSS framework from @jgthms, based on Flexbox. Using Bulma, we can describe our website's design using just classes. ᕕ( ᐛ )ᕗ
Flexbox is a CSS spec that makes sectioning and aligning more natural. We don't need to know Flexbox but it's how Bulma works behind-the-scenes. ⦤(^ー^)⦥
Instead of writing our CSS per-element, we can use predefined classes. With enough classes, we can describe our website design using semantics. ٩(^ᴗ^)۶


angular.module
ng
The angular.module
is a global place for creating, registering
and retrieving Angular
modules.
All modules (angular core or 3rd party) that should be available to an application must be
registered using this mechanism.
When passed two or more arguments, a new module is created. If passed only one argument, an
existing module (the name passed as the first argument to module
) is retrieved.
A module is a collection of services, directives, filters, and configuration information.
angular.module
is used to configure the $injector
.
// Create a new module var myModule = angular.module('myModule', []); // register a new service myModule.value('appName', 'MyCoolApp'); // configure existing services inside initialization blocks. myModule.config(function($locationProvider) { // Configure existing providers $locationProvider.hashPrefix('!'); });
Then you can create an injector and load your modules like this:
var injector = angular.injector(['ng', 'MyModule'])
However it's more likely that you'll just use
ngApp
or
angular.bootstrap
to simplify this process for you.
angular.module(name[, requires], configFn);
| Param | Type | Details |
|---|---|---|
| name | !string |
The name of the module to create or retrieve. |
| requires
(optional)
|
Array.<string> |
If specified then new module is being created. If unspecified then the the module is being retrieved for further configuration. |
| configFn | Function |
Optional configuration function for the module. Same as
|
| module |
new module with the |


Store and retrieve data from local storage.
When storing data, the data has to be a certain format and regardless of where you choose to store it, text is always one of the legal formats. JSON makes it possible to store JavaScript objects as text


{% extends "layouts/default.html" %} {% block title %} Blank Page {% endblock title %} {% block stylesheets %}{% endblock stylesheets %} {% block content %}
Wash Karo is a free Android-based app which aims to spread awareness among the mass regarding hygiene and sanitation practices. The application provides the latest news articles and matching WHO guidelines in the domain of WASH (Water, Sanitation and Hygiene).
In times of Search Results Web results Coronavirus Disease, our application acts as an effective healthcare intervention.
Paper: https://arxiv.org/pdf/2003.07074.pdf
Application: Download Now


Home
Things Needed
Series
Gallery
Contact
Palete Knife Portraits
Things Needed
Canvas
Painting Knives
Water (in case your paint gets thirsty)
Napkins
Painting kives
Awesome Imagination
LOTS OF PAINT!
Portrait Series
Artist Name
Painting Name
Date Completed
Loteria
Jeanette Alfaro
El Corazon
Aug. 2014
Loteria
Jeanette Alfaro
El Gallo
Aug. 2014
Loteria
Jeanette Alfaro
La Dama
Sept. 2014
Loteria
Jeanette Alfaro
La Rosa
Aug. 2016


Lagos seals off plastic company over death of worker
by The Eagle OnlineThe Lagos State Government has sealed off Multipak Nigeria Ltd., a plastic producing factory, for violation of safety rules and regulations, poor house-keeping and lack of signage, which led to the death of a worker.
The Director-General, Lagos State Safety Commission, Lanre Mojola, made this known in an interview with the News Agency of Nigeria in Lagos on Sunday.
The company is located at Plot F8, Kudirat Abiola Way, Oregun, Lagos.
Signage is a graphic design, symbols, emblems or words, used especially for identification or as a means of giving directions or warning.
According to him, the factory was sealed up following the Lagos State Government’s declaration of zero tolerance for factories and private organisations that violate safety rules and regulations.
“LASG seals off Multipak factory for violation of safety rules and regulations as well as poor house-keeping and lack of signage.
“The poor house-keeping led to the untimely death of Mr Femi Olatunde, a factory worker, who got his head stuck while operating one of the machines.
“Mr Babajide Sanwo-Olu’s administration is passionate about safety of lives and property of the citizenry.
“On no account should any factory operates without putting in place safety equipment, quality house-keeping, signage, good wiring system and a clean environment devoid of hazards to the lives of workers and visitors, ’’ Mojola said.
He, however, urged organisations and individuals to embrace best practices and international safety operations to prevent fatal incidents that endangered lives.
The LSSC boss said that safety of lives and property was collective responsibility and warned that factories that violated safety rules would be severely sanctioned.
Previous Post
Alleged arms possession: Zamfara urges police to investigate ex-governor Yari
Next Post
Army operations: Super camp concept yielding positive results – Buratai


public final class PluginStorage
extends java.lang.Object
PluginManager
is Firer
.
Alg
is the most abstract interface for all algorithms.
Every algorithm has a unique name. Every algorithm is registered in system register table and identified by its name.
Such system register table is modeled as RegisterTable
class.
Actually, plug-in manager discovers automatically all algorithms via their names at the booting time and requires PluginStorage
to add such algorithms into register tables represented by RegisterTable
classes.
After Hudup framework started, it is easy to retrieve any any algorithms by looking up algorithms in register tables from PluginStorage
.
Please pay attention that system register tables are stored in a so-called plug-in storage
which is represented by this PluginStorage
class.
Alg
interface. Alg
has five typical inherited interfaces as follows:
Recommender
.CTSManager
.DatasetParser
.ExternalQuery
.Metric
.PluginStorage
manages many RegisterTable
(s) and each RegisterTable
stores algorithms having the same type.
For examples, the internal variable recommenderReg
which is a register table manages recommendation algorithms (recommenders).
The internal variable metricReg
which is a register table manages metrics for evaluating recommenders.
PluginStorage
also manages a list of next-update algorithms. Next-update algorithm is the one which needs to be updated in next version of Hudup framework because it is not perfect, for example.
Currently, next-update algorithms are not used.| Constructor and Description |
|---|
PluginStorage() |
| Modifier and Type | Method and Description |
|---|---|
static void |
clear()
This static method clears this storage, which means that all register tables become empty.
|
static RegisterTable |
getCTSManagerReg()
This static method gets
CTSManager register. |
static RegisterTable |
getExternalQueryReg()
This static method gets
ExternalQuery register. |
static RegisterTable |
getMetricReg()
This static method gets
Metric register. |
static AlgList |
getNextUpdateList()
This static method gets list of next-update algorithms.
|
static RegisterTable |
getParserReg()
This static method gets
DatasetParser register. |
static RegisterTable |
getRecommenderReg()
This static method gets recommendation algorithm register.
|
static RegisterTableList |
getRegisterTableList()
This static method gets all register tables as a
RegisterTableList . |
static java.lang.String |
lookupAlgTypeName(java.lang.Class<? extends Alg> algClass)
Looking up the type name of specified class of algorithm.
|
static RegisterTable |
lookupTable(java.lang.Class<? extends Alg> algClass)
Looking up the register table whose algorithms have the class which is equal to specified algorithm class.
|
static RegisterTable |
lookupTable(java.lang.String algTypeName)
Looking up the register table whose name is equal to specified name
|
public static final RegisterTable getRecommenderReg()
Alg
.public static final RegisterTable getParserReg()
DatasetParser
register.DatasetParser
.public static final RegisterTable getMetricReg()
Metric
register.Metric
register.public static final RegisterTable getExternalQueryReg()
ExternalQuery
register.ExternalQuery
register.public static final RegisterTable getCTSManagerReg()
CTSManager
register.CTSManager
register.public static final AlgList getNextUpdateList()
public static final void clear()
public static final RegisterTableList getRegisterTableList()
RegisterTableList
.RegisterTableList
.public static final RegisterTable lookupTable(java.lang.Class<? extends Alg> algClass)
algClass
- specified algorithm class.RegisterTable
whose algorithms have the class which is equal to specified algorithm class.public static final RegisterTable lookupTable(java.lang.String algTypeName)
algTypeName
- specified name. This is the name implying the type of algorithm.
Recommender
(s) has name specified by the constant RECOMMENDER
.DatasetParser
(s) has name specified by the constant PARSER
.Metric
(s) has name specified by the constant METRIC
.ExternalQuery
(s) has name specified by the constant EXTERNAL_QUERY
.CTSManager
(s) has name specified by the constant CTS_MANAGER
.RegisterTable
whose name is equal to specified name.public static final java.lang.String lookupAlgTypeName(java.lang.Class<? extends Alg> algClass)
algClass
- specified class of algorithm.Recommender
(s) has type name specified by the constant RECOMMENDER
.DatasetParser
(s) has type name specified by the constant PARSER
.Metric
(s) has type name specified by the constant METRIC
.ExternalQuery
(s) has type name specified by the constant EXTERNAL_QUERY
.CTSManager
(s) has type name specified by the constant CTS_MANAGER
.


Farr, Christina. “The First Study Of Self-Driving Car Crash Rates Suggests They Are Safer.” Fast Company, Fast Company, 12 Jan. 2016, www.fastcompany.com/3055356/the-first-study-of-self-driving-car-crash-rates-suggests-they-are-safer.
Kaushik, Preetam. “Is Artificial Intelligence the Way Forward for Personal Finance?” Wired, Conde Nast, 7 Aug. 2015, www.wired.com/insights/2014/02/artificial-intelligence-way-forward-personal-finance/.
Klein, Mike. “Google's AlphaZero Destroys Stockfish In 100-Game Match.” Chess.com, Chess.com, 6 Dec. 2017, www.chess.com/news/view/google-s-alphazero-destroys-stockfish-in-100-game-match.
Knight, Will. “A New AI Algorithm Summarizes Text Amazingly Well.” MIT Technology Review, MIT Technology Review, 14 May 2017, www.technologyreview.com/s/607828/an-algorithm-summarizes-lengthy-text-surprisingly-well/.
Quora. “The Future Of Massively Open Online Courses (MOOCs).” Forbes, Forbes Magazine, 23 Mar. 2017, www.forbes.com/sites/quora/2017/03/23/the-future-of-massively-open-online-courses-moocs/#160c1f696b83.
Sagin, Erin. “What the New AdWords Ad Rank Algorithm Really Means.” WordStream, 30 Jan. 2018, www.wordstream.com/blog/ws/2013/10/24/adwords-ad-rank-algorithm.
Litman, www.aaai.org/ocs/index.php/AAAI/AAAI16/paper/view/12310.
Gaskell, Adi. “Machine Learning And The Future Of Education.” Forbes, Forbes Magazine, 7 Nov. 2016, www.forbes.com/sites/adigaskell/2016/11/04/machine-learning-and-the-future-of-education/#327d9e997693.
Hof, Robert D. “Is Artificial Intelligence Finally Coming into Its Own?” MIT Technology Review, MIT Technology Review, 29 Mar. 2016, www.technologyreview.com/s/513696/deep-learning/.
IBM. “What Is Watson.” IBM Watson, 15 Oct. 2017, www.ibm.com/watson/about/index.html.
“Mika™ It's Time to Expect More from Higher Ed Math Courseware.” Math Courseware for Higher Ed | Mika by Carnegie Learning, www.carnegielearning.com/products/software-platform/mika-learning-software/#slide02.
Momoh, Osi. “Natural Language Processing (NLP).” Investopedia, 7 Mar. 2018, www.investopedia.com/terms/n/natural-language-processing-nlp.asp.
Newnham, Danielle. “The Story Behind Siri – The Startup – Medium.” Medium, The Startup, 21 Aug. 2015, medium.com/swlh/the-story-behind-siri-fbeb109938b0.
“On 'Jeopardy!' Watson Win Is All but Trivial.” The New York Times, The New York Times, 16 Feb. 2011, www.nytimes.com/2011/02/17/science/17jeopardy-watson.html?pagewanted=all.
Sennaar, Kumba. “The Artificial Intelligence Tutor - The Current Possibilities of Smart Virtual Learning.” TechEmergence, 2 Nov. 2017, www.techemergence.com/artificial-intelligence-tutor-current-possibilities-smart-virtual-learning/.
“Your Project - Google Science Fair 2015.” Your Project - Google Science Fair, www.googlesciencefair.com/projects/en/2015/7151ae4ff6b70198aafc08fbee39127ad0913cd407d98d8b596a85c14ed57ba9.
“Program of Studies 2018-2019.” Program of Studies, 2018, www.ww-p.org/common/pages/DisplayFile.aspx?itemId=41019639.
All pictures used are either royalty free or were taken or created by the HSN TSA Webmaster team. Illustrations were created using Adobe Photoshop and Adobe Illustrator. Royalty free & copyright free icons were provided by Freepix and Iconsplace.
“Freepix.” Freepix, image.freepik.com/free-icon/nut-icon_318-84971.jpg.
“Iconsplace.” Iconsplace, www.iconsplace.com/icons/preview/white/number-3-filled-256.png.
“Iconsplace.” Iconsplace, www.iconsplace.com/icons/preview/white/number-2-filled-256.png.
“Iconsplace.” Iconsplace, www.iconsplace.com/icons/preview/white/number-1-filled-256.png.
“Iconsplace.” Iconsplace, www.iconsplace.com/icons/preview/white/number-4-filled-256.png.
All content built on top of these frameworks is the original work of the HSN TSA Webmaster team.
Sketch.js
The MIT License
Copyright (C) 2013 Justin Windle. http://soulwire.co.uk
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
BotUI.js
MIT License
Copyright (c) 2017 Moin Uddin
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Bootstrap
The MIT License (MIT)
Copyright (c) 2011-2018 Twitter, Inc.
Copyright (c) 2011-2018 The Bootstrap Authors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
jQuery
Copyright (c) JS Foundation and other contributors, https://js.foundation/
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Animsition
The MIT License (MIT)
Copyright (c) 2013-2015 blivesta
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Font Awesome
The MIT License (MIT)
Copyright (c) 2012-2016 Font Awesome
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Owl Carousel
Copyright (c) 2014 Owl
Modified work Copyright 2016-2018 David Deutsch
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.


JavaScript: Nested Objects
In the 'gradebook' example to the right:
- The forEach() method takes a function, which takes two arguments, 'student' and 'index'. For each element in the 'students' array, the gradebook object gets 'testScores' added as a key and the 'scores' array element at 'index' added as a value.
- The "gradebook['addScore']" statement assigns a function to an object key in 'gradebook'. The function takes two parameters - 'name' and 'score' - and pushes 'score' to 'testScores' in the 'name' key.
- The reduce() method
Ruby Classes:
The 'die class' exercise to the right gives an excellent illustration of some of the basic concepts of Ruby classes.
var students = ["Joseph", "Susan", "William", "Elizabeth"]
var scores = [ [80, 70, 70, 100],
[85, 80, 90, 90],
[75, 70, 80, 75],
[100, 90, 95, 85] ]
var gradebook = {}
students.forEach(function(student, index) {
gradebook[student] = {testScores: scores[index]};
})
gradebook['addScore'] = function(name, score) {
gradebook[name].testScores.push(score);
}
gradebook['getAverage'] = function(name) {
return average(gradebook[name].testScores);
}
var average = function(scores) {
return(scores.reduce(function(sum, score) {
return sum + score;
}))/scores.length;
}
Die class exercise
class Die
def initialize(labels)
@labels = labels
@sides = sides
unless labels.size > 0
raise ArgumentError.new('Array is empty.
Pass a non-empty array.')
end
unless labels.is_a?(Array) == true
raise ArgumentError.new('Please pass an array.')
end
end
def sides
@sides = @labels.size
end
def roll
prng = Random.new
die_roll = prng.rand(0...@sides)
@labels[die_roll]
end
end


Viscyc
Status
Cadence
Camera
Status
Detection:
n/a
On
Off
Sending:
n/a
On
Off
Cadence
Cadence:
0
rpm
Power:
0
Watt
Camera


Introduction
GRAMMy is a computational framework developed for Genome Relative Abundance using Mixture Model theory (GRAMMy) based estimation. Accurate estimation of microbial community composition based on metagenomic sequencing data is fundamental for metagenomics analysis. Prevalent estimation methods are mainly based on directly summarizing alignment results or its variants; often result in biased and/or unstable estimates. We developed the Genome Relative Abundance using Mixture Model theory (GRAMMy) approach estimate genome relative abundance based on shotgun reads. GRAMMy has been demonstrated to give estimates that are accurate and robust across both simulated and real read benchmark datasets.
Implementation
Figure 1. The GRAMMy model. A schematic diagram of the finite mixture model underlies the GRAMMy framework for shotgun metagenomics.
Availability
- Download and use SunLab virtual box machine with pre-installed GRAMMy at: http://meta.usc.edu/softs/vbox/SunLab.vdi.tgz. Check the md5sum to ensure integrity of the file: http://meta.usc.edu/softs/vbox/SunLab.vdi.tgz.md5.txt. Look into the README.txt file viewable from https://bitbucket.org/charade/grammy for detailed information.
- Download released source code package at: https://bitbucket.org/charade/grammy/get/release.tar.gz and install. Look into the README.txt file within the package (also viewable from https://bitbucket.org/charade/grammy) for detailed installation information and others.
-
Development source code access at: https://bitbucket.org/charade/grammy.
The python package is made open source for advanced users to pipeline the analysis or implement other variants. -
An example genome and texon id dump directory can be downloaded here: grefs.tgz.
An test example with step by step explanation can be found in 'test/test.sh' within the package.
Contacts
Questions and comments shall be addressed to lxia at usc dot edu.
References
- Li C. Xia, Jacob A. Cram, Ting Chen, Jed A. Fuhrman, Fengzhu Sun Accurate genome relative abundance estimation based on shotgun metagenomic reads. PLoS ONE 2011, 6(12):p.e27992


#^------------------------------
#^title trim=ends
Dquery
#^crumb_trap trim=ends same=append
{crumb_slash}dquery
#^------------------------------
#^body trim=ends
{body_text}
#^body_text trim=ends form=markdown
Every now and then, we get requests for really complex data queries on d-portal.
There is a mild API running the site and this has served us well but data needs have changed, including our understanding of them and the IATI standard.
We've spent some considerable amount of time iterating on the architecture of the database so that future queries like these are made easier and more efficient.
One of the main things we did was flatten "full" IATI data.
The idea is to have something that can be expressed as a handful of tables and then be converted back to IATI schema-validated XML.
And so, we now have a full queryable IATI data backend and have created **dquery**, a read only SQL interface to the full database.
We will need time to work on the user interface and documentation but until then, below are some queries you can use. With some minor tweaks, you should be able to adapt the query to the elements and data fields you need.
Otherwise, do let me know in the comments below.


Electricity is the sole source of energy in my property...
It powers the Heat pump (Nibe F1245) for heating and hot water. It powers the pump for the well water and an air pump for the waste water treatment. Its used for cooking, cleaning etc etc etc - you get the picture.
I've had a Emonpi working since the start of the year and my usage is just under 24kwh in a 24 hour period. Does that sound reasonable? Think I read on the openenergy monitor blogspot a target of 11kwh (http://openenergymonitor.blogspot.co.uk/2015/12/heatpumps-in-zerocarbonb...)
In December I have a 4kw solar PV array installed. The Nibe F1245 has an internal immersion for dhw incase of compressor failure / to assist with legionella cycles.
Prior to my emonpi discovery I spoke with nibe about using a solar iboost with the internal immersion. Apparently its not possible as the Nibe computer has to control it. The only work around would be to signal the computer when to turn it on but that would be a 3kw load - no variation.
So my question is what to do with the pv excess...?
Can I make use of a mk2 diverter?
My current thoughts are to put an dhw tank and immersion in the loft on the heat pump dhw cold feed pipe so to preheat all water. The down side to the this would be the cost of the tank and the requirement to relocate the current cold water tank to a higher position in the loft in order to feed the new dhw preheat tank. (the cold tank is currently on the loft floor).
Alternatively my heat pump has a 'ballast' or load tank next to it. This has a spare 28mm connection at the bottom. The tank is on the underfloor heating circulation so does such a small but powerful immersion exist that I could utilise here?
Hope the above makes sense and many thanks for reading
Re: House setup - what to do with pv excess
A couple of passing thoughts
1) would it be possible to add a changerover relay to the feed of your existing immersion with the common to the immersion, a MkII on the normally closed and the Nibe feeding both the normally open and the relay coil so that in the rest position you have "MkII diverteted surplus" but when the Nibe feels it is appropriate it can override and provide full power.
2) perhaps a external immersion heater unit could work either wth the "ballast" tank or as an etension to the existing DHW setup.
I assume there is no way to fit a second element to the existing tank?
Paul
Re: House setup - what to do with pv excess
Thanks for the reply...
1) I suspect its possible but... probably not easily, and I wouldn't really know where to start or even get to the feed for the immersion - any one know the Nibe heatpumps well enough?
2) interesting thought another unit... it would have to be small though as externally to the tank I've not a huge amount of space left in the cupboard... and I thought I was being so smart when it was installed in there!
The only 'hole' left in the tank is a 28mm.. its at the bottom though so perfect location.


Quick Response Hints
How many letters are there in "JS"?
one
two
three
four
How many letters are there in "BMX"?
uno
dos
tres
quatro
How many letters are there in "A"?
2
1
3
4


Lucas Cairns - HMPPS Digital
Package applications with dependencies
Your only requirement is Docker
Sandboxed from host machine
Relatively small size
FROM node:current-alpine
WORKDIR /home/node/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 8080
CMD ["npm", "start"]
Relatively easy to run multiple connected services
Representitive of the architecture for your project
Integration testing as part of your CI pipeline
version: "3"
services:
frontend:
image: lucascairns/frontend-service
environment:
...
ports:
- 8080:80
depends_on:
- backend
backend:
image: lucascairns/backend-service
environment:
...
ports:
- 8081:80
depends_on:
- database
database:
image: mongo
environment:
MONGO_INITDB_ROOT_USERNAME: root
MONGO_INITDB_ROOT_PASSWORD: dev
...
ports:
- 27017:27017
volumes:
- ./db/data:/data/db
Dependencies provided by the container
Sandboxed from host machine
Develop using the same environment you use to build
Cross platform, works on any machine with Docker
Initial IDE configuration can be provided
Ultimately...
{
"name": "Go",
"dockerFile": "Dockerfile",
"runArgs": ["--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined"],
"appPort": [8080],
"extensions": ["ms-vscode.go"],
"settings": {
"go.inferGopath": true
}
}
Develop against other microservices
Provide dependencies such as databases, queues, etc...
{
"name": "Go",
"dockerComposeFile": "./docker-compose.yml",
"extensions": ["ms-vscode.go"],
"settings": {
"go.gopath": "/go"
},
"service": "web_server",
"workspaceFolder": "/go/src/github.com/LucasCairns/go-web",
"shutdownAction": "stopCompose"
}
version: "3"
services:
web_server:
build:
context: .
volumes:
- ..:/go/src/github.com/LucasCairns/go-web
- ~/.gitconfig:/root/.gitconfig
cap_add:
- SYS_PTRACE
security_opt:
- seccomp:unconfined
ports:
- 8080:8080
command: "sleep infinity"
pg_db:
image: postgres
environment:
POSTGRES_USER: root
POSTGRES_PASS: dev
POSTGRES_DB: test_db
ports:
- 5432:5432
volumes:
- ../data/postgres:/var/lib/postgresql/data
Develop against ~25 AWS services locally
Compatible with the AWS CLI
Learning and development, no need for a subscription
Use as part of your CI pipeline for integration testing
localstack:
image: localstack/localstack:latest
ports:
- 9000:8080
- 4572:4572
- 4576:4576
- 4575:4575
- 4571:4571
- 4578:4578
environment:
HOSTNAME_EXTERNAL: localstack
DEFAULT_REGION: eu-west-2
SERVICES: sqs,s3,sns,es
aws_cli:
image: xueshanf/awscli
command:
- /bin/sh
- -c
- |
sleep 30
aws --version
aws --endpoint-url=http://localstack:4572 s3 mb s3://untrusted-bucket
aws --endpoint-url=http://localstack:4572 s3 mb s3://trusted-bucket
aws --endpoint-url=http://localstack:4576 sqs create-queue --queue-name audit-queue
aws --endpoint-url=http://localstack:4575 sns subscribe --topic-arn arn:aws:sns:eu-west-2:123456789012:audit-topic --attributes RawMessageDelivery=true --protocol sqs --notification-endpoint arn:aws:sns:eu-west-2:123456789012:audit-queue
aws --endpoint-url=http://localstack:4575 sns set-subscription-attributes --subscription-arn $$(aws --endpoint-url=http://localstack:4575 sns list-subscriptions-by-topic --topic-arn arn:aws:sns:eu-west-2:123456789012:audit-topic --output json | jq --raw-output '.Subscriptions[0].SubscriptionArn') --attribute-name RawMessageDelivery --attribute-value true
aws --endpoint-url=http://localstack:4575 sns list-subscriptions
environment:
AWS_ACCESS_KEY_ID: UNSET
AWS_SECRET_ACCESS_KEY: UNSET
AWS_DEFAULT_REGION: 'eu-west-2'
depends_on:
- localstack
Use Docker to make your life easier
Use Docker-Compose for integrating services
Remote container development makes getting set up a breeze
Try out Localstack, it's awesome...
...just don't use it in production


resolve-view-target.coffee |
|
define [
'oraculum'
'jquery'
], (Oraculum, $) ->
'use strict'
|
|
¶ Resolve View TargetThis function is a helper for arbitrary Params
view
View
The object that contains the targeted method.
target
null
false
undefined
String
Element
jQueryElement
Function
Something that resembles an element or selector.
|
Oraculum.resolveViewTarget = (view, target) ->
target = target.call view if typeof target is 'function'
return target if target instanceof $
return $(target) if _.isElement target
return if target? then view.$(target) else view.$el
Oraculum.define 'resolveViewTarget', (->
console?.warn? '''
Oraculum resolveViewTarget definition has been superceded by the
Oraculum.resolveViewTarget instance method.
This factory definition will be removed in 2.x
'''
return Oraculum.resolveViewTarget
), singleton: true
|


Pre-K Classes
As preschoolers gain more self-esteem, they feel ready to take on the world.
Our preschool curriculum enhances their confidence by providing activities to
help them become problem solvers and nurture a love of learning. With independent
exploration, structured activities, and hands-on learning, our children develop
a variety of skills and knowledge in areas from mathematics to reading.
We're proud of the work we do. Early learning standards, backed by education experts,
inform the scope and sequence of our pre-k program. Our curriculum aligns to
72 learning standards progressing sequentially across six developmental domains.
Add to this a healthy dose of running, jumping and movement to keep children active
and you'll see why Trusted Friends is a true leader in early
childhood education.
Language Skills
Language, literacy, and communication skills are embedded into a child's
daily experiences. We strive to create meaningful classroom experiences that
help children use and build a growing vocabulary.
Math Exploration
Pre-k children are enthusiastic mathematicians. Our instructors work to ensure that
our students don't simply learn numbers by rote, but instead build mathematical
understanding related to real, everyday problems. Our curriculum includes
important skills such as comparing and contrasting items by characteristics,
following complex directions in sequence, and solving simple number problems.
Science Studies
As their cognitive and physical abilities develop, children are able to develop and test
their own theories, and to engage in scientific reasoning. Our curriculum encourages students
to broaden their understanding of scientific disciplines, from physics to chemistry to
earth science. Children learn by participating in cooking projects and participating in
multi-skill experiments, handling mechanical tools.
Creative Expressions
Pre-kindergarten is an ideal time to introduce children to artistic expression. Our
pre-k teachers extend their student's skills and knowledge through process-oriented art
projects. We teach sculpting with clay and etching tools, writing and illustrating books,
and our students experience acting out original stories with costumes, props, and masks.
Cultural Sharing
Children are innately interested in the diversity of people and cultures. We
foster the development of all areas of a child's emotional intelligence including interpersonal
skills, compassion, and acceptance of personal responsibility. We believe in fostering
respect for different cultures, traditions, and life styles.
Physical Wellness
Pre-k children learn about becoming responsible for their own choices and decisions.
Our curriculum encourages students to learn physical wellness through physical activity,
healthy eating, and personal hygiene. Everyday our children learn about themselves and
others through supportive sharing times.


(Deprecated API)
(Deprecated API)
(Deprecated API)
Includes enterprise licensing and support
Welcome to the developer documentation for the Google Static Maps API! The Google Static Maps API lets you embed a Google Maps image on your webpage without requiring JavaScript or any dynamic page loading. The Google Static Map service creates your map based on URL parameters sent through a standard HTTP request and returns the map as an image you can display on your web page.
Note: The Google Static
Maps API no longer requires a Maps API key!
(Google Maps API
Premier customers should instead sign their URLs using a new
cryptographic key which will be sent to you. See the
Premier documentation for more information.)
New! The Google Static Maps service now supports custom styled maps!
If you just want to quickly change your existing Static Maps URLs to use the new API, consult this Upgrade Guide.
The following example contains the URL of a static map image of downtown New York City, which is displayed below:
# You can copy the URL from the image below, however. # http://maps.google.com/maps/api/staticmap?center=Brooklyn+Bridge,New+York,NY&zoom=14&size=512x512&maptype=roadmap &markers=color:blue|label:S|40.702147,-74.015794&markers=color:green|label:G|40.711614,-74.012318 &markers=color:red|color:red|label:C|40.718217,-73.998284&sensor=false
Notice that you don't need to do anything "special" to get this image to
show up on the page. No JavaScript is required. All we needed to do was create
a URL, and place it within an <img>
tag. You can place a
Google static map anywhere on your webpage where you can place an image.
This document is intended for website and mobile developers who want to include Google Static Maps API images within a webpage. It provides an introduction to using the API and reference material on the available parameters.
Use of the Google Static Maps API is subject to a query limit of 1000 unique (different) image requests per viewer per day. Since this restriction is a quota per viewer, most developers should not need to worry about exceeding their quota. However, note that we enforce an additional request rate limit to prevent abuse of the service. Requests of identical images, in general, do not count towards this limit beyond the original request.
If a user exceeds the limit as proscribed above, the following image will be displayed indicating that the quota has been exceeded:
This limit is enforced to prevent abuse and/or repurposing of the Static Maps API, and this limit may be changed in the future without notice. If you exceed the 24-hour limit or otherwise abuse the service, the Static Maps API may stop working for you temporarily. If you continue to exceed this limit, your access to the Static Maps API may be blocked.
Static Map URLs are restricted to 2048 characters in size. In practice, you will probably not have need for URLs longer than this, unless you produce complicated maps with a high number of markers and paths. Note, however, that certain characters may be URL-encoded by browsers and/or services before sending them off to the Static Map service, resulting in increased character usage. For more information, see Building a Valid URL.
The Google Static Maps API returns an image (either GIF, PNG or JPEG) in response to a HTTP request via a URL. For each request, you can specify the location of the map, the size of the image, the zoom level, the type of map, and the placement of optional markers at locations on the map. You can additionally label your markers using alphanumeric characters, so that you can refer to them in a "key."
 When the webpage is
displayed, the browser requests the image from the the Static Maps API and it
renders within the image location. Note that static maps may only be displayed
within browser content; use of static maps outside of the browser is not
allowed. (Google Maps API
Premier users are waived of this requirement.)
This document describes the required format of Static Maps API URLs and the available parameters. It also points out some tips and tricks in specifying your URLs.
A Google Static Maps API URL must be of the following form:
http://maps.google.com/maps/api/staticmap?parameters
Certain parameters are required while some are optional. As is standard in
URLs, all parameters are separated using the ampersand (&
)
character. The list of parameters and their possible values
are enumerated below.
The Static Maps API defines map images using the following URL parameters:
Location Parameters:
center
(required if markers not present) defines the center
of the map, equidistant from all edges of the map. This parameter takes a
location as either a comma-separated {latitude,longitude} pair (e.g.
"40.714728,-73.998672") or a string address (e.g. "city hall, new york, ny")
identifying a unique location on the face of the earth. For more information,
see Locations below.zoom
(required if markers not present) defines the
zoom level of the map, which determines the
magnification level of the map. This parameter takes a numerical value
corresponding to the zoom level of the region desired. For more information,
see zoom levels below.Map Parameters:
size
(required) defines the rectangular dimensions of the map
image. This parameter takes a string of the form
valuexvalue
where horizontal pixels are denoted
first while vertical pixels are denoted second. For example,
500x400
defines a map 500 pixels wide by 400 pixels high. If you
create a static map that is 100 pixels wide or smaller, the "Powered by
Google" logo is automatically reduced in size.format
(optional) defines the format of the resulting image.
By default, the Static Maps API creates PNG images. There are several possible
formats including GIF, JPEG and PNG types. Which format you use depends on
how you intend to present the image. JPEG typically provides greater
compression, while GIF and PNG provide greater detail. For more information,
see Image Formats.maptype
(optional) defines the type of map to construct.
There are several possible maptype values, including roadmap
,
satellite
, hybrid
, and terrain
. For
more information, see Static Maps API Maptypes below.
language
(optional) defines the language to use for display
of labels on map tiles. Note that this parameter is only supported for some
country tiles; if the specific language requested is not supported for the
tile set, then the default language for that tileset will be used.Feature Parameters:
markers
(optional) define one or more markers to attach to
the image at specified locations. This parameter takes a single marker
definition with parameters separated by the pipe character (|
).
Multiple markers may be placed within the same markers
parameter
as long as they exhibit the same style; you may add additional markers of
differing styles by adding additional markers
parameters.
Note that if you supply markers for a map, you do not need to specify the
(normally required) center
and zoom
parameters. For
more information, see Static Map Markers below.path
(optional) defines a single path of two or more
connected points to overlay on the image at specified locations. This
parameter takes a string of point definitions separated by the pipe
character (|
). You may supply additional paths by adding
additional path
parameters. Note that if you supply a path for a
map, you do not need to specify the (normally required) center
and zoom
parameters. For more information, see
Static Map Paths below.visible
(optional) specifies one or more
locations that should remain visible on the map,
though no markers or other indicators will be displayed. Use this parameter to
ensure that certain features or map locations are shown on the static
map.style
(optional) defines a custom style to alter the
presentation of a specific feature (road, park, etc.) of the map. This
parameter takes feature
and element
arguments
identifying the features to select and a set of style operations to apply
to that selection. You may supply multiple styles by adding additional
style
parameters. For more information, see
Styled Maps below.Reporting Parameters:
sensor
(required) specifies whether the application
requesting the static map is using a sensor to determine the user's location.
This parameter is required for all static map requests. For more information,
see Denoting Sensor Usage below.The Static Maps API is relatively easy to use, as it consists solely of a parameterized URL. This section explains how to use these parameters to construct your URLs.
The Static Maps API must be able to precisely identify locations on the
map, both to focus the map at the correct location (using the
center
parameter) and/or to place any optional placemarks
(using the markers
parameter) at locations on the map. The Static
Maps API uses numbers (latitude and longitude values) or strings (addresses)
to specify these locations. These values identify a geocoded
location.
Several parameters (such as the markers
and path
parameters) take multiple locations. In those cases, the locations are
separated by the pipe (|
) character.
Latitudes and longitudes are defined using numerals within a comma-separated text string that have a precision to 6 decimal places. For example, "40.714728,-73.998672" is a valid geocode value. Precision beyond the 6 decimal places is ignored.
Longitude values are based on their distance from Greenwich, England, home
of the prime meridian. Since Greenwich is situated at 51.477222 latitude, we
can enter a center
value of 51.477222,0
to center
the map on Greenwich:
Latitude and longitude values must correspond to a valid location on the
face of the earth. Latitudes can take any value between -90
and
90
while longitude values can take any value between
-180
and 180
. If you specify an invalid latitude or
longitude value, your request will be rejected as a bad request.
Most people don't speak in latitudes and longitudes; they denote locations using addresses. The process of turning an address into a geographic point is known as geocoding and the Static Maps service can perform geocoding for you if you provide valid addresses.
In any parameter where you may provide a latitude/longitude, you may instead specify a string indicating an address. Google will geocode the address and provide the Static Map service with a latitude/longitude value to use in placing markers or specifying locations. The string should be URL-escaped, so addresses such as "City Hall, New York, NY" should be converted to "City+Hall,New+York,NY", for example.
Note that addresses may reflect either precise locations, such as street addresses, polylines such as named routes, or polygonal areas such as cities, countries, or national parks. For polylinear and polygonal results, the Static Map server will use the center point of the line/area as the address center. If you have doubt about how an address may geocode, you can test out the address using this Geocoding Utility.
The following example generates a static map for Berkeley, CA:
http://maps.google.com/maps/api/staticmap?center=Berkeley,CA&zoom=14&size=400x400&sensor=false
Use of the Google Static Maps API requires that you indicate whether your application is using a "sensor" (such as a GPS locator) to determine the user's location. This is especially important for mobile devices. Applications must pass a required sensor parameter indicating whether or not your application is using a sensor device.
Applications that determine the user's location via a sensor must pass
sensor=true
within your Static Maps API request URL. If your
application does not use a sensor, pass sensor=false
.
Maps on Google Maps have an integer "zoom level" which defines the
resolution of the current view. Zoom levels between 0
(the lowest
zoom level, in which the entire world can be seen on one map) to
21+
(down to individual buildings) are possible within the
default roadmap maps view.
Google Maps sets zoom level 0
to encompass the entire earth.
Each succeeding zoom level doubles the precision in both horizontal and
vertical dimensions. More information on how this is done is available in the
Google Maps API documentation.
Note: not all zoom levels appear at all locations on the earth. Zoom levels vary depending on location, as data in some parts of the globe is more granular than in other locations.
If you send a request for a zoom level in which no map tiles exist, the Static Maps API will return a blank image instead.
The example below requests two maps of Manhattan at the same
center
value but at zoom levels 12 and 14, respectively:
http://maps.google.com/maps/api/staticmap?center=40.714728,-73.998672&zoom=12&size=400x400&sensor=false http://maps.google.com/maps/api/staticmap?center=40.714728,-73.998672&zoom=14&size=400x400&sensor=false
Images may be retrieved in sizes up to 640 by 640 pixels. The
size
parameter takes a string with two values separated by the
x
character. 640x640
is the largest image size
allowed. Note that the center
parameter, combined with the
size
parameter implicitly defines the coverage area of the map
image.
The example below requests a "slice" of the earth at the equator at zoom level 1:
http://maps.google.com/maps/api/staticmap?center=0,0&zoom=1&size=400x50&sensor=true_or_false
The example below requests a small map, of size 100 x 100 pixels centered on the same region. Note the smaller Google logo:
Images may be returned in several common web graphics formats: GIF,
JPEG and PNG. The format
parameter takes one of the
following values:
png8
or png
(default) specifies the 8-bit
PNG
format.png32
specifies the 32-bit
PNG
format.gif
specifies the
GIF format.jpg
specifies the
JPEG compression
format.jpg-baseline
specifies a non-progressive
JPEG compression
format.jpg
and jpg-baseline
typically provide the
smallest image size, though they do so through "lossy" compression which may
degrade the image. gif
, png8
and png32
provide lossless compression.
Most JPEG images are progressive, meaning that they load a coarser image
earlier and refine the image resolution as more data arrives. This allows
images to be loaded quickly in webpages and is the most widespread use of JPEG
currently. However, some uses of JPEG (especially printing) require
non-progressive (baseline) images. In such cases, you may want to use the
jpg-baseline
format, which is non-progressive.
The Google Static Maps API creates maps in several formats, listed below:
roadmap
(default) specifies a standard roadmap image, as is
normally shown on the Google Maps website. If no maptype
value
is specified, the Static Maps API serves roadmap
tiles by
default.satellite
specifies a satellite image.terrain
specifies a physical relief map image, showing
terrain and vegetation.hybrid
specifies a hybrid of the satellite and roadmap
image, showing a transparent layer of major streets and place names on the
satellite image.You can see the difference between roadmap and terrain types in the code example below.
http://maps.google.com/maps/api/staticmap?center=40.714728,-73.998672&zoom=12&size=400x400&maptype=roadmap&sensor=true_or_false http://maps.google.com/maps/api/staticmap?center=40.714728,-73.998672&zoom=12&size=400x400&maptype=terrain&sensor=true_or_false
Hybrid maps use satellite images and prominent roadmap features to create a combination map. The following examples show satellite and hybrid map types:
http://maps.google.com/maps/api/staticmap?center=40.714728,-73.998672&zoom=12&size=400x400&maptype=satellite&sensor=true_or_false http://maps.google.com/maps/api/staticmap?center=40.714728,-73.998672&zoom=12&size=400x400&maptype=hybrid&sensor=true_or_false
Styled maps allow you to customize the presentation of the standard Google map styles, changing the visual display of such elements as roads, parks, and built-up areas to reflect a different style than that used in the default map type. These components are known as features and a styled map allows you to select these features and apply visual styles to their display (including hiding them entirely). With these changes, the map can be made to emphasize particular components or complement content within the surrounding page.
A customized "styled" map consists of one or more specified styles,
each indicated through a style
parameter within the Static
Map request URL. Additional styles are specified by passing additional
style
parameters. A style consists of a selection(s)
and a set of rules to apply to that selection. The rules indicate
what visual modification to make to the selection.
Each style
declaration consists of the following arguments,
separated using a pipe ("|
") character within the style
declaration:
feature
(optional) indicates what features to select
for this style modification. (See Map
Features below.) If no feature
argument is passed,
all features will be selected.element
(optional) indicates what sub-set of the
selected features to select. (See Map
Elements below.) If no element
argument is passed,
all elements of the given feature will be selected.style
declaration. (See
Style Rules below.) Any number of
rules may follow a feature selection, within the normal URL-length
constraints of the Static Maps API.Note: the style
declaration must specify the above arguments
in the order stated. For example, a feature selection with two rules
would appear as show below:
style=feature:featureArgument|element:elementArgument|rule1:rule1Argument|rule2:rule2Argument
A map consists of a set of features, such as roads
or parks. The feature types form a category tree, with feature:all
as the root. Some common features are listed
below:
feature:all
(default) selects all features of the map.feature:road
selects all roads on the map.
feature:landscape
selects all background landscapes on a map,
which is often the area between roads, for example. In cities, landscape usually consists
of built-up areas.The full list of features for selection within a map is documented in the Maps Javascript API V3 reference.
Some feature type categories contain sub-categories which are specified
using a dotted notation (landscape.natural
or
road.local
, for example). If the parent feature
(road
, for example) is specified, then styles applied to this
selection will be applied to all roads, including sub-categories.
Additionally, some features on a map typically consist of different
elements. A road, for example, consists of not only the graphical
line (geometry) on the map, but the text denoting its name (labels)
attached the map. Elements within features are selected by declaring
an element
argument. The following element argument values
are supported:
element:all
(default) selects all elements of that feature.element:geometry
selects only geometric elements of that
feature.element:labels
selects only textual labels associated with that
feature.If no element argument is passed, styles will be applied to all elements of the feature regardless of element type.
The following style
declaration selects the labels for all local
roads:
style=feature:road.local|element:labels
Style rules are formatting options which are applied to the features
and elements specified within each style
declaration. Each
style
declaration must contain one or more operations separated
using the pipe ("|
") character. Each operation specifies its
argument value using the colon (":
") character, and all operations
are applied to the selection in the order in which they are specified.
The following operation arguments, and the values that take, are currently supported:
hue
(an RGB hex string of format
0xRRGGBB
) indicates the basic color to
apply to the selection.
(* See usage note below.)lightness
(a floating point value
between -100
and 100
)
indicates the percentage
change in brightness of the element. Negative
values increase darkness (where -100 specifies black) while positive
values increase brightness (where +100 specifies white).saturation
(a floating point value between
-100
and 100
) indicates the percentage
change in intensity of the basic color to apply to the element.gamma
(a floating point value between 0.01
and 10.0
, where 1.0
applies no correction)
indicates the amount of gamma correction to apply to the element. Gammas
modify the lightness of hues in a non-linear fashion, while unaffecting
white or black values. Gammas are typically used to modify the contrast
of multiple elements. For example, you could modify the gamma to
increase or decrease the contrast between the edges and interiors of
elements. Low gamma values (< 1) increase contrast, while high
values (> 1) decrease contrast.inverse_lightness:true
simply
inverts the existing lightness.visibility
(on
, off
,
or simplified
) indicates whether and how the element
appears on the map. visibility:simplified
indicates
that the map should simplify the presentation of those elements as
it sees fit. (A simplified road structure may show fewer roads, for
example.)Style rules must be applied as separate, distinct operations, and are
applied in the order they appear within the style
declaration. Order is important, as some operations are not commutative. Features
and/or elements that are modified through style operations
(usually) already have existing styles; the operations act on those existing
styles, if present.
Note that we use the
Hue, Saturation, Lightness (HSL) model to denote color within the
styler operations. These operations to define color are common within
graphic design. Hue indicates the basic color, saturation
indicates the intensity of that color, and lightness indicates the
relative amount of white or black in the constituent color. All three
HSL values can be mapped to RGB values (and vice versa).
Gamma
correction acts to modify saturation over the color space, generally
to increase or decrease contrast. Additionally, the HSL model defines color
within a coordinate space where hue
indicates the orientation
within a color wheel, while saturation and lightness indicate amplitudes
along different axes. Hues are measured within an RGB color space,
which is similar to most RGB color spaces, except that shades of white and
black are absent.
An RGB Color Wheel
Note: while hue
takes
an RGB hex color value, it only uses this value to determine the basic
color (its orientation around the color wheel), not its saturation or
lightness, which are indicated separately as percentage changes. For
example, the hue for pure green may be defined
as hue:0x00ff00
or hue:0x000100
and
both hues will be identical. (Both values point to pure green in
the HSL color model.) RGB hue
values which consist
of equal parts Red, Green and Blue — such as hue:0x0000000
(black) and hue:0xffffff
(white) and all the pure shades
of grey — do not indicate a hue whatsoever, as none of those values
indicate an orientation in the HSL coordinate space. To indicate
black, white or grey, you must remove all saturation
(add
a saturation:-100
operation) and adjust lightness
instead.
Additionally, when modifying existing features which already have a
color scheme, changing a value such as hue
does not change
its existing saturation
or lightness
.
The following example displays a map of Brooklyn where local roads have been changed to bright green and the residential areas have been changed to black:
http://maps.google.com/maps/api/staticmap?sensor=false&size=512x512¢er=Brooklyn&zoom=12&style=feature:road.local|element:geometry|hue:0x00ff00|saturation:100&style=feature:landscape|element:geometry|lightness:-100
The following more complicated example uses several operations and simplifications to approximate the look of a US road atlas:
http://maps.google.com/maps/api/staticmap?sensor=false&size=512x512&zoom=11¢er=Chicago&style=feature:road.highway|element:geometry|hue:0xff0022|saturation:60|lightness:-20&style=feature:road.arterial|element:geometry|hue:0x2200ff|lightness:-40:visibility:simplified|saturation:30&style=feature:road.local|hue:0xf6ff00|saturation:60|gamma:0.7|visibility:simplified&style=feature:water|element:geometry|saturation:40|lightness:40&style=road.highway|element:labels|visibility:on|saturation:98&style=feature:administrative.locality|element:labels|hue:0x0022ff|saturation:50|lightness:-10|gamma:0.9&style=feature:transit.line|element:geometry|hue:0xff0000|visibility:on|lightness:-70
The markers
parameter defines a set of one or more markers at
a set of locations. Each marker defined within a single markers
declaration must exhibit the same visual style; if you wish to display markers
with different styles, you will need to supply multiple markers
parameters with separate style information.
The markers
parameter takes set of value assignments
(marker descriptors) of the following format:
markers=markerStyles|markerLocation1|
markerLocation2|...
etc.
The set of markerStyles is declared at the beginning of the
markers
declaration and consists of zero or more style
descriptors separated by the pipe character (|
), followed
by a set of one or more locations also separated by the pipe character
(|
). (The pipe character is also %7C in ASCII if you are encoding
your URLs.)
Because both style information and location information is delimited via the pipe character, style information must appear first in any marker descriptor. Once the Static Map server encounters a location in the marker descriptor, all other marker parameters are assumed to be locations as well.
The set of marker style descriptors is a series of value assignments
separated by the pipe (|
) character. This style descriptor
defines the visual attributes to use when displaying the markers within this
marker descriptor. These style descriptors contain the following key/value
assignments:
size:
(optional) specifies the size of marker from
the set {tiny, mid, small}
. If no size
parameter
is set, the marker will appear in its default (normal) size.color:
(optional) specifies a 24-bit color
(example: color=0xFFFFCC
) or a predefined color from the set
{black, brown, green, purple, yellow, blue, gray, orange, red,
white}
.
Note that transparencies (specified using 32-bit hex color values) are not supported in markers, though they are supported for paths.
label:
(optional) specifies a single
uppercase alphanumeric character from the set {A-Z, 0-9}. (The
requirement for uppercase characters is new to this version of the API.)
Note that default and mid
sized markers are the only markers
capable of displaying an alphanumeric-character
parameter.
tiny
and small
markers are not capable of
displaying an alphanumeric-character.Note: instead of using these markers, you may wish to use your own custom icon. (For more information, see Custom Icons below.)
Each marker descriptor must contain a set of one or more locations defining
where to place the marker on the map. These locations may be either specified
as latitude/longitude values or as
addresses. These locations are separated using the
pipe character (|
).
The location parameters define the marker's location on the map. If the
location is off the map, that marker will not appear in the constructed image
provided that center
and zoom
parameters are
supplied. However, if these parameters are not supplied, the Static Map server
will automatically construct an image which contains the supplied markers.
(See Implicit Positioning below.)
A sample marker declaration is shown below. Note that we define one set of styles and three locations:
http://maps.google.com/maps/api/staticmap?center=Williamsburg,Brooklyn,NY&zoom=13&size=400x400& markers=color:blue|label:S|11211|11206|11222&sensor=true_or_false
To define markers with differing styles, we need to supply multiple
markers
parameters. This set of markers
parameters
defines three markers: one blue marker labeled "S" at 62.107733, -145.5419,
one tiny green marker at "Delta Junction, AK", and one mid-sized yellow marker
labeled "C" at "Tok, AK". These markers are shown in the example below:
http://maps.google.com/maps/api/staticmap?center=63.259591,-144.667969&zoom=6&size=400x400\ &markers=color:blue|label:S|62.107733,-145.541936&markers=size:tiny|color:green|Delta+Junction,AK\ &markers=size:mid|color:0xFFFF00|label:C|Tok,AK&sensor=false" />
Rather than use Google's marker icons, you are free to use your own custom
icons instead. Custom icons are specified using the following descriptors to
the markers
parameter:
icon
specifies a URL to use as the marker's custom icon.
Images may be in PNG, JPEG or GIF formats, though PNG is recommended.shadow
(default true
) indicates that the
Static Maps service should construct an appropriate shadow for the image.
This shadow is based on the image's visible region and its
opacity/transparency.The icon
parameter must be specified using a URL (which
should be
URL-encoded).
You may use any valid URL of your choosing, or a
URL-shortening service such as http://bit.ly
or
http://tinyurl.com
. Most URL-shortening services have the
advantage of automatically encoding URLs. Icons are limited to sizes of
4096 pixels (64x64 for square images), and the Static Maps service allows
up to five unique custom icons per request. Note that each of these unique
icons may be used multiple times within the static map.
Custom icons that have a shadow:true
descriptor (the default)
will have their "anchor point" set as the bottom center of the provided icon
image, from which the shadow is cast. Icons without a shadow (setting
a shadow:false
descriptor) are instead assumed to be icons
centered on their specified locations, so their anchor points are set as
the center of the image.
The following example uses Google's Chart API to create custom markers, showing several coffee shops in New York City:
http://maps.google.com/maps/api/staticmap?size=480x480&markers= icon:http://chart.apis.google.com/chart%3Fchst%3Dd_map_pin_icon%26chld%3Dcafe%257C996600| 224+West+20th+Street|75+9th+Ave|700+E+9th+St&sensor=true_or_false
Note: the Google Chart API, like the Google
Static Maps API, uses the pipe character ("|") to delimit parameters within
its URLs. Any icon
URLs containing such a character will cause
the Static Map service to interpret the pipe character as a parameter
delimiter before evaluating the URL. If you wish to use a URL containing
a pipe character, you can "double-encode" the pipe to %257C
,
which decodes to %7C
and will ensure that any pipe you place in
the icon's URL is not interpreted by the Static Map service. (We used this
trick above.)
The example below shows how such a URL will look after double-encoding the pipe character:
# Original URL: http://chart.apis.google.com/chart?chst=d_map_pin_icon&chld=cafe|996600 # Encoded URL: http://chart.apis.google.com/chart%3Fchst%3Dd_map_pin_icon%26chld%3Dcafe%7C996600 # Double-encoding of the "|" character: http://chart.apis.google.com/chart%3Fchst%3Dd_map_pin_icon%26chld%3Dcafe%257C996600
The path
parameter defines a set of one or more locations
connected by a path to overlay on the map image. The path
parameter takes set of value assignments (path descriptors) of the
following format:
path=pathStyles|pathLocation1|pathLocation2|...
etc.
Note that both path points are separated from each other using the pipe
character (|
). Because both style information and point
information is delimited via the pipe character, style information must appear
first in any path descriptor. Once the Static Map server encounters a
location in the path descriptor, all other path parameters are assumed to be
locations as well.
The set of path style descriptors is a series of value assignments
separated by the pipe (|
) character. This style descriptor
defines the visual attributes to use when displaying the path. These style
descriptors contain the following key/value assignments:
weight:
(optional) specifies the thickness of the
path in pixels. If no weight
parameter is set, the path will
appear in its default thickness (5 pixels).color:
(optional) specifies a color either as a
24-bit (example: color=0xFFFFCC
) or 32-bit hexadecimal value
(example: color=0xFFFFCCFF
), or from the set {black,
brown, green, purple, yellow, blue, gray, orange, red, white}
.
When a 32-bit hex value is specified, the last two characters
specify the 8-bit alpha transparency value. This value varies between
00
(completely transparent) and FF
(completely opaque). Note that transparencies are supported in paths, though
they are not supported for markers.
fillcolor:
(optional) indicates both that the path
marks off a polygonal area and specifies the fill color to use as an overlay
within that area. The set of locations following need not be a "closed"
loop; the Static Map server will automatically join the first and last
points. Note, however, that any stroke on the exterior of the filled area
will not be closed unless you specifically provide the same beginning
and end location.Some example path definitions appear below:
path=color:0x0000ff|weight:1
path=color:0xff0000ff|weight:5
path=color:0xffffffff|weight:10
These path styles are optional. If default attributes are desired, you may skip defining the path attributes; in that case, the path descriptor's first "argument" will consist instead of the first declared point (location).
In order to draw a path, the path
parameter must also be
passed two or more points. The Google Static Maps API will then connect the
path along those points, in the specified order. Each pathPoint is
denoted in the pathDescriptor separated by the |
(pipe)
character.
The following example defines a blue path with default 50% opacity from Union Square NY to Times Square, NY.
The specifics of the path
parameter appear below:
path=color:0x0000ff|weight:5|40.737102,-73.990318|40.749825,-73.987963|40.752946,-73.987384|40.755823,-73.986397
The following example defines the same path instead defining a solid red line with 100% opacity:
The specifics of this path
parameter appear below:
path=color:0xff0000ff|weight:5|40.737102,-73.990318|40.749825,-73.987963|40.752946,-73.987384|40.755823,-73.986397
The example below defines a polygonal area within Manhattan, passed a series of intersections as locations:
The specifics of this path
parameter appear below:
path=color:0x00000000|weight:5|fillcolor:0xFFFF0033|8th+Avenue+%26+34th+St,New+York,NY|\ 8th+Avenue+%26+42nd+St,New+York,NY|Park+Ave+%26+42nd+St,New+York,NY,NY|\ Park+Ave+%26+34th+St,New+York,NY,NY
Note that we set the path itself to be invisible and the polygonal area to have a 15% opacity.
Instead of a series of locations, you may instead declare a path as an
encoded polyline
by using the enc:
prefix within the location declaration of the
path
. Note that if you supply an encoded polyline path for a map,
you do not need to specify the (normally required) center
and
zoom
parameters.
The following example outlines the course of the Alaska Highway from Dawson Creek, BC to Delta Junction, AK with an encoded polyline:
http://maps.google.com/maps/api/staticmap?size=400x400&path=weight:3|color:orange|enc:polyline_data
As with standard paths, encoded polyline paths may also demarcate polygonal
areas if a fillcolor
argument is passed to the path
parameter.
The following example outlines a polygonal area for Brooklyn, NY:
http://maps.google.com/maps/api/staticmap?size=400x400&path=fillcolor:0xAA000033|color:0xFFFFFF00| enc:encoded_data
Images may specify a viewport by specifying visible locations using
the visible
parameter. The visible
parameter
instructs the Static Map service to construct a map such that the existing
locations remain visible. (This parameter may be combined with existing
markers or paths to define a visible region as well.) Defining a viewport in
this manner obviates the need to specify an exact zoom level.
The example below requests a map centered on Boston, MA containing both MIT and Harvard Square in Cambridge, MA:
http://maps.google.com/maps/api/staticmap?center=Boston,MA &visible=77+Massachusetts+Ave,Cambridge,MA|Harvard+Square,Cambridge,MA&size=512x512&sensor=true_or_false
Normally, you need to specify center
and zoom
URL
parameters to define the location and zoom level of your generated map.
However, if you supply markers
, path
, or
visible
parameters, you can instead let the Static Maps API
determine the correct center and zoom level implicitly, based on evaluation of
the position of these elements.
If supplying two or more elements, the Static Maps API will determine a proper center and zoom level, providing generous margins for the elements contained. The example below displays a map containing San Francisco, Oakland, and San Jose, CA:
http://maps.google.com/maps/api/staticmap?size=512x512&maptype=roadmap\ &markers=size:mid|color:red|San+Francisco,CA|Oakland,CA|San+Jose,CA&sensor=false
For more information on using the Static Maps API, or other Google Maps API products, be sure to check out the Maps API Google Group.


- ObjectHelper - Class in com.iasmar.rome.util
-
Created by Asmar on 01/7/2018.
- ObjectHelperNoInstances() - Method in class com.iasmar.rome.util.ObjectHelperTest
-
The class should not allowed any instances.
- ObjectHelperTest - Class in com.iasmar.rome.util
-
Created by Asmar on 01/7/2018.
- ObjectHelperTest() - Constructor for class com.iasmar.rome.util.ObjectHelperTest
-
- onAttach(IBaseView) - Method in class com.iasmar.rome.ui.views.base.BasePresenter
-
Called from the constructor.
- onAttach(V) - Method in interface com.iasmar.rome.ui.views.base.IBasePresenter
-
Called from the constructor.
- onBackPressed() - Method in class com.iasmar.rome.ui.views.main.MainActivity
-
Called when the activity has detected the user's press of the back
key and tool bar back button.
- onBindViewHolder(T, int) - Method in class com.iasmar.rome.ui.views.custom.recyclerview.BaseAdapter
-
- onClick(View) - Method in class com.iasmar.rome.ui.views.main.engineers.EngineersFragment
-
- onConfigurationChanged(Configuration) - Method in class com.iasmar.rome.app.RomeApplication
-
Called by the system when the device configuration changes while the component is running.
- onCreate() - Method in class com.iasmar.rome.app.RomeApplication
-
Called when the application is starting, before any other application objects have been created.
- onCreate(Bundle) - Method in class com.iasmar.rome.ui.views.base.BaseActivity
-
This method called once the AppCompatActivity
created.
- onCreate(Bundle) - Method in class com.iasmar.rome.ui.views.base.BaseFragment
-
Called to do initial creation of a fragment.
- onCreateView(LayoutInflater, ViewGroup, Bundle) - Method in class com.iasmar.rome.ui.views.base.BaseFragment
-
Called to have the fragment instantiate its user interface view.
- onCreateViewHolder(ViewGroup, int) - Method in class com.iasmar.rome.ui.views.custom.recyclerview.BaseAdapter
-
- onDestroy() - Method in class com.iasmar.rome.ui.views.base.BaseActivity
-
Destroy all fragments and loaders.
- onDetach() - Method in class com.iasmar.rome.ui.views.base.BasePresenter
-
Called when the fragment is no longer attached to its activity.
- onDetach() - Method in interface com.iasmar.rome.ui.views.base.IBasePresenter
-
- onDetach() - Method in class com.iasmar.rome.ui.views.main.engineers.EngineersPresenter
-
Called when the fragment is no longer attached to its activity.
- onDetach() - Method in class com.iasmar.rome.ui.views.main.MainPresenter
-
Called when the fragment is no longer attached to its activity.
- onDetach() - Method in class com.iasmar.rome.ui.views.main.schedules.SchedulesPresenter
-
Called when the fragment is no longer attached to its activity.
- onFragmentChange(String) - Method in class com.iasmar.rome.ui.views.main.MainActivity
-
Tis method will update the UI base on the selected fragment.
- onInterceptTouchEvent(MotionEvent) - Method in class com.iasmar.rome.ui.views.custom.CustomViewPager
-
- onInterceptTouchEvent(MotionEvent) - Method in class com.iasmar.rome.ui.views.custom.recyclerview.CustomSwipeRefreshLayout
-
- onLowMemory() - Method in class com.iasmar.rome.app.RomeApplication
-
This is called when the overall system is running low on memory,
and would like actively running processes to tighten their belts.
- onMeasure(int, int) - Method in class com.iasmar.rome.ui.views.custom.CustomViewPager
-
- onOptionsItemSelected(MenuItem) - Method in class com.iasmar.rome.ui.views.main.MainActivity
-
This hook is called whenever an item in options menu is selected.
- onPause() - Method in class com.iasmar.rome.ui.views.base.BaseFragment
-
Called when the Fragment is no longer resumed.
- onPause() - Method in class com.iasmar.rome.ui.views.main.engineers.EngineersFragment
-
Called when the Fragment is no longer resumed.
- onPause() - Method in class com.iasmar.rome.ui.views.main.schedules.SchedulesFragment
-
Called when the Fragment is no longer resumed.
- onRefresh() - Method in class com.iasmar.rome.ui.views.main.engineers.EngineersFragment
-
Called when the user Swipe down.
- onRefresh() - Method in class com.iasmar.rome.ui.views.main.schedules.SchedulesFragment
-
Called when the user Swipe down.
- onResume() - Method in class com.iasmar.rome.ui.views.base.BaseFragment
-
Called when the fragment is visible to the user and actively running.
- onResume() - Method in class com.iasmar.rome.ui.views.main.engineers.EngineersFragment
-
Called when the fragment is visible to the user and actively running.
- onResume() - Method in class com.iasmar.rome.ui.views.main.MainActivity
-
Called when the fragment is visible to the user and actively running.
- onResume() - Method in class com.iasmar.rome.ui.views.main.schedules.SchedulesFragment
-
Called when the fragment is visible to the user and actively running.
- onSaveInstanceState(Bundle) - Method in class com.iasmar.rome.ui.views.main.engineers.EngineersFragment
-
Save current View's state.
- onSaveInstanceState(Bundle) - Method in class com.iasmar.rome.ui.views.main.schedules.SchedulesFragment
-
Save current View's state.
- onTouchEvent(MotionEvent) - Method in class com.iasmar.rome.ui.views.custom.CustomViewPager
-
- onViewCreated(View, Bundle) - Method in class com.iasmar.rome.ui.views.base.BaseFragment
-
- onViewReady(Bundle, Intent) - Method in class com.iasmar.rome.ui.views.base.BaseActivity
-
This method called after the AppCompatActivity.setContentView(int)
.
- onViewReady(View, Bundle) - Method in class com.iasmar.rome.ui.views.base.BaseFragment
-
This method called after the Fragment.onViewCreated(View, Bundle)
.
- onViewReady(View, Bundle) - Method in class com.iasmar.rome.ui.views.main.engineers.EngineersFragment
-
- onViewReady(Bundle, Intent) - Method in class com.iasmar.rome.ui.views.main.MainActivity
-
This method called after the setContentView(int) in the base class.
- onViewReady(View, Bundle) - Method in class com.iasmar.rome.ui.views.main.schedules.SchedulesFragment
-
- onViewReady(Bundle, Intent) - Method in class com.iasmar.rome.ui.views.splash.SplashActivity
-
This method called after the setContentView(int) in the base class.


the and data with {background margin for {border-style cases coronavirus px;} #ffffff;} respiratory COVID- children disease pediatric that Accessed The have from (.) mild px; severe {font-family []. acute been font-size syndrome were Health are double; imported novel COVID-. China Control Mar border-color border-width infection solid; years {font-style {font-weight (COVID-) Disease Hong associated bold courier; cytokine em; higher inflammatory local multisystem not other patients pt;} report reported storm young


This is one of the infinite solutions for the system
{{solutionCtrl.solutionError.message || solutionCtrl.solutionError}}


#{ModelBean.getTheBlogs()}
Tweets
Blog Comments
Analyze Anything
Blog Comments
Displaying any blog posts with comments
#{blog.URL}
Post Title
#{post.title}
Date
#{post.date}
Link
Link
Comments
#{comment.name}
#{comment.email}
#{comment.msg}


Learn to test Rails apps the way I learned, building up tests step-by-step, in Everyday Rails Testing with RSpec. Expanded to include exclusive content and a complete sample Rails application. Learn more »


Bayelsa/Kogi elections: Court begins hearing on suit challenging Bello’s eligibility
by Agency ReportThe Federal High Court, Abuja, on Friday, commenced hearing on the suit challenging whether Gov. Yahaya Bello is fit to contest in the November 16 Kogi Governorship election.
The presiding judge, Justice Inyang Ekwo, however, stood down the case for 30 minutes in order to study a motion filed by Gov. Bello, who is seeking to be joined in the suit.
News Agency of Nigeria reports that while the Social Democratic Party (SDP)’s Candidate in the Saturday’s poll, Natasha Akpoti, is the plaintiff, the All Progressives Congress and the Independent National Electoral Commission are 1st and 2nd defendants respectively.
At the hearing on Friday, Bello’s lawyer, Mike Enahoro, who filed a motion of a party seeking to be joined in the matter, said he filed the application this morning because they got wind of the case yesterday.
Counsel to the plaintiff, Chief Mike Ozekhome, SAN, who acknowledged receipt of the motion this morning, hinted that the motion sought to stop court’s proceeding on the matter.
He, however, argued that the motion is thrown out considering that the election is Saturday.
On his part, Counsel to the APC, Abdulwahab Mohammed, said he would need more time to study the motion.
However, Counsel to INEC, Alhassan Umar, SAN, said he had no objection to the motion.


Zoom Poof
Enter your name, select number of poofs and poof length, submit, enjoy, repeat.
Name
Poof Count:
1
2
3
4
5
10
20
30
40
Poof Length:
0.1
0.25
0.5
0.75
1
2
3
Style:
Full
Alternating
Cylon
Timing:
Straight
Accelerating
Submit
Queue
Zoom Poof
×
In the queue!


qmv
Move files and directories using the default text editor to define the filenames.
More information: home page
- Move a single file (open an editor with the source filename on the left and the target filename on the right):
qmv source_file
- Move multiple JPG files:
qmv *.jpg
- Move multiple directories:
qmv -d path/to/directory1 path/to/directory2 path/to/directory3
- Move all files and directories inside a directory:
qmv --recursive path/to/directory
- Move files, but swap the positions of the source and the target filenames in the editor:
qmv --option swap *.jpg
- Rename all files and folders in the current directory, but show only target filenames in the editor (you can think of it as a kind of simple mode):
qmv --format=do .


| DOSE: |
2 bowls |
smoked |
Cannabis |
(plant material) |
I'm 16 years old, about to enter my last year of high school this August. Its the end of June, and I just passed my second drug test. My mom had previously found my stash, and told me to get rid of it. I did, but not my pipe. I asked my friend (lets call him M) to hold my pipe for me, and he obliged.  She didn't want to do it, but she was like 'this is just for you no one else.' Thanks, I reply. We smoke for a bit and have a good time, but this isn't the story.
A couple of weeks later, my mom springs another test on me. I was ready for it, and passed it with ease.  So she leaves, and my sister and her friends are playing Spades upstairs. I Get all my stuff, and proceed into my garage and turn off the lights. I light up, and taste the bud. Tastes fanfuckingtastic.
I smoke two bowls, occasionally stopping to let the high come on little by little. I blow some final smoke rings, and re enter my house.  I proceed to turn off the lights, and pop in Fantasia. I fast forward through the beginning parts, all the while moving my head in the 'infinity' loop. I begin to laugh and say 'It feels like a maiden is guiding my head.' Laugh some more. I begin to play it at normal speed at the greek mythology peice. I watch and some points begin to shudder, because it was so beautiful.
As I continue watching, I begin to take it in. Theres a part in the movie where a black pegasus and white pegasus are flying with their children. All of them are different colors except the black one who is flying in the back. I say to myself 'The black and white (pegasus) mean people, and they have children of all colors. One is black, and she is the most beautiful.' I'm thinking, and I have a revalation, sort of. To me, the pegasus represent a black person and white person, who marry and have children. They are all bi racial, but the one black baby pegasus is black, and the most revered. Interacial marriage in the real world can yeild these results, but is looked down upon by some. The movie showed me that interacial marriage is ok. Even though I was ok with it all along.
As I start to come down, I turn off the movie and go upstairs to go to sleep. Before I close my eyes, I say to myself 'Now time to send my self to the psychological cornucopia that is sleep.' I didn't even know what I was saying at the time, but a cornucopia in mythology was a goats horn that filled with whatever the owner desired. I had vivid, swirling dreams of color and sound. But, I had one bad dream. I don't recall all of the events, but apparently my teachers had given birth to the antichrist. I killed the baby, and woke up.
In the end, I wrote the dreams off as my mind working out things that had been worrying me. This was the first time I had a mystical experience with bud. I guess the more potent it is, the different effects it has on your body.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.