--- layout: page title: Atom Format (OData Version 3.0) date: 2014-02-20 08:13:13.000000000 +08:00 permalink: /documentation/odata-version-3-0/atom-format/ ---
The OData protocol is comprised of a set of specifications for representing and interacting with structured content. This document describes the OData Atom Format returned from an OData Service when requesting the application/atom+xml
mime type.
An OData payload may represent:
For a description of the xml format for describing an entity model, see OData:CSDL. For a description of batch requests and responses, see OData:Batch.
The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC2119, “Key words for use in RFCs to Indicate Requirement Levels”)].
This document references the following related documents:
OData payloads may use the xml:base
attribute to define a base URI for relative references defined within the scope of the element containing the xml:base
attribute.
OData Atom and XML payloads serialize primitive types as shown in the table below.
For full syntax rules, see OData:ABNF:
| Primitive Type | Literal Form | Example |
|---|---|---|
| Null Represents the absence of a value |
"null" | null |
| Edm.Binary Represent fixed- or variable- length binary data |
((A-F | a-f | 0-9)(A-F | a-f | 0-9))* | 23ABFF |
| Edm.Boolean Represents the mathematical concept of binary-valued logic |
"true" | "1" "false" | "0" |
true false |
| Edm.Byte Unsigned 8-bit integer value |
(A-F | a-f | 0-9)(A-F | a-f | 0-9) | FF |
| Edm.DateTime Represents date and time with values ranging from 12:00:00 midnight, January 1, 1753 A.D. through 11:59:59 P.M, December 9999 A.D. |
yyyy "-" mm "-" dd "T" hh ":" mm [":" ss["." fffffff]] | 2000-12-12T12:00 |
| Edm.Decimal Represents numeric values with fixed precision and scale. This type can describe a numeric value ranging from negative 10^255 + 1 to positive 10^255 -1 |
["-"][0-9]+[.][0-9]* | 2.345 |
| Edm.Double Represents a floating point number with 15 digits precision that can represent values with approximate range of Â± 2.23e -308 through Â± 1.79e +308 |
["-"][0-9]+ ((.[0-9]+) | [E[+ | -][0-9]+]) | 2.345 |
| Edm.Single Represents a floating point number with 7 digits precision that can represent values with approximate range of Â± 1.18e -38 through Â± 3.40e +38 |
["-"][0-9]+.[0-9] | 2.5 |
| Edm.Float Represents a floating point number with 7 digits precision that can represent values with approximate range of Â± 1.18e -38 through Â± 3.40e +38 |
["-"][0-9]+.[0-9] | 2.5 |
| Edm.Guid Represents a 16-byte (128-bit) unique identifier value |
dddddddd "-" dddd "-" dddd "-" dddd "-" dddddddddddd
d= A-F |a-f | 0-9 |
12345678-aaaa-bbbb-cccc-ddddeeeeffff |
| Edm.Int16 Represents a signed 16-bit integer value |
[-][0-9]+ | 16 |
| Edm.Int32 Represents a signed 32-bit integer value |
[-] [0-9]+ | 32 |
| Edm.Int64 Represents a signed 64-bit integer value |
[-] [0-9]+ | 64 |
| Edm.SByte Represents a signed 8-bit integer value |
[-] [0-9]+ | 8 |
| Edm.String Represents fixed- or variable-length character data |
any UTF-8 character Note: See definition of UTF8-char in [RFC3629] |
OData |
| Edm.Time Represents the time of day with values ranging from 0:00:00.x to 23:59:59.y, where x and y depend upon the precision |
Defined by the lexical representation for time at http://www.w3.org/TR/xmlschema-2 | 13:20:00 |
| Edm.DateTimeOffset Represents date and time as an Offset in minutes from GMT, with values ranging from 12:00:00 midnight, January 1, 1753 A.D. through 11:59:59 P.M, December 9999 A.D |
Defined by the lexical representation for datetime (including timezone offset) at http://www.w3.org/TR/xmlschema-2 | 2002-10-10T17:00:00Z |
| Edm.Geography Abstract base type for all Geography types. |
N/A | N/A |
| Edm.GeographyPoint Represents a point in a round-earth coordinate system. |
srid "Point(" point ")" srid= "SRID=" 1*5DIGIT ";" point= LONG LAT Where LONG and LAT are EDM.Doubles representing Longitude and Latitude. |
SRID=123435;Point(33.84 -117.91) |
| Edm.GeographyLineString Represents a linestring in a round-earth coordinate system. |
srid "LineString(" linestring ")" linestring= point ["," point]+ |
SRID=123435;Linestring(33.84 -117.91,48.87 2.78) |
| Edm.GeographyPolygonRepresents a polygon in a round-earth coordinate system. | srid "Polygon(" polygon ")" polygon= ring "," [ring ","]* ring= "(" firstpoint "," [point ","]* firstpoint ")" ]* ")" firstpoint = point |
SRID=123435;Polygon((33.84 -117.91,48.87 2.78,33.84 -117.91)) |
| Edm.GeographyCollection Represents a collection of Geography Values. |
srid "GeographyCollection(" geographycollection ")" geographycollection= geographyvalue ["," geographyvalue]* geographyvalue="Point("point")" | "LineString(" linestring ")" | "Polygon(" polygon ")" | "GeographyCollection(" geographycollection ")" | "MultiPoint("multipoint ")" | "MultiLineString("multilinestring ")" | "MultiPolygon("multipolygon ")" |
SRID=123435;GeographyCollection(Point(33.84 -117.91),Point(48.87 2.78)) |
| Edm.GeographyMultiPointRepresents a collection of points in a round-earth coordinate system | srid "MultiPoint(" multipoint ")" multipoint= point ["," point]* |
SRID=123435;MultiPoint((33.84 -117.91),(48.87 2.78)) |
| Edm.GeographyMultiLineStringRepresents a collection of linestrings in a round-earth coordinate system. | srid "MultiLineString(" multilinestring ")" multilinestring= "(" linestring ")" [",(" linestring ")" ]* |
SRID=123435;MultiLineString((33.84 -117.91,48.87 2.78),(33.84 -117.91, 28.36 -81.56)) |
| Edm.GeographyMultiPolygonRepresents a collection of polygons in a round-earth coordinate system. | srid "MultiPolygon(" multipolygon ")" multipolygon= "(" polygon ")" [",(" polygon ")"]* |
SRID=123435;MultiPolygon(((33.84 -117.91,(33.84 -117.91,28.36 -81.56,33.84 -117.91))) |
| Edm.Geometry Abstract base type for all Geometry types |
N/A | N/A |
| Edm.GeometryPoint Represents a point in a flat-earth coordinate system. |
srid "Point(" point ")" | SRID=123435;Point(33.84 -117.91) |
| Edm.GeometryLineString Represents a linestring in a flat-earth coordinate system. |
srid "LineString(" linestring ")" | SRID=123435;Linestring(33.84 -117.91,48.87 2.78) |
| Edm.GeometryPolygonRepresents a polygon in a flat-earth coordinate system. | srid "Polygon(" polygon ")" | SRID=123435;Polygon((33.84 -117.91,48.87 2.78,33.84 -117.91)) |
| Edm.GeometryCollection Represents a collection of Geometry Values. |
srid "GeometryCollection(" geometrycollection ")" geometrycollection= geometryvalue ["," geometryvalue]* geometryvalue= "Point("point")" | "LineString(" linestring ")" | "Polygon(" polygon ")" | "GeometryCollection(" geometrycollection ")" | "MultiPoint("multipoint ")" | "MultiLineString("multilinestring ")" | "MultiPolygon("multipolygon ")" |
SRID=123435;GeometryCollection(Point(33.84 -117.91),Point(48.87 2.78)) |
| Edm.GeometryMultiPointRepresents a collection of points in a flat-earth coordinate system. | srid "MultiPoint(" multipoint ")" | SRID=123435;MultiPoint((33.84 -117.91),(48.87 2.78)) |
| Edm.GeographyMultiLineStringRepresents a collection of linestrings in a flat-earth coordinate system. | srid "MultiLineString(" multilinestring ")" | SRID=123435;MultiLineString((33.84 -117.91,48.87 2.78),(33.84 -117.91, 28.36 -81.56)) |
| Edm.GeographyMultiPolygonRepresents a collection of polygons in a flat-earth coordinate system. | srid "MultiPolygon(" multipolygon ")" | SRID=123435;MultiPolygon(((33.84 -117.91,(33.84 -117.91,28.36 -81.56,33.84 -117.91))) |
The Atom Syndication Format RFC4287 defines an XML-based format for describing collections (“feeds”) made up of individual “entries”. The Atom Publishing Protocol RFC5023 defines an application-level protocol based on HTTP transfer of Atom-formatted representations.
OData builds on RFC4287 and RFC5023 by defining additional conventions and extensions for representing and querying entity data.
OData defines meaning for elements and attributes defined in the following namespaces.
Atom elements and attributes are defined within the Atom namespace: “http://www.w3.org/2005/Atom”.
In this specification the namespace prefix “atom” is used to represent the Atom Namespace, however the prefix name is not prescriptive.
Atom Publishing Protocol (AtomPub) elements and attributes are defined within the AtomPub namespace: “http://www.w3.org/2007/app”.
In this specification the namespace prefix “app” is used to represent the AtomPub Namespace, however the prefix name is not prescriptive.
Elements that describe the actual data values for an entity are qualified with the OData Data Namespace: “http://schemas.microsoft.com/ado/2007/08/dataservices”
In this specification the namespace prefix “data” is used to represent the OData Data Namespace, however the prefix name is not prescriptive.
Attributes and elements that represent metadata (such as type, null usage, and entry-level etags) are defined within the OData Metadata Namespace: “http://schemas.microsoft.com/ado/2007/08/dataservices/metadata”. Custom elements or attributes MUST NOT use this namespace.
In this specification the namespace prefix “metadata” is used to represent the OData Metadata Namespace, however the prefix name is not prescriptive.
OData’s Atom format defines extensions and conventions on top of RFC4287 and RFC5023 for representing structured data as follows:
Entity Instances, whether individual or within an ATOM feed, are represented as atom:entry
elements.
For example, the following atom:entry
element describes a Product:
https://services.odata.org/OData/OData.svc/Products(0)
2012-03-30T07:11:05Z
0
Bread
Whole grain bread
1992-01-01T00:00:00
4
2.5
{% endhighlight %}
This section defines the elements and attributes within an atom:entry
element that are assigned meaning in OData.
atom:entry
ElementsAn atom:entry
element is used to represent a single entity, which is an instance of a structured type with an identity.
metadata:etag
AttributeThe atom:entry
element MAY contain a metadata:etag
attribute, representing an opaque string value that can be used in a subsequent request to determine if the value of the entity has changed. For details on how ETags are used, see to OData:Core.
atom:id
ElementThe atom:id
element defines a durable, opaque, globally unique identifier for the entry. Its content must be an IRI as defined in RFC3987. The consumer of the feed must not assume this IRI can be de-referenced, nor assume any semantics from its structure.
atom:link
ElementsAtom defines two types of links within an entry that represent retrieve or update/delete operations on the entry.
atom:link
elements with a rel attribute of "self"
can be used to retrieve the entity (via the URL specified in the href
attribute).
atom:link
elements with a rel attribute of "edit"
can be used to retrieve, update, or delete the entity (via the URL specified in the href
attribute).
An atom:entry
element representing an OData entity SHOULD contain a self link, an edit link, or both for a particular entry, but MUST NOT contain more than one edit link for a given entry. Absence of an edit link implies that the entry is read-only.
atom:link
ElementsAn entity may have one or more stream properties (for example, a photo property of an employee entity). Properties that represent streams have a type of “Edm.Stream”.
OData uses atom:link
elements to represent named stream properties of an entity.
For example, a stream property named “Photo” could be represented through an atom:link
element as a child of the atom:entry
element as follows:
{% endhighlight %}
A stream property named “Photo” could be edited through an atom:link
element as a child of the atom:entry
element as follows:
{% endhighlight %}
rel
attribute of a Link Representing a Stream PropertyThe rel
attribute for an atom:link
element that can be used to retrieve a stream property is made up of the name of the OData Data Namespace, followed by the string “/mediaresource/”, followed by the name of the stream property on the entity.
The rel
attribute for an atom:link
element that can be used to write a stream property is made up of the name of the OData Data Namespace, followed by the string “/edit-media/”, followed by the name of the stream property on the entity.
In both cases the full name must be used; the use of relative URLs in the rel attribute is not allowed.
href
attribute of a Link Representing a Stream PropertyThe href
attribute of an atom:link
element describing an OData stream property contains the URL that can be used to read, or write, the stream, according to the rel
attribute. This URL may be relative or absolute.
title
attribute of a Link Representing a Stream PropertyThe title
attribute on an atom:link
element describing an OData relationship provides human-readable, possibly language-dependent, and not necessarily unique information about the link. It has no implied semantics in OData.
atom:link
ElementsOData uses atom:link
elements to represent relationships between entities.
For example, the set of related products for a particular category may be represented through an atom:link
element as a child of a category entry
element as follows:
{% endhighlight %}
The related data for the relationship MAY be included in the Entity using a single child metadata:inline
element.
rel
attribute of an atom:link
element Representing a RelationshipThe rel
attribute for an atom:link
element that represents a relationship MUST be present and is made up of the name of the OData Data Namespace, followed by the string “/related/
” followed by the name of the navigation property on the entity.
Note that the full name must be used; the use of relative URLs in the rel attribute is not allowed.
href
attribute of an atom:link
element Representing a RelationshipThe href
attribute of an atom:link
element describing an OData relationship MUST be present and specifies the URL that can be used to retrieve the related entities. This URL may be relative or absolute.
type
attribute of an atom:link
element Representing a RelationshipThe type
attribute on an atom:link
element describing an OData relationship MUST be present and determines whether the cardinality of the related end is:
type
=“application/atom+xml;type=entry”, ortype
=“application/atom+xml;type=feed”title
attribute of an atom:link
element Representing a RelationshipThe title
attribute on an atom:link
element describing an OData relationship SHOULD be present and equal to the name of the navigation property, and provides human-readable, possibly language-dependent, and not necessarily unique information about the link.
metadata:inline
ElementAn atom:link
element describing an OData relationship MAY contain a single metadata:inline
element, in which case the element contains the feed (in the case of a collection) or entry (in the case of a single entity), where the feed or entry is a child of the metadata:inline
element formatted as per this document.
An empty metadata:inline
element means that there is no content associated with the relationship (i.e., the navigation property is null). Note that this case is distinct from the absence of a metadata:inline
element which simply means that the contents of the relationship is deferred (not included in the payload).
It is valid to include the metadata:inline
element in only a subset of the entries within a feed.
atom:link
ElementsOData uses atom:link
elements to represent the collection of relationship link(s) between entities.
For example, the set of links between a category and related products may be represented through an atom:link
element as a child of a category entry element as follows:
{% endhighlight %}
rel
attribute of an atom:link
element Representing Relationship LinksThe rel
attribute for an atom:link
element that represents a collection of relationship links MUST be present and is made up of the name of the OData Data Namespace, followed by the string "/relatedlinks/"
followed by the name of the navigation property on the entity.
Note that the full name must be used; the use of relative URLs in the rel attribute is not allowed.
href
attribute of an atom:link
element Representing Relationship LinksThe href
attribute of an atom:link
element describing a relationship link MUST be present and specifies the URL that represents the collection of relationship links. This URL may be relative or absolute.
type
attribute of an atom:link
element Representing Relationship LinksThe type
attribute on an atom:link
element describing a relationship link MUST be present and equal to the content type “application/xml”
title
attribute of an atom:link
element Representing Relationship LinksThe title
attribute on an atom:link
element describing a relationship link SHOULD be present and SHOULD be set to the name of the navigation property. The title
attribute provides human-readable, possibly language-dependent, and not necessarily unique information about the link.
atom:category
ElementAn OData entry MAY contain a single atom:category
element with a scheme attribute equal to "http://schemas.microsoft.com/ado/2007/08/dataservices/scheme"
to identify the entity type of the entry. This element MUST be present if the entry represents an entity whose type is part of a type hierarchy.
An atom:category
element describing an OData entity type MUST have a term
attribute whose value is the namespace qualified name of the entity type of the entry.
The entry MAY contain additional atom:category
elements with different scheme values; such atom:category
elements have no semantic meaning in OData.
atom:content
ElementThe atom:content
element defines the content of the entry.
src
AttributeThe atom:content
element MAY contain a src
attribute, in which case the entry is a Media Link Entry, used to represent a Media Resource (for example, a photo). The value of the src
attribute MUST be a URI that can be used to retrieve the content of the Media Resource.
For Media Entities, the atom:content
element MUST be empty. In this case, properties of the Media Resource (other than the stream) are represented by the metadata:properties
element as a sibling to, rather than a child of, the atom:content
element.
atom:link
element for Updating Media Link EntriesA Media Link Entry MAY contain an atom:link
element with a rel
attribute of "edit-media"
to specify a URL that can be used to write to the BLOB associated with the entity.
rel
attribute for writing to Media Link EntriesWithin an atom:entry
representing a Media Link Entry, an atom:link
element with a rel
attribute of “edit-media” is used to identify a link that can be used to write to the BLOB associated with the entry.
href
attribute for writing to Media Link EntriesAn atom:link element representing the link used to write to the BLOB associated with the entity MUST include an href
attribute to specify the URI that can be used to write the stream. This URI may be relative or absolute.
metadata:properties
ElementThe metadata:properties
element represents a subset of the property values for an entity that are not exclusively mapped to defined or custom elements, as described in Custom Mapping to Atom Elements.
The metadata:properties
element MUST be a direct child of the atom:content
element EXCEPT for the case where the entry represents a media entity, in which case the metadata:properties
element MUST be a sibling of the atom:content
element. In the case that all properties of the entity are exclusively mapped to defined or custom elements, an empty metadata:properties
element MAY be present.
data:[propertyName]
ElementWithin the metadata:properties
element, individual data values of the entity are represented as elements where the name of the element is the name of the entity property within the OData Data Namespace.
The data:[PropertyName]
element MAY include a metadata:type
attribute to specify the type of the simple- or complex-typed instance.
For example, the following element within an metadata:properties element represents the “Rating” field with an integer value of 4:
{% highlight xml %}4
{% endhighlight %}
For simple typed properties, the content of the data:[propertyName]
element represents the value of the property. For example, the following would represent the value “CEO” for the Title property of an entity:
CEO
{% endhighlight %}
For complex typed properties, the content of the data:[propertyName]
element consists of nested data:[propertyName]
elements describing the properties of the complex type. It MAY include a metadata:type
attribute to specify the type.
For example, the complex typed property “Name”, with properties “FirstName” and “LastName” would be respresented as:
{% highlight xml %}
Julie
Swansworth
{% endhighlight %}
For properties that represent a collection of simple types, the data:[propertyName]
element may include a metadata:type
attribute with a value of "Collection([SimpleTypeName])"
. The content of the element consists of nested child elements named “element
”, in the OData Data Namespace, for each value in the collection.
The value of each simple-typed data:element in the collection follows the syntax for the simple typed property as defined for [simple-typed properties](#simpletypedproperties.
elements MUST NOT contain the metadata:null="true"
attribute value.
For example, the collection typed property “Emails” would be respresented as:
{% highlight xml %}
<EMAIL_ADDRESS><EMAIL_ADDRESS>{% endhighlight %}
For properties that represent a collection of complex types, the data:[propertyName]
element may include a metdata:type
attribute with a value of "Collection([ComplexTypeName])
“ attribute. The content of the element consists of nested child elements named ”element
", in the OData Data Namespace namespace, for each complex typed value in the collection.
The
element representing the instance may include a metadata:type
attribute to specify the type of the individual element. The value of each complex-typed
follows the syntax for complex-typed properties.
elements MUST NOT be empty and MUST NOT contain the metadata:null="true"
attribute.
For example, the collection typed property “PhoneNumbers” would be respresented as:
{% highlight xml %}
425-555-1212
Home
425-555-0178
Cell
Sprint
{% endhighlight %}
Null valued properties are represented as empty elements with the metadata:null="true"
attribute.
The metadata:null
attribute distinguishes null values from other empty content (such as an empty string).
For example, the following represents an empty apartment number:
{% highlight xml %}
{% endhighlight %}
The absence of the metadata:null attribute is equivalent to specifying metadata:null="false"
.
Primitive-valued properties and Complex-valued properties that are not part of a hierarchy MAY contain a metadata:type to specify the primitive type of the property.
Complex-valued properties that are part of a hierarchy MUST contain a metadata:type attribute.
For Complex-valued properties, the value of the attribute is the namespace-qualified name of the complex type.
For example, the following specifies that the Age property is a 32bit integer with the value 25:
{% highlight xml %}25
{% endhighlight %}
Collections of entities are represented in Atom as an Atom Feed.
Collections of entities are represented using an atom:feed
Element, where each entity is represented as an atom:entry
.
atom:id
Element within an atom:feed
The atom:id
element defines a durable, opaque, globally unique identifier for the feed. Its content must be an IRI as defined in RFC3987. The consumer of the feed must not assume this IRI can be de-referenced, nor assume any semantics from its structure.
metadata:count
ElementThe atom:feed
element may contain an m:count
element to specify the total count of rows in the result. This may be greater than the number of rows in the feed if server side paging has been applied, in which case the feed will include a next results link.
atom:link
ElementsAtom requires that feeds contain a “self link”. A self link is represented as an atom:link
with a rel
attribute of “self” and an href
that can be used to retrieve the feed from which the current entries are taken.
Note that the actual set of entries contained within the atom:feed may be a subset of those retrieved using the self link, for example, if filtering has been applied.
atom:link
elementThe atom:feed
element may contain a “next link” to indicate the presence of additional entries that belong to the feed. Such a link is represented as an atom:link
with a rel
attribute of "next"
and an href
attribute containing a URL that can be used to retrieve the next set of results.
For example, the following atom:link
element within an atom:feed
element indicates that additional results can be returned by following the specified href
:
{% endhighlight %}
The contents of the href
should be treated as an opaque URL that can be used to fetch the next set of results.
Zero or more actions may be associated with a feed or entry.
The actions associated with a particular feed or entry MAY be described using metadata:action
element(s) that are direct children of the feed or entry on which the action(s) exist.
For example, the following element describes an “Order” action:
{% highlight xml %}
{% endhighlight %}
metadata:action
ElementActions are represented as metadata:action
elements that appear as direct children of the atom:feed
or atom:entry
element representing the feed or entity on which the action(s) exist.
metadata:metadata
Attribute for an ActionA metadata:action
element MUST have a metadata:metadata
attribute which specifies the container qualified name of the function import describing the action, preceded by a “#”. For example, “#MyEntityContainer.MyFunctionName”.
This function import name must be unique within the entity container.
If the metadata cannot be retrieved by appending "$metadata"
to the service root, then this name MUST additionally be prefixed by a URL that can be used to retrieve the metadata document containing the function import that describes the action.
metadata:target
Attribute for an ActionA metadata:action
element MUST have a metadata:target
attribute that specifies the URL to POST to in order to invoke the action.
The first parameter of the action MUST be a binding parameter that is bound to the feed or entity on which the action is specified, and MUST NOT be provided as a separate parameter by the client when invoking the action.
metadata:title
Attribute for an ActionThe metadata:action
element MUST have a metadata:title
attribute that contains a human-readable, possibly language-dependent, and not necessarily unique name for the action, commonly used by clients to describe the action to a user.
Zero or more functions may be associated with a feed or entry.
The functions associated with a particular feed or entry MAY be described using metadata:function
element(s) that are direct children of the feed or entry on which the action(s) exist.
For example, the following element describes a “GetTopProducts” function:
{% highlight xml %}
{% endhighlight %}
metadata:function
ElementFunctions are represented as metadata:function
elements that appear as direct children of the atom:feed
or atom:entry
element representing the collection or entity on which the function(s) exist.
metadata:metadata
Attribute for a FunctionA metadata:function
element MUST have a metadata:metadata
attribute which specifies the container qualified name of the function import describing the function, preceded by a “#”. For example, “#MyEntityContainer.MyFunctionName”.
The named function may have multiple overloads (multiple function imports) within the container. If the metadata:function
cannot be used to invoke all overloads for the function, then it must further be distinguished by appending a comma separated ordered list of parameter type names, enclosed in parenthesis (). For example, “#MyEntityContainer.MyFunctionName(Edm.Integer, Edm.String)”.
If the metadata cannot be retrieved by appending "$metadata"
to the service root, then this name MUST additionally be prefixed by a URL that can be used to retrieve the metadata document containing the function import that describes the function.
metadata:target
Attribute for a FunctionA metadata:function
element MUST have a metadata:target
element that specifies the URL to GET from in order to invoke the function.
The first parameter of the function MUST be a binding parameter that is bound to the feed or entity on which the function is specified, and MUST NOT be provided as a separate parameter by the client when invoking the function.
metadata:title
Attribute for a FunctionThe metadata:function
element MUST have a metadata:title
attribute that contains a human-readable, possibly language-dependent, and not necessarily unique name for the function, commonly used by clients to describe the function to a user.
In OData version 3.0, annotations may be appear as a child to any of the following elements:
,
,
,
,
,
, or
where rel
indicates a navigation link or named stream.
There are two types of annotation terms in OData; ValueTerms and TypeTerms.
A ValueTerm defines a named annotation for a single primitive value. A ValueAnnotation specifies the value for a ValueTerm.
A TypeTerm defines a named annotation for a complex or entity typed value. A TypeAnnotation specifies the values for each property defined by the TypeTerm.
Custom ValueTerms and Custom TypeTerms MUST be defined in a namespace other than the Atom Namespace, AtomPub Namespace, OData Data Namespace, or OData Metadata Namespace. Annotations corresponding to custom terms add additional information about the item being annotated and SHOULD be designed in such a way that they can be safely ignored by the client.
TypeAnnotations and ValueAnnotations specify a target, which represents the collection, entry, property, function, action, navigation link, error, or named stream being annotated. The target is specified relative to the parent of the ValueAnnotation or TypeAnnotation, and is either the parent itself (“.”) or the name of the sibling element being annotated.
If more than one sibling exists with the same unqualifed name, then the namespace qualified element named MUST be used.
A ValueAnnotation is specified by a single element containing the metadata:target
attribute, whose element name is the namespace-qualified ValueTerm.
The content of the ValueAnnotation element is the value of the ValueTerm, formatted as per Primitive Types In Atom.
For example; the following specifies a value of “Home” for the “PhoneNumberType” ValueTerm applied to the “PhoneNumber” property of a customer:
{% highlight xml %}
ALFKI
Alfreds Futterkiste
030-0074321
Home
{% endhighlight %}
metadata:target
attributeThe metadata:target
attribute MUST be present on a ValueAnnotation and identifies the target of the annotation as described in Annotations.
metadata:type
attributeIf the type of the annotation value being specified is Edm.String
, then the ValueAnnotation element MAY contain the metadata:type
attribute specifying “Edm.String”, otherwise the ValueAnnotation element MUST contain the metadata:type
attribute specifying the appropriate primitive type.
A TypeAnnotation is specified by an element containing the metadata:target
attribute, whose element name is the namespace-qualified TypeTerm.
The TypeAnnotation element contains a single child element for each property of the TypeTerm being specified. The name of each such child element is the namespace-qualified name of the property, and its content specifies the value of the corresponding property of the TypeTerm, formatted as per Primitive Types In Atom. If the type of the annotation property is Edm.String
, then the child element MAY contain the metadata:type
attribute specifying “Edm.String”, otherwise the child element MUST contain the metadata:type
attribute specifying the appropriate primitive type.
For example; the following specifies the “StreetAddress”, “City”, “Region”, “Country” and “Postal Code” properties of an “Address” TypeTerm applied to a customer entity:
{% highlight xml %}
ALFKI
Alfreds Futterkiste
030-0074321
Obere Str. 578
Toronto
12209
Germany
{% endhighlight %}
metadata:target
attributeThe metadata:target
attribute MUST be present on a TypeAnnotation and identifies the target of the annotation as described in Annotations.
Individual property values MAY be mapped to predefined atom elements or custom content within the entry. The mapping is described through attributes in the metadata.
The mapping may specify whether the property value appears within the metadata:properties
element as well as being mapped, however in the case of a null value the property MUST always appear within the metadata:properties
element as an empty element with the metadata:null="true"
attribute.
For more information on the format of the mapping specification, see OData:CSDL.
A valid OData payload may consist of a single primitive or complex property.
For example, a request for the first name of a given customer may return the following payload:
{% highlight xml %} CEO
{% endhighlight %}
Similarly, the following payload represents a full name:
{% highlight xml %}
Julie
Swansworth
{% endhighlight %}
A valid OData payload MAY consist of a collection of primitive or complex properties. A collection is a single root element containing zero or more
For example, the following payload represents a collection of phone numbers.
{% highlight xml %}
(203)555-1718
(203)555-1719
{% endhighlight %}
Similarly, the following payload represents a collection of full names.
{% highlight xml %}
Julie
Swansworth
Mark
Swansworth
{% endhighlight %}
Atom defines the concept of a Service Document to represent the set of available collections. OData uses Service Documents to describe the set of entity sets available through the service.
app:service
elementThe atom ServiceDocument is represented by the app:service
element. The app:service
element contains one or more app:workspaces
, which represents a set of collections.
app:workspace
elementOData represents entity containers as app:workspace
elements. An app:workspace
element contains zero or more app:collections
.
app:collection
elementOData describes available collections of entities as app:collection
elements.
The app:collection
element MUST contain an href
attribute which represents a URL that can be used to retrieve the members of the entity set.
atom:title
elementThe atom:title
element within the app:collection
SHOULD contain the name of the entity set.
Links represent the relationships between an entity and related entity(s).
The link(s) available from a particular entity for a particular relationship can be retrieved from the service as a colleciton of URIs within a data:links
element.
data:links
ElementA data:link
element represents the set of references from one entity to all related entities according to a particular relationship.
The reference for each related entity is represented as a data:uri
element that appears as a direct child of the data:links
element.
For example, a query for links to Products within the Category with ID=1:
{% highlight xml %}https://services.odata.org/OData/OData.svc/Categories(1)$links/Products
{% endhighlight %}
might return the following XML response:
{% highlight xml %}
https://services.odata.org/OData/OData.svc/Products(1)
https://services.odata.org/OData/OData.svc/Products(2)
https://services.odata.org/OData/OData.svc/Products(3)
https://services.odata.org/OData/OData.svc/Products(4)
https://services.odata.org/OData/OData.svc/Products(5)
https://services.odata.org/OData/OData.svc/Products(6)
{% endhighlight %}
data:uri
ElementEach related entity is represented as a data:uri
element, which appears as a direct child of a data:link
element.
The content of the data:uri
element is the Canonical URL for the related entity.
In the case of an error being generated in response to a request specifying an Accept
header of application/xml
or application/atom+xml
, or that does not specify an Accept
header, the service MUST respond with with an error formatted as XML.
When formatting error responses as XML, servers SHOULD include a Content-Type
response header with the value "application/xml"
.
metadata:error
ElementErrors formatted as XML have a root metadata:error
element. The metadata:error
element MUST have two child elements: metadata:code
and metadata:message
.
In addition, errors may be annotated using custom annotations
For example:
{% highlight xml %}
BDRQST
Bad Request - Error in query syntax.
{% endhighlight %}
metadata:code
ElementThe metadata:error
element MUST contain a metadata:code
element specifying a service-defined string. This value MAY be used to provide a more specific substatus to the returned HTTP response code.
metadata:message
ElementThe metadata:error
element MUST contain a metadata:message
element specifying a human readable message describing the error.
The metadata:message
element MAY contain an xml:lang
attribute to specify the language of the error message.
metadata:innererror
ElementThe metadata:error
element MAY contain a metadata:innererror
element containing service specific debugging information that might assist a service implementer in determining the cause of an error.
The metadata:innererror
element SHOULD only be used in development environments in order to guard against potential security concerns around information disclosure.
Implementations MAY add custom content anywhere allowed by RFC4287, Section 6, “Extending Atom”. However, custom elements and attributes MUST NOT be defined in the OData Data Namespace nor the OData Metadata Namespace, and SHOULD not be required to be understood by the receiving party in order to correctly interpret the rest of the payload.


Picking refers to the process of figuring out which object a user clicked on or touched. There are tons of ways to implement picking each with their tradeoffs. Let's go over the 2 most common.
Probably the most common way of picking is by doing raycasting which means to cast a ray from the mouse through the frustum of the scene and computing which objects that ray intersects. Conceptually it's very simple.
First we'd take the position of the mouse. We'd convert that into world space by applying the camera's projection and orientation. We'd compute a ray from the near plane of the camera's frustum to the far plane. Then, for every triangle of every object in the scene we'd check if that ray intersects that triangle. If your scene has 1000 objects and each object has 1000 triangles then 1 million triangles will need to be checked.
A few optimizations would include first checking if the ray intersects with an object's bounding sphere or bounding box, the sphere or box that contains the entire object. If the ray doesn't intersect one of those then we don't have to check the triangles of that object.
THREE.js provides a RayCaster
class that does exactly this.
Let's make a scene with a 100 objects and try picking them. We'll start with an example from the article on responsive pages
A few changes
We'll parent the camera to another object so we can spin that other object and the camera will move around the scene just like a selfie stick.
*const fov = 60; const aspect = 2; // the canvas default const near = 0.1; *const far = 200; const camera = new THREE.PerspectiveCamera(fov, aspect, near, far); *camera.position.z = 30; const scene = new THREE.Scene(); +scene.background = new THREE.Color('white'); +// put the camera on a pole (parent it to an object) +// so we can spin the pole to move the camera around the scene +const cameraPole = new THREE.Object3D(); +scene.add(cameraPole); +cameraPole.add(camera);
and in the render
function we'll spin the camera pole.
cameraPole.rotation.y = time * .1;
Also let's put the light on the camera so the light moves with it.
-scene.add(light); +camera.add(light);
Let's generate 100 cubes with random colors in random positions, orientations, and scales.
const boxWidth = 1; const boxHeight = 1; const boxDepth = 1; const geometry = new THREE.BoxGeometry(boxWidth, boxHeight, boxDepth); function rand(min, max) { if (max === undefined) { max = min; min = 0; } return min + (max - min) * Math.random(); } function randomColor() { return `hsl(${rand(360) | 0}, ${rand(50, 100) | 0}%, 50%)`; } const numObjects = 100; for (let i = 0; i < numObjects; ++i) { const material = new THREE.MeshPhongMaterial({ color: randomColor(), }); const cube = new THREE.Mesh(geometry, material); scene.add(cube); cube.position.set(rand(-20, 20), rand(-20, 20), rand(-20, 20)); cube.rotation.set(rand(Math.PI), rand(Math.PI), 0); cube.scale.set(rand(3, 6), rand(3, 6), rand(3, 6)); }
And finally let's pick.
Let's make a simple class to manage the picking
class PickHelper { constructor() { this.raycaster = new THREE.Raycaster(); this.pickedObject = null; this.pickedObjectSavedColor = 0; } pick(normalizedPosition, scene, camera, time) { // restore the color if there is a picked object if (this.pickedObject) { this.pickedObject.material.emissive.setHex(this.pickedObjectSavedColor); this.pickedObject = undefined; } // cast a ray through the frustum this.raycaster.setFromCamera(normalizedPosition, camera); // get the list of objects the ray intersected const intersectedObjects = this.raycaster.intersectObjects(scene.children); if (intersectedObjects.length) { // pick the first object. It's the closest one this.pickedObject = intersectedObjects[0].object; // save its color this.pickedObjectSavedColor = this.pickedObject.material.emissive.getHex(); // set its emissive color to flashing red/yellow this.pickedObject.material.emissive.setHex((time * 8) % 2 > 1 ? 0xFFFF00 : 0xFF0000); } } }
You can see we create a RayCaster
and then we can call the pick
function to cast a ray through the scene. If the ray hits something we change the color of the first thing it hits.
Of course we could call this function only when the user pressed the mouse down which is probably usually what you want but for this example we'll pick every frame whatever is under the mouse. To do this we first need to track where the mouse is
const pickPosition = {x: 0, y: 0}; clearPickPosition(); ... function getCanvasRelativePosition(event) { const rect = canvas.getBoundingClientRect(); return { x: (event.clientX - rect.left) * canvas.width / rect.width, y: (event.clientY - rect.top ) * canvas.height / rect.height, }; } function setPickPosition(event) { const pos = getCanvasRelativePosition(event); pickPosition.x = (pos.x / canvas.width ) * 2 - 1; pickPosition.y = (pos.y / canvas.height) * -2 + 1; // note we flip Y } function clearPickPosition() { // unlike the mouse which always has a position // if the user stops touching the screen we want // to stop picking. For now we just pick a value // unlikely to pick something pickPosition.x = -100000; pickPosition.y = -100000; } window.addEventListener('mousemove', setPickPosition); window.addEventListener('mouseout', clearPickPosition); window.addEventListener('mouseleave', clearPickPosition);
Notice we're recording a normalized mouse position. Regardless of the size of the canvas we need a value that goes from -1 on the left to +1 on the right. Similarly we need a value that goes from -1 on the bottom to +1 on the top.
While we're at it lets support mobile as well
window.addEventListener('touchstart', (event) => { // prevent the window from scrolling event.preventDefault(); setPickPosition(event.touches[0]); }, {passive: false}); window.addEventListener('touchmove', (event) => { setPickPosition(event.touches[0]); }); window.addEventListener('touchend', clearPickPosition);
And finally in our render
function we call the PickHelper
's pick
function.
+const pickHelper = new PickHelper(); function render(time) { time *= 0.001; // convert to seconds; ... + pickHelper.pick(pickPosition, scene, camera, time); renderer.render(scene, camera); ...
and here's the result
This appears to work great and it probably does for many use cases but there are several issues.
It's CPU based.
JavaScript is going through each object and checking if the ray intersects that object's bounding box or bounding sphere. If it does then JavaScript has to go through each and every triangle in that object and check if the ray intersects the triangle.
The good part of this is JavaScript can easily compute exactly where the ray intersected the triangle and provide us with that data. For example if you wanted to put a marker where the intersection happened.
The bad part is that's a lot of work for the CPU to do. If you have objects with lots of triangles it might be slow.
It doesn't handle any strange shaders or displacements.
If you have a shader that deforms or morphs the geometry JavaScript has no knowledge of that deformation and so will give the wrong answer. For example AFAIK you can't use this method with skinned objects.
It doesn't handle transparent holes.
As an example let's apply this texture to the cubes.
We'll just make these changes
+const loader = new THREE.TextureLoader(); +const texture = loader.load('resources/images/frame.png'); const numObjects = 100; for (let i = 0; i < numObjects; ++i) { const material = new THREE.MeshPhongMaterial({ color: randomColor(), +map: texture, +transparent: true, +side: THREE.DoubleSide, +alphaTest: 0.1, }); const cube = new THREE.Mesh(geometry, material); scene.add(cube); ...
And running that you should quickly see the issue
Try to pick something through a box and you can't
This is because JavaScript can't easily look into the textures and materials and figure out if part of your object is really transparent or not.
A solution all of these issues is to use GPU based picking. Unfortunately while it is conceptually simple it is more complicated to use than the ray casting method above.
To do GPU picking we render each object in a unique color offscreen. We then look up the color of the pixel corresponding to the mouse position. The color tells us which object was picked.
This can solve issue 2 and 3 above. As for issue 1, speed, it really depends. Every object has to be drawn twice. Once to draw it for viewing and again to draw it for picking. It's possible with fancier solutions maybe both of those could be done at the same time but we're not going to try that.
One thing we can do though is since we're only going to be reading one pixel we can just setup the camera so only that one pixel is drawn. We can do this using PerspectiveCamera.setViewOffset
which lets us tell THREE.js to compute a camera that just renders a smaller part of a larger rectangle. This should save some time.
To do this type of picking in THREE.js at the moment requires we create 2 scenes. One we will fill with our normal meshes. The other we'll fill with meshes that use our picking material.
So, first create a second scene and make sure it clears to black.
const scene = new THREE.Scene(); scene.background = new THREE.Color('white'); const pickingScene = new THREE.Scene(); pickingScene.background = new THREE.Color(0);
Then, for each cube we place in the main scene we make a corresponding "picking cube" at the same position as the original cube, put it in the pickingScene
, and set its material to something that will draw the object's id as its color. Also we keep a map of ids to objects so when we look up an id later we can map it back to its corresponding object.
const idToObject = {}; +const numObjects = 100; for (let i = 0; i < numObjects; ++i) { + const id = i + 1; const material = new THREE.MeshPhongMaterial({ color: randomColor(), map: texture, transparent: true, side: THREE.DoubleSide, alphaTest: 0.1, }); const cube = new THREE.Mesh(geometry, material); scene.add(cube); + idToObject[id] = cube; cube.position.set(rand(-20, 20), rand(-20, 20), rand(-20, 20)); cube.rotation.set(rand(Math.PI), rand(Math.PI), 0); cube.scale.set(rand(3, 6), rand(3, 6), rand(3, 6)); + const pickingMaterial = new THREE.MeshPhongMaterial({ + emissive: new THREE.Color(id), + color: new THREE.Color(0, 0, 0), + specular: new THREE.Color(0, 0, 0), + map: texture, + transparent: true, + side: THREE.DoubleSide, + alphaTest: 0.5, + blending: THREE.NoBlending, + }); + const pickingCube = new THREE.Mesh(geometry, pickingMaterial); + pickingScene.add(pickingCube); + pickingCube.position.copy(cube.position); + pickingCube.rotation.copy(cube.rotation); + pickingCube.scale.copy(cube.scale); }
Note that we are abusing the MeshPhongMaterial
here. By setting its emissive
to our id and the color
and specular
to 0 that will end up rendering the id only where the texture's alpha is greater than alphaTest
. We also need to set blending
to NoBlending
so that the id is not multiplied by alpha.
Note that abusing the MeshPhongMaterial
might not be the best solution as it will still calculate all our lights when drawing the picking scene even though we don't need those calculations. A more optimized solution would make a custom shader that just writes the id where the texture's alpha is greater than alphaTest
.
Because we're picking from pixels instead of ray casting we can change the code that sets the pick position to just use pixels.
function setPickPosition(event) { const pos = getCanvasRelativePosition(event); - pickPosition.x = (pos.x / canvas.clientWidth ) * 2 - 1; - pickPosition.y = (pos.y / canvas.clientHeight) * -2 + 1; // note we flip Y + pickPosition.x = pos.x; + pickPosition.y = pos.y; }
Then let's change the PickHelper
into a GPUPickHelper
. It will use a WebGLRenderTarget
like we covered the article on render targets. Our render target here is only a single pixel in size, 1x1.
-class PickHelper { +class GPUPickHelper { constructor() { - this.raycaster = new THREE.Raycaster(); + // create a 1x1 pixel render target + this.pickingTexture = new THREE.WebGLRenderTarget(1, 1); + this.pixelBuffer = new Uint8Array(4); this.pickedObject = null; this.pickedObjectSavedColor = 0; } pick(cssPosition, scene, camera, time) { + const {pickingTexture, pixelBuffer} = this; // restore the color if there is a picked object if (this.pickedObject) { this.pickedObject.material.emissive.setHex(this.pickedObjectSavedColor); this.pickedObject = undefined; } + // set the view offset to represent just a single pixel under the mouse + const pixelRatio = renderer.getPixelRatio(); + camera.setViewOffset( + renderer.getContext().drawingBufferWidth, // full width + renderer.getContext().drawingBufferHeight, // full top + cssPosition.x * pixelRatio | 0, // rect x + cssPosition.y * pixelRatio | 0, // rect y + 1, // rect width + 1, // rect height + ); + // render the scene + renderer.setRenderTarget(pickingTexture) + renderer.render(scene, camera); + renderer.setRenderTarget(null); + + // clear the view offset so rendering returns to normal + camera.clearViewOffset(); + //read the pixel + renderer.readRenderTargetPixels( + pickingTexture, + 0, // x + 0, // y + 1, // width + 1, // height + pixelBuffer); + + const id = + (pixelBuffer[0] << 16) | + (pixelBuffer[1] << 8) | + (pixelBuffer[2] ); - // cast a ray through the frustum - this.raycaster.setFromCamera(normalizedPosition, camera); - // get the list of objects the ray intersected - const intersectedObjects = this.raycaster.intersectObjects(scene.children); - if (intersectedObjects.length) { - // pick the first object. It's the closest one - this.pickedObject = intersectedObjects[0].object; + const intersectedObject = idToObject[id]; + if (intersectedObject) { + // pick the first object. It's the closest one + this.pickedObject = intersectedObject; // save its color this.pickedObjectSavedColor = this.pickedObject.material.emissive.getHex(); // set its emissive color to flashing red/yellow this.pickedObject.material.emissive.setHex((time * 8) % 2 > 1 ? 0xFFFF00 : 0xFF0000); } } }
Then we just need to use it
-const pickHelper = new PickHelper(); +const pickHelper = new GPUPickHelper();
and pass it the pickScene
instead of the scene
.
- pickHelper.pick(pickPosition, scene, camera, time); + pickHelper.pick(pickPosition, pickScene, camera, time);
And now it should let you pick through the transparent parts
I hope that gives some idea of how to implement picking. In a future article maybe we can cover how to manipulate objects with the mouse.


Dropper Demo
View Documentation
Basic
Dropper will create a simple 'drop zone' for file uploads:
$(".target").dropper({
action: "upload.php"
});

Demo
Uploads
Dropper does not store or manipulate uploaded files on the server, it simply facilitates the asynchronous upload process from the front end.


Match Play. Red trails 3-5 to 11. Should Red redouble to 8? If redoubled, should White take?
pips Red=59 White=138
(CorrectAnswer= 0/0, ErrorScore= 0)
My biggest blunder this year! I was White against Romolo Mudu in the quarter-final of the Consolation at the London Open.
I dropped the redouble, not wanting to lose the match on this game if Red rolled a six.
Muddy thinking. Red is not favourite to escape his checker and may well leave a home board blot next turn. With the cube on 8 gammons are irrelevant for both players and Red only wins 55% of the time – a trivially easy take for White and in fact no double from Red. Red does much better to play on for a gammon with the cube on 4, which is enough to win the match for him.
A shocking pass and one I am not proud of!!
For money this would be redouble and take because now Red gets full value from his gammons.
I dropped the redouble, not wanting to lose the match on this game if Red rolled a six.
Muddy thinking. Red is not favourite to escape his checker and may well leave a home board blot next turn. With the cube on 8 gammons are irrelevant for both players and Red only wins 55% of the time – a trivially easy take for White and in fact no double from Red. Red does much better to play on for a gammon with the cube on 4, which is enough to win the match for him.
A shocking pass and one I am not proud of!!
For money this would be redouble and take because now Red gets full value from his gammons.
Cube analysis 2-ply cubeless equity +0.681 (Money: +0.501) 0.564 0.417 0.002 - 0.436 0.047 0.000 Cubeful equities: 1. No double +0.735 2. Double, pass +1.000 (+0.265) 3. Double, take +0.697 (-0.038) Proper cube action: No redouble, take (12.6%)


Specify the project key. A project key is the all capitals part before the issue number in Jira.
(EXAMPLE-100)


The metal:define-macro
attribute
The metal:define-macro
attribute indicates that the element upon which it appears is a METAL macro.
The value of this attribute indicates the name of that macro.
The names of METAL macros defined within a document template must be unique within that template.
Consuming a METAL macro
The presence of a metal:define-macro
attribute alone has no effect upon how that element or any of its descendents will render in the output.
To make use of a METAL macro created via the metal:define-macro
attribute, the macro must be consumed.
This is accomplished via the metal:use-macro
attribute.
A METAL macro
A METAL macro is the subtree of the DOM beginning at the element upon which the metal:define-macro
attribute appears.
That is, the macro is the defining element as well as all of its content & descendents.
Macro slots
Macros may contain zero or more slots, each designated via the metal:define-slot
attribute.
The element which has the metal:define-macro
attribute may not also have a metal:define-slot
attribute but any of its descendents may.
Macro extension
An element which defines a METAL macro via metal:define-macro
may optionally be declared as an extension of another existing macro.
This is accomplished by placing a metal:extend-macro
attribute upon the same element.
metal:extend-macro
attributes are only valid where they appear upon the same element as a metal:define-macro
attribute.
Example
This example shows the definition of a METAL macro named "myMacro".
As noted above, this (alone) has no direct effect upon rendering.
The macro is the entire subtree of the DOM starting at the

element which defines the macro.
In other words, it is the

element and all of its content & descendents.

This is not part of the macro.

This heading is part of the macro

So is this paragraph, as well as this emphasized text.

This is also not part of the macro.


Video: Tulsa native Tim Blake Nelson talks about his role, Oklahoma setting on HBO's 'Watchmen'
by Brandy McDonnellLast week's fifth episode of the critically acclaimed HBO series "Watchmen" revealed the origins of Tulsa native Tim Blake Nelson's character, Tulsa Police Detective Wade Tillman, who wears a reflective mask and goes by the alter ego Looking Glass.
As previously reported, Damon Lindelof’s (“Lost,” “The Leftovers”) spin-off on “Watchmen,” the trailblazing 1986-87 DC comic book by writer Alan Moore and artist Dave Gibbons, is set in an alternate-reality version of Tulsa, with the 1921 Tulsa Race Massacre playing a key role in the series.
The folks at the Oklahoma Museum of Popular Culture recently talked to Nelson about "Watchmen" and the show's Tulsa setting:
"Watchmen" Episode 5, titled "Little Fear of Lighting," reairs at 6:45 tonight on HBO2, with the new installment, "This Extraordinary Being," premiering at 8 tonight on HBO.
-BAM
Related Photos


Toggles change tracking. When change tracking is on all differences between the current file and the file on disk (ie, as it was when opened or last saved) are highlighted. The color used to highlight the changes is taken from the color scheme in use in the active file - use the color Options page to change the Change Tracking color or to select a different color scheme.
Changes are shown in this way:
Replacements are underlined.
Insertions are shown with a highlighted background
Deletions have a mark at the byte after the deletion.
If less than 10 bytes are deleted the number of deleted bytes is displayed in between the bytes in hex view.
If more than 10 bytes have been an asterisk is displayed.
Note that you can only insert or delete bytes if you are in insert mode (see Insert Mode Toggle). And you can't even replace bytes in read-only mode (see Allow Changes Toggle).
Also note that the changes displayed do not reflect the actual editing operations performed only the differences between the current file and what is saved on disk. For example if you delete 5 bytes then insert 5 bytes at the same location this will be shown as 5 bytes having been replaced.
Shortcuts
Toolbar:


Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning
Superviced Learning


{% load static %}
Home
About Us
Contact Us
{% if user.is_authenticated %}
({{ user.username }})
Logout
{% else %}
{% csrf_token %}
Login
Sign Up
{% endif %}
{% if user.is_authenticated%}
Add a Review about this Dealership
{% csrf_token %}
Enter the review content:
Have you purchased a car from this Dealership?
True
False
If purhcased, please give us more information:
Car Make
Car Model
Model Year
Select your purchase date:
Submit Review
{% else %}
Sign up to Review
{% endif %}


interface MinedTransaction : Transaction
Parent type for transactions that have been mined. This is useful for putting all transactions in one list for things like history. A mined tx should have all properties, except possibly a memo.
blockTimeInSeconds |
abstract val blockTimeInSeconds: Long |
minedHeight |
abstract val minedHeight: Int |
noteId |
abstract val noteId: Long |
rawTransactionId |
abstract val rawTransactionId: ByteArray |
transactionIndex |
abstract val transactionIndex: Int |
ConfirmedTransaction |
A mined, shielded transaction. Since this is a MinedTransaction, it represents data on the blockchain. data class ConfirmedTransaction : MinedTransaction, SignedTransaction |


A typographic exploration into the development of communication, inspired by the 150th anniversary of the Penny Black – the world’s first adhesive postage stamp. The historic timeline is visualized on each page with the clever use of horizontal and vertical lines which interrupt and influence the layout of each spread. Historic documentation and photography are displayed throughout. The timeline was carried onto the exterior of the book in the form of a single red string across the binding. The book was hand finished and perfect bound.


Connecting to Ixian DLT...
has sent a CONTACT REQUEST
Accept
Ignore
Send File
Request Payment
Send Payment


Given a valid region name, return a boto.sts.connection.STSConnection.
| Type: | str |
|---|---|
| Parameters: | region_name – The name of the region to connect to. |
| Return type: | boto.sts.connection.STSConnection or None |
| Returns: | A connection to the given region, or None if an invalid region name is given |
Get all available regions for the STS service.
| Return type: | list |
|---|---|
| Returns: | A list of boto.regioninfo.RegionInfo instances |
AWS Security Token Service The AWS Security Token Service is a web service that enables you to request temporary, limited-privilege credentials for AWS Identity and Access Management (IAM) users or for users that you authenticate (federated users). This guide provides descriptions of the AWS Security Token Service API.
For more detailed information about using this service, go to `Using Temporary Security Credentials`_.
For information about setting up signatures and authorization through the API, go to `Signing AWS API Requests`_ in the AWS General Reference . For general information about the Query API, go to `Making Query Requests`_ in Using IAM . For information about using security tokens with other AWS products, go to `Using Temporary Security Credentials to Access AWS`_ in Using Temporary Security Credentials .
If you’re new to AWS and need additional technical information about a specific AWS product, you can find the product’s technical documentation at `http://aws.amazon.com/documentation/`_.
We will refer to Amazon Identity and Access Management using the abbreviated form IAM. All copyrights and legal protections still apply.
Returns a set of temporary security credentials (consisting of an access key ID, a secret access key, and a security token) that you can use to access AWS resources that you might not normally have access to. Typically, you use AssumeRole for cross-account access or federation.
For cross-account access, imagine that you own multiple accounts and need to access resources in each account. You could create long-term credentials in each account to access those resources. However, managing all those credentials and remembering which one can access which account can be time consuming. Instead, you can create one set of long-term credentials in one account and then use temporary security credentials to access all the other accounts by assuming roles in those accounts. For more information about roles, see `Roles`_ in Using IAM .
For federation, you can, for example, grant single sign-on access to the AWS Management Console. If you already have an identity and authentication system in your corporate network, you don’t have to recreate user identities in AWS in order to grant those user identities access to AWS. Instead, after a user has been authenticated, you call AssumeRole (and specify the role with the appropriate permissions) to get temporary security credentials for that user. With those temporary security credentials, you construct a sign-in URL that users can use to access the console. For more information, see `Scenarios for Granting Temporary Access`_ in AWS Security Token Service .
The temporary security credentials are valid for the duration that you specified when calling AssumeRole, which can be from 900 seconds (15 minutes) to 3600 seconds (1 hour). The default is 1 hour.
The temporary security credentials that are returned from the AssumeRoleWithWebIdentity response have the permissions that are associated with the access policy of the role being assumed and any policies that are associated with the AWS resource being accessed. You can further restrict the permissions of the temporary security credentials by passing a policy in the request. The resulting permissions are an intersection of the role’s access policy and the policy that you passed. These policies and any applicable resource-based policies are evaluated when calls to AWS service APIs are made using the temporary security credentials.
To assume a role, your AWS account must be trusted by the role. The trust relationship is defined in the role’s trust policy when the IAM role is created. You must also have a policy that allows you to call sts:AssumeRole.
Important: You cannot call Assumerole by using AWS account credentials; access will be denied. You must use IAM user credentials to call AssumeRole.
| Parameters: |
|
|---|
Returns a set of temporary security credentials for users who have been authenticated via a SAML authentication response. This operation provides a mechanism for tying an enterprise identity store or directory to role-based AWS access without user-specific credentials or configuration.
The temporary security credentials returned by this operation consist of an access key ID, a secret access key, and a security token. Applications can use these temporary security credentials to sign calls to AWS services. The credentials are valid for the duration that you specified when calling AssumeRoleWithSAML, which can be up to 3600 seconds (1 hour) or until the time specified in the SAML authentication response’s NotOnOrAfter value, whichever is shorter.
The maximum duration for a session is 1 hour, and the minimum duration is 15 minutes, even if values outside this range are specified.
Optionally, you can pass an AWS IAM access policy to this operation. The temporary security credentials that are returned by the operation have the permissions that are associated with the access policy of the role being assumed, except for any permissions explicitly denied by the policy you pass. This gives you a way to further restrict the permissions for the federated user. These policies and any applicable resource-based policies are evaluated when calls to AWS are made using the temporary security credentials.
Before your application can call AssumeRoleWithSAML, you must configure your SAML identity provider (IdP) to issue the claims required by AWS. Additionally, you must use AWS Identity and Access Management (AWS IAM) to create a SAML provider entity in your AWS account that represents your identity provider, and create an AWS IAM role that specifies this SAML provider in its trust policy.
Calling AssumeRoleWithSAML does not require the use of AWS security credentials. The identity of the caller is validated by using keys in the metadata document that is uploaded for the SAML provider entity for your identity provider.
For more information, see the following resources:
| Parameters: |
|---|
| Parameters: | policy (string) – |
|---|
An AWS IAM policy in JSON format.
| Parameters: | duration_seconds (integer) – |
|---|
Returns a set of temporary security credentials for users who have been authenticated in a mobile or web application with a web identity provider, such as Login with Amazon, Facebook, or Google. AssumeRoleWithWebIdentity is an API call that does not require the use of AWS security credentials. Therefore, you can distribute an application (for example, on mobile devices) that requests temporary security credentials without including long-term AWS credentials in the application or by deploying server-based proxy services that use long-term AWS credentials. For more information, see `Creating a Mobile Application with Third-Party Sign-In`_ in AWS Security Token Service .
The temporary security credentials consist of an access key ID, a secret access key, and a security token. Applications can use these temporary security credentials to sign calls to AWS service APIs. The credentials are valid for the duration that you specified when calling AssumeRoleWithWebIdentity, which can be from 900 seconds (15 minutes) to 3600 seconds (1 hour). By default, the temporary security credentials are valid for 1 hour.
The temporary security credentials that are returned from the AssumeRoleWithWebIdentity response have the permissions that are associated with the access policy of the role being assumed. You can further restrict the permissions of the temporary security credentials by passing a policy in the request. The resulting permissions are an intersection of the role’s access policy and the policy that you passed. These policies and any applicable resource-based policies are evaluated when calls to AWS service APIs are made using the temporary security credentials.
Before your application can call AssumeRoleWithWebIdentity, you must have an identity token from a supported identity provider and create a role that the application can assume. The role that your application assumes must trust the identity provider that is associated with the identity token. In other words, the identity provider must be specified in the role’s trust policy. For more information, see ` Creating Temporary Security Credentials for Mobile Apps Using Third-Party Identity Providers`_.
| Parameters: |
|
|---|
Decodes additional information about the authorization status of a request from an encoded message returned in response to an AWS request.
For example, if a user is not authorized to perform an action that he or she has requested, the request returns a Client.UnauthorizedOperation response (an HTTP 403 response). Some AWS actions additionally return an encoded message that can provide details about this authorization failure. Only certain AWS actions return an encoded authorization message. The documentation for an individual action indicates whether that action returns an encoded message in addition to returning an HTTP code. The message is encoded because the details of the authorization status can constitute privileged information that the user who requested the action should not see. To decode an authorization status message, a user must be granted permissions via an IAM policy to request the DecodeAuthorizationMessage ( sts:DecodeAuthorizationMessage) action.
The decoded message includes the following type of information:
| Parameters: | encoded_message (string) – The encoded message that was returned with the response. |
|---|
Returns a set of temporary security credentials (consisting of an access key ID, a secret access key, and a security token) for a federated user. A typical use is in a proxy application that is getting temporary security credentials on behalf of distributed applications inside a corporate network. Because you must call the GetFederationToken action using the long- term security credentials of an IAM user, this call is appropriate in contexts where those credentials can be safely stored, usually in a server-based application.
Note: Do not use this call in mobile applications or client-based web applications that directly get temporary security credentials. For those types of applications, use AssumeRoleWithWebIdentity.
The GetFederationToken action must be called by using the long-term AWS security credentials of the AWS account or an IAM user. Credentials that are created by IAM users are valid for the specified duration, between 900 seconds (15 minutes) and 129600 seconds (36 hours); credentials that are created by using account credentials have a maximum duration of 3600 seconds (1 hour).
The permissions that are granted to the federated user are the intersection of the policy that is passed with the GetFederationToken request and policies that are associated with of the entity making the GetFederationToken call.
For more information about how permissions work, see `Controlling Permissions in Temporary Credentials`_ in Using Temporary Security Credentials . For information about using GetFederationToken to create temporary security credentials, see `Creating Temporary Credentials to Enable Access for Federated Users`_ in Using Temporary Security Credentials .
| Parameters: |
|
|---|
Return a valid session token. Because retrieving new tokens from the Secure Token Service is a fairly heavyweight operation this module caches previously retrieved tokens and returns them when appropriate. Each token is cached with a key consisting of the region name of the STS endpoint concatenated with the requesting user’s access id. If there is a token in the cache meeting with this key, the session expiration is checked to make sure it is still valid and if so, the cached token is returned. Otherwise, a new session token is requested from STS and it is placed into the cache and returned.
| Parameters: |
|
|---|
| Variables: |
|
|---|
| Variables: |
|
|---|
Create and return a new Session Token based on the contents of a JSON document.
| Parameters: | json_doc (str) – A string containing a JSON document with a previously saved Credentials object. |
|---|
Checks to see if the Session Token is expired or not. By default it will check to see if the Session Token is expired as of the moment the method is called. However, you can supply an optional parameter which is the number of seconds of offset into the future for the check. For example, if you supply a value of 5, this method will return a True if the Session Token will be expired 5 seconds from this moment.
| Parameters: | time_offset_seconds (int) – The number of seconds into the future to test the Session Token for expiration. |
|---|
Create and return a new Session Token based on the contents of a previously saved JSON-format file.
| Parameters: | file_path (str) – The fully qualified path to the JSON-format file containing the previously saved Session Token information. |
|---|
Persist a Session Token to a file in JSON format.
| Parameters: | path (str) – The fully qualified path to the file where the the Session Token data should be written. Any previous data in the file will be overwritten. To help protect the credentials contained in the file, the permissions of the file will be set to readable/writable by owner only. |
|---|
Return a Python dict containing the important information about this Session Token.
| Variables: |
|
|---|
| Variables: |
|
|---|


PRELUDE:
This evening i decided to try this beautiful herb, Salvia divinorum. I had purchased a 10X extract online, and it arrived this morning. I was eager and excited to try it, but I decided I would wait till the time was right.
So, this evening when I was sure to be alone with no disruptions I decided after a short time of meditation, relaxation and preperation, now was the time.
My bedroom is somewhere I always feel calm and contemplative so I thought what better place to break through into the Salvia experience for the first time than here. I closed the door, turned my lamp on at the side of my bed, carefully positioning it so as to emit a dull light. I lay upon my bed, bong in hand and eye-balled out about 1/15th of a gram (a common dose on Erowid's Salvia divinorum Dosage chart). I filled the bowl, leaving the smallest bit of Salvia (a moment of apprehension and anxiety) to the side....maybe I'd need it later.
After inhaling and holding in the tasteless, smooth smoke for roughly 30 seconds, I exhaled. Within a minute or so (I couldnt say exactly) I could feel myself gently 'floating' into what I was about to experience.
THE EXPERIENCE:
I saw, or rather felt, or rather percieved to have seen in my minds eye (let me add I had turned my lamp off by this time, with much difficulty finding the switch. My eyes closed.) a small speedboat travelling across the sea, bumping up and down and spraying a jet of foam behind it. Several people were on it, their faces I couldnt make out but I think I, or rather a part of me, was on it. Before I knew it, my 'viewpoint' had switched (like a camera zooming in) to behind the wheel of the craft, only there was no wheel.
Blankness....but still travelling. Then again seeing what seemed to be a stronger 'essence' of me atop a creature with the head of a white bear and the white wings of a bird, flying/travelling ....gone....blankness again.
Next my whole perception of this 'new world' around me had changed somehow. I cant place my finger on it, it just had.
The darkness around me (my eyes were now open) had taken a form, a substance. Snakes or rather sentient tubes of darkness/form were interweaving into, out of, through the darkness, into each other, consuming each other then reforming. I looked for a source from which these 'snakes' came from only to find they came from the darkness itself. This is hard to explain in words (like many things in this strange salvia journey), but let me say it was a rather strange thing to percieve.
Next the darkness took a different form. Suddenly I was transported to inside a tube (perhaps one of the 'snakes'????). Just sitting there cross legged. There was perhaps a wind blowing through the tube, or an energy. Then the tube closed in and I found myself inside an orb of darkness.
Then the orb (this made me think of cell division) split/divided into two. With my body, or rather 'self' 'split' straight through the middle with one side of my 'self' inside each smaller orb. Again this is VERY hard to explain. My consiousness seemed to be thinking inside each different orb about the same things only percieving them in completely different ways.
I was finished with the journey, or rather the journey was finished with me. So to cut a very long story short I will say the Journey gently eased back to reality with MUCH contemplation, insight and philosophising about the nature of this beautiful reality.
CONCLUSION:
I have half a gram of this beautiful smelling, innocent looking herb to last me. I will DEFINATELY take another Journey into the 'Salvia Reality'. Soon, but when the time is right. Or when I am right for the time. I have decided I will grow some of this amazing herb. And I have also decided to go even deeper into my already spiritual journey in life. Salvia has helped me see a whole lot more, and clarified a lot I had already thought about.
Thankyou Salvia divinorum.
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.


Provides functions to read 'ImageJ' (http://imagej.nih.gov/ij/) Region of Interest (ROI) files, to plot the ROIs and to convert them to 'spatstat' (http://spatstat.org/) spatial patterns.
| Version: | 0.1.1 |
| Depends: | R (≥ 3.0.2) |
| Imports: | spatstat |
| Suggests: | png, testthat |
| Published: | 2015-05-07 |
| Author: | David C Sterratt [aut, cph, cre], Mikko Vihtakari [aut, cph] |
| Maintainer: | David C Sterratt <david.c.sterratt at ed.ac.uk> |
| License: | GPL-3 |
| URL: | https://github.com/davidcsterratt/RImageJROI |
| NeedsCompilation: | no |
| Materials: | NEWS |
| CRAN checks: | RImageJROI results |
| Reference manual: | RImageJROI.pdf |
| Package source: | RImageJROI_0.1.1.tar.gz |
| Windows binaries: | r-devel: RImageJROI_0.1.1.zip, r-release: RImageJROI_0.1.1.zip, r-oldrel: RImageJROI_0.1.1.zip |
| OS X binaries: | r-release: RImageJROI_0.1.1.tgz, r-oldrel: RImageJROI_0.1.1.tgz |
| Old sources: | RImageJROI archive |
| Reverse depends: | sclero |
| Reverse imports: | retistruct |
Please use the canonical form https://CRAN.R-project.org/package=RImageJROI to link to this page.


ALTIBA ALTIDA ALTIHA Do You Remember The 'TISS Quiz'? more.. The 'Vitual TISS Campus'. more.. An Informal Evening With Old Friends. more..


Hello, and welcome to my server!
My server's documentation:
USERS
https://documenter.getpostman.com/view/10085267/SzKYQxc2?version=latest
This shows you the documentation for registering a user
ITEMS
https://documenter.getpostman.com/view/10085267/SzKZsFws?version=latest
This shows you the documentation for the item endpoints


Robot Simulations Ltd.Products for robot simulation, calibration and offline programming Welcome to the home page for Robot Simulations Ltd, developers of the Workspace ® PC based robot simulation and offline programming software and the Robotrak ® calibration device. The latest information on these products can be found here as well as downloadable demonstration software. |
Come and see us at
November 12-14
Cobo Hall, Detroit, MI, USA
Free tickets can be arranged by calling our North American Dealer, RWT, at<PHONE_NUMBER>
Workspace ® utilised in development fo new robot: Mitsubishi PA-10 and controller language offered with Workspace ® release 4.0


Plots univariate comparison graphs, an alternative to boxplot/stripchart/violin plot.
| Version: | 1.2 |
| Suggests: | vioplot, lattice |
| Published: | 2014-09-19 |
| Author: | Peter Kampstra |
| Maintainer: | Peter Kampstra <beanplot at kampstra.net> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| Citation: | beanplot citation info |
| CRAN checks: | beanplot results |
| Reference manual: | beanplot.pdf |
| Vignettes: |
Beanplot: A Boxplot Alternative for Visual Comparison of Distributions |
| Package source: | beanplot_1.2.tar.gz |
| Windows binaries: | r-devel: beanplot_1.2.zip, r-release: beanplot_1.2.zip, r-oldrel: beanplot_1.2.zip |
| OS X binaries: | r-release: beanplot_1.2.tgz, r-oldrel: beanplot_1.2.tgz |
| Old sources: | beanplot archive |
| Reverse imports: | rdi, regplot |
| Reverse suggests: | datarobot, deBInfer, SPEDInstabR, vipor, WRS2 |
Please use the canonical form https://CRAN.R-project.org/package=beanplot to link to this page.


Misty's Staryu
Misty uses Staryu often as one of her main battling Pokémon throughout most of the series. It often shimmers when called into battles, and its core glows pink accompanied by a siren-like noise when tired or weakened.


| DOSE: |
2 hits |
smoked |
DMT |
(powder / crystals) |
This was my first experience with what a lot of you will know to be the most powerful hallucinogenic substance available. Up until this point I had been a hardcore Cannabis user to the point that my life was very shaky, often putting 'getting high' above other life pursuits and the people that love me. This experience was truly amazing as it was my first time with high level hallucinogenics. It was certainly one of the most pleasant experiences of my life to date and really made me re-think a lot of what I thought I understood about religion and the universe. Any way, I shall begin.
A friend of mine, K, had been talking about this substance; DMT. I had never heard of it before. After much research about where it's from and what it can do, I decided to take the plunge. That day I had been smoking Cannabis and was still a bit strung out. K came up into my room and suggested we turn off the all the lights but one and remain in complete silence. He demonstrated the effects on himself with a small dose. He appeared calm and spoke quietly to me afterwards about his experience.
He then handed me the glass bong. Crystal DMT sandwiched between the inert Damiana. He instructed me, and I thank him for this as it gave the experience a much more shamanic atmosphere. I filled the chamber and inhaled. Held. Released. Repeat. I stared around the room as the path of the light seem to become visible.  I had a strange sense of cartoonishness. I closed my eyes and was greeted by a beautiful purple fractal pattern. I traveled onwards into this 'portal' until suddenly blocked by an almost visible 'Guard'. I opened my eyes. It all seemed like some sort of hilarious joke. I laughed and shook my head. The experience was shortly over.
K looked at me with a playful glint in his eye as he prepared the next dose. It wasn't until afterwards that he advised it was 3-4 times larger then the previous one. I performed the smoking ritual, the glass water pipe in my hand appearing alien, something I had been advised of by many experienced users of the substance.
I felt/heard a 'woosh' and the deep warm echo of a strange music. K spoke one last time before the silence. 'Lie down' He whispered. So I did. My 'eyes' (which were closed) looked up into the sky. A glittering Kaleidescope of stars. Up I went, forward through the galaxy at an impossible rate. In the distance I saw an amazing fractal that I can relate only to a strange corruption of a heartbeat monitor.
And there it was. A purple form flowing infinitely, a golden light emanating from its 'forehead', eyes fading in and out of visibility on its 'body'. A face manifested, one that I can only relate to the image of a Hindu god. I was surrounded by the feeling of absolute bliss. I felt that no trouble would come to me while I was in the presence of this majestic entity.
I again looked up, as my eye was caught by the flowing black hair of a beautiful woman peeking into the scene. She gave me the impression that she loved me entirely and would remain by my side. I stared down and right and it seemed as if I was in a magnificent auditorium. Looking on at the Hindu entity was a deep black shadow, flowing similarly to the purple being, but with a far more malicious intent. It looked back at me with glowing red eyes. I smiled, knowing that while meeting the 'creator' (a term that I gave the purple being) I would come to no harm.
I had a feeling I should open my eyes. So I did. My hands! How strange. I did not regret doing this at all as I felt a common divinity with all human beings at this point. I closed my eyes once again and was shown an image of the earth from a satellite perspective. A man with a flowing white beard stared at me, smiling warmly, gesturing towards the earth. Beside him stood a red queen. They loved each other and they loved me.
These are two characters I experienced in later DMT experiments. However, that is for another day. At this point I raised both my hands, still with eyes closed. In one hand I felt a masculine presence, in the other a feminine. I brought them together in what seemed a perfectly reasonable ritual. The warmth that flowed through my veins was almost orgasmic.
I got the sense that this was the King of Men and his queen. A divine representation of Man and Woman. The scene faded and I was once again in space. Amazing. I pictured what I believed to be a black hole, visibly sucking in solid 'worms' of 'matter' and spitting them out in infinite shards of turquoise light. I was given a closer look at this 'worm' of power. Organic, yet artificial. Writhing and pulsating with an incomprehensible energy.
I was taken to a final scene. An endless ocean below me and it seemed as if I was flying just above the surface, a beautiful orange sky above it. In the distance, I saw a man superimposed. His hair was thickly dreadlocked and in his hand he held a device from which he was smoking. A character that, again, I experienced in later trips in a much darker context. He disappeared and the ocean continued forever.
I opened my eyes and sat up. K looked at me with pupils as big as the world and he just smiled. 'You were away for about 15 minutes there man' He chuckled. 'Really? It seemed like much, much longer'.
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.


Torque 2D - Fish Demo Tutorial - Part 8
8. Config Datablock
Now that we have our fish behaving
properly, we need to duplicate that fish. One way we could do that would be to
drag over new animated fish and set up each of the settings we've already set.
Fortunately, there is an easier way to accomplish this: we can use a config
datablock. A config datablock is just a basic object that can hold any
sort of object data. This would be object data that you want to be repeated
across multiple objects. When you create an object, you can specify a config
datablock, and all valid data will be used. If your object has already set a
data value, which is also set on the config datablock, then your object's data
will take precedence (as it should). As you can imagine this is immensely
useful for assigning similar data to multiple objects. Browse out to your MyFishDemo/game/gameScripts
folder and locate a file named datablocks.cs . Add this
config datablock to the end of your file.
datablock t2dSceneObjectDatablock(FishDatablock) { Class = "FishClass"; Layer = "16"; WorldLimitMode = "NULL"; WorldLimitMin = "-66.2102 -45"; WorldLimitMax = "66.1003 45"; WorldLimitCallback = "1"; minSpeed = "5"; maxSpeed = "25"; };
Code Sample 8.1.1
As you can see, we have all the important values we just set on our single fish. The two values you might not be familiar with are the WorldLimitMin and WorldLimitMax values. From -66 to 66 it spans the entire space that we visually specified in the Level Builder. We have a class of FishClass, our layer as 16, our proper world limit mode and min and max values, and our callback option. We also have our two dynamic fields for our min and max speeds. Make sure you save your datablocks.cs file.
8.2
Creating fish using our config datablock
Now that we have our config datablock, we need to allow T2D to register it. This requires you to click the Project -> Reload Project option. This will close and reload the current project to register our new config datablock. We can add in any of the fish Animated sprites of our choice and simply set the config datablock. To set the config datablock make sure the object is selected, click the EDIT tab, the Script rollout and select our FishDatablock from the config datablock dropdown. Drag and drop about 3 fish from your Animated Sprites object library into your level (as shown in Figure 8.2.1) and set their config datablocks accordingly. Save your level and then play your level. Your new fish should swim around just like the original (as shown in Figure 8.2.2).
|
|
|
|
|
|


A new way to create and build online communities!
Spixi Bot allows you to create your own chat server for
Spixi Decentralized Messenger.
Whether you are a part of a gaming or any other interest group, you can enjoy secure communication and other features that only Spixi can provide.
Promote your services or products, interact with your friends and receive payment.
Hi, I am Spixi Bot! I will help you create and manage your very own Spixi server.
Spixi is the next generation messaging platform.


{{syncingText}}
To register, simply put a unique email address and enter a comment. To login, enter an existing email address and press login. Open Developer Tools to see the operations.


Don't want the URL to be {{domain}}/{{slug}}?
Change the part after the / in the browser address bar at any time!
Tip: use something catchy or memorable, perhaps related to the birthday theme. Example: {{domain}}/minecraft. Don't be surprised if someone is already using it though! Be creative!


the and with for virus that are viral which {background coronavirus may respiratory infection margin SARS-CoV- can {border-style also from The human other px;} #ffffff;} have RNA was anti-viral potential disease new patients severe were acute coronaviruses has host immune such understanding been not plasma their these this while This including most replication vaccine COVID- cellular convalescent could during individuals syndrome treatment well CoV any associated based high infection. influenza its novel px; response viruses yet {font-family Infect against animal antibodies data development different drugs effective enable font-size genome identify important infected number pandemic target transmission Engl between control coronaviruses, double; drug emergence even help infection, likely major molecular more protein protein, spread testing viruses, when will (ACE) Betacoronavirus However, These border-color border-width but disease, diseases emerging enzyme genetic given hCoVs highly identified infect infections into involves many outbreak. particular people should solid; some subsequent tests they used vaccines virion years {font-style {font-weight Accordingly, All Common Ebola Finally, Med Med./NEJMoa SARS SARS-CoV-, Therefore, acid addition, animals assays basic being bold cases, cause cell cold, context courier; developing diagnostic does effects either em; evaluation family genomic hCoV-NL how knowledge known large like long-term lower need newly outbreak over pathogenic pneumonia prevention protection proteins provides pt;} range rapid receptor response, safe screening sequence study symptoms than therapeutic through together virus, viruses. who


PAYMENT UNSUCCESSFUL
We are unable to receive your payment.
Please review your payment information and try again or select a different payment method. If you continue to encounter problems, please email<EMAIL_ADDRESS>for assistance. Thank you very much.


We Find, You Love, Simply
Find the apartment of your dreams. Exactly matching your profile.
Fastest/Most suitable Options
We did heavy lifting for you. You can thank us later.
Find the apartment of your dreams. Exactly matching your profile.
We did heavy lifting for you. You can thank us later.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/experiment.20on.20students.html ---
Like Kevin, I decided to jump the gun and teach students how to write crappy Lean code like professional mathematicians. This morning I showed Lean to the head of the Maths-CS double major program at Orsay. She was very excited and I will probably get about twenty first year undergraduate students to experiment on during the spring semester next year.
FYI, the file I used is at https://github.com/PatrickMassot/lean-scratchpad/blob/master/src/demo.lean it only depends on https://github.com/PatrickMassot/lean-scratchpad/blob/master/src/choice.lean (and mathlib of course)
Of course it's focused on very explicit inefficient tactic mode, not code golf
Having undergraduates to experiment on is really good fun. It's all about the interface, with them. I will be paying particular attention to what my undergraduates struggle with and my guess is that most of the time their struggles will be because they can do something in maths but not in Lean. Ideally the Lean proof should look as mathematical as possible.
I must say part of my plan is to use whatever insight and documentation you will continue to accumulate
You even managed to squeeze some French into the demo! Bonus points (-;
How valuable would it be to have (some) tutorials in video format? I'm wondering if it would be worth looking into doing that kind of presentation
I think videos could be nice. We could also have semi-interactive web pages with Lean code you could navigate and see the Lean status corresponding to each line, precomputed, not computed in real time. This should be a very easy exercise in using Lean in server mode.
I'm actually making a video in a couple of weeks, it was going to be a general one on dependent type theory. We have a bunch of fancy video-making kit at my university and some people are keen for me to try it out.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


{{onText}}
Right Hand
Right Hand
wrist
thumb
index
majeure
ringFinger
pinky
Left Hand
Left Hand
wrist
thumb
index
majeure
ringFinger
pinky
Back
rightHand is:
rightHand is:
Save rightHand.wrist Config
rightHand is:
rightThumb Sensor:
This is a work in progress:
Start rightHand Sensor
Test sensor values
Save rightHand.thumb Config
rightHand is:
rightIndex Sensor:
This is a work in progress:
Start rightHand Sensor
Test sensor values
Save rightHand.index Config
rightHand is:
rightMajeure Sensor:
This is a work in progress:
Start rightHand Sensor
Test sensor values
Save rightHand.majeure Config
rightHand is:
rightRingFinger Sensor:
This is a work in progress:
Start rightHand Sensor
Test sensor values
Save rightHand.ringFinger Config
rightHand is:
This is a work in progress:
Start rightHand Sensor
Test sensor values
Save rightHand.pinky Config
leftHand is:
leftHand is:
Save leftHand.wrist Config
leftHand is:
leftThumb Sensor:
This is a work in progress
Start leftHand Sensor
Test sensor values
Save leftHand.thumb Config
leftHand is:
leftIndex Sensor:
This is a work in progress
Start leftHand Sensor
Test sensor values
Save leftHand.index Config
leftHand is:
leftMajeure Sensor:
This is a work in progress
Start leftHand Sensor
Test sensor values
Save leftHand.majeure Config
leftHand is:
leftRingFinger Sensor:
This is a work in progress
Start leftHand Sensor
Test sensor values
Save leftHand.ringFinger Config
leftHand is:
leftPinky Sensor:
This is a work in progress
Start leftHand Sensor
Test sensor values
Save leftHand.pinky Config


The Bay of Arcachon lies about 50nm south of the Gironde. The town of Arcachon is a holiday resort, well known for its sandy beaches and for the growing Pyla sand dune in the bay.
Position 44° 33'30"W, 01° 18'17"W (river/bay entrance)
There is a dangerous sand bar across the entrance to the bay which moves, and it is essential to ensure it is safe to enter. Although conditions out to sea may be calm, this is not necessarily the situation over the bar.
Call Cap Ferret Signal Station on VHF CH16 or Tel: +33<PHONE_NUMBER> and they will advise if and when it is safe to enter.
Changes to the entrance channel
The entrance is tricky and has severe tides.
The channel has moved around 300m East.
Follow the lateral buoys, taking advice from Cap Ferret coastguard as to where in the channel is deepest. The most dangerous stretch is where the channel turns N and swell over the sandbanks is beam on.
A cruiser report indicates that facilities are in poor condition and that a one night stay is expensive.
Last updated June 2016.


How to send a letter to Santa - and ensure he replies
by Judy RimmerHow can you make sure your child's letter gets to Santa - and that he sends them a letter back?
The NSPCC mailroom is now taking orders for their 'Letter from Santa' for children in Suffolk and around the UK.
Since 2001 the children's charity has delivered 84,308 festive messages from Father Christmas across East Anglia, bringing joy to the youngsters who receive the letters.
In placing their orders over the past 18 years generous family and friends in the region have also donated £502,627 to the NSPCC.
Lisa Williams from the NSPCC's Individual Giving Team said: "There are few better ways to mark the beginning of the festive period than by ordering a 'Letter from Santa' for a special child in your life and donating to the NSPCC."
Across the UK and Channel Islands, more than two million letters have been ordered and delivered, with over £12million being raised for the charity's work to stop child abuse.
This Christmas, family and friends can build children a personalised Letter from Santa, choosing from eight new illustrations, including 'Reindeer Flying Practice', 'Christmas Disco' and 'Elves are Ready to Go!'
Each letter can be tailored with details including the child's hobbies, best friend or family member's name and a special message.
Letters are also age appropriate, with shorter text that is easier to read for younger children.
Chocolate company Lindt is sponsoring the Letter from Santa service for the fifth year running.
The deadline for ordering letters is November 26 for overseas, December 4 for Europe and 16 December for UK. You can order your letter, for a suggested donation of £5, by visiting the NSPCC's website.