Sources
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
See Also
Tables
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Tables
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| id_tipo_automotor |
int |
|
| hash |
varchar(50) |
|
| modelo |
varchar(250) |
|
| matricula |
varchar(200) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| tipoautomotor |
id_tipo_automotor |
automotor |
id |
| automotor |
id_automotor |
servicio |
id |
Indexes
| Name |
Type |
Columns |
Description |
| IDX_27A426F47A5DA61F |
Non-unique |
id_tipo_automotor |
|
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| hash |
varchar(50) |
|
| nombre |
varchar(255) |
|
| descripcion |
varchar(255) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| cargo |
id_cargo |
empleado |
id |
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| identificacion |
varchar(255) |
|
| nombre |
varchar(255) |
|
| apellido |
varchar(255) |
|
| genero |
varchar(45) |
|
| f_nacimiento |
date |
|
| direccion |
varchar(200) |
|
| telefono |
varchar(200) |
|
| celular |
varchar(200) |
|
| email |
varchar(200) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| cliente |
id_cliente |
servicio |
id |
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| id_cargo |
int |
|
| identificacion |
varchar(255) |
|
| nombre |
varchar(255) |
|
| apellido |
varchar(255) |
|
| genero |
varchar(45) |
|
| f_nacimiento |
date |
|
| direccion |
varchar(200) |
|
| telefono |
varchar(200) |
|
| celular |
varchar(200) |
|
| email |
varchar(200) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| empleado |
id_empleado |
servicio |
id |
| empleado |
id_empleado |
prestamo |
id |
| cargo |
id_cargo |
empleado |
id |
Indexes
| Name |
Type |
Columns |
Description |
| IDX_20AFDD04D56B1641 |
Non-unique |
id_cargo |
|
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| hash |
varchar(50) |
|
| id_usuario |
int |
|
| valor |
varchar(255) |
|
| iva |
varchar(255) |
|
| total |
varchar(255) |
|
| observacion |
varchar(255) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| factura |
id_factura |
facturadetalle |
id |
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| id_factura |
int |
|
| id_servicio |
int |
|
| hash |
varchar(50) |
|
| cantidad |
varchar(255) |
|
| valor |
varchar(255) |
|
| iva |
varchar(255) |
|
| total |
varchar(255) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| factura |
id_factura |
facturadetalle |
id |
| servicio |
id_servicio |
facturadetalle |
id |
Indexes
| Name |
Type |
Columns |
Description |
| IDX_AA0EC6AA27760979 |
Non-unique |
id_factura |
|
| IDX_AA0EC6AA9B5D1EBF |
Non-unique |
id_servicio |
|
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| username |
varchar(255) |
|
| username_canonical |
varchar(255) |
|
| email |
varchar(255) |
|
| email_canonical |
varchar(255) |
|
| enabled |
tinyint |
|
| salt |
varchar(255) |
|
| password |
varchar(255) |
|
| last_login |
datetime |
|
| locked |
tinyint |
|
| expired |
tinyint |
|
| expires_at |
datetime |
|
| confirmation_token |
varchar(255) |
|
| password_requested_at |
datetime |
|
| roles |
longtext |
(DC2Type:array)
|
| credentials_expired |
tinyint |
|
| credentials_expire_at |
datetime |
|
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
| UNIQ_957A647992FC23A8 |
Unique |
username_canonical |
|
| UNIQ_957A6479A0D96FBF |
Unique |
email_canonical |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| id_grl_region |
int |
|
| codigo |
varchar(15) |
|
| nombre |
varchar(27) |
|
| latitud |
varchar(15) |
|
| longitud |
varchar(15) |
|
| estado |
varchar(15) |
|
Indexes
| Name |
Type |
Columns |
Description |
| id_grl_region |
Non-unique |
id_grl_region |
|
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| nombre |
varchar(100) |
|
| estado |
varchar(50) |
|
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| id_empleado |
int |
|
| hash |
varchar(50) |
|
| valor |
varchar(255) |
|
| observacion |
varchar(255) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| empleado |
id_empleado |
prestamo |
id |
Indexes
| Name |
Type |
Columns |
Description |
| IDX_DAE16A4890253C7 |
Non-unique |
id_empleado |
|
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| id_tipo_rubro |
int |
|
| hash |
varchar(50) |
|
| nombre |
varchar(255) |
|
| descripcion |
varchar(45) |
|
| valor |
varchar(200) |
|
| iva |
varchar(200) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| rubro |
id_rubro |
servicio |
id |
| tiporubro |
id_tipo_rubro |
rubro |
id |
Indexes
| Name |
Type |
Columns |
Description |
| IDX_534743EB31B076F0 |
Non-unique |
id_tipo_rubro |
|
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| id_cliente |
int |
|
| id_empleado |
int |
|
| id_automotor |
int |
|
| id_rubro |
int |
|
| hash |
varchar(50) |
|
| estado_servicio |
varchar(255) |
|
| observacion |
varchar(255) |
|
| pago |
varchar(255) |
|
| fecha_servicio |
datetime |
|
| fecha_entrega |
datetime |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| rubro |
id_rubro |
servicio |
id |
| empleado |
id_empleado |
servicio |
id |
| servicio |
id_servicio |
facturadetalle |
id |
| automotor |
id_automotor |
servicio |
id |
| cliente |
id_cliente |
servicio |
id |
Indexes
| Name |
Type |
Columns |
Description |
| IDX_32F0907C25601870 |
Non-unique |
id_automotor |
|
| IDX_32F0907C2A813255 |
Non-unique |
id_cliente |
|
| IDX_32F0907C7C032DDF |
Non-unique |
id_rubro |
|
| IDX_32F0907C890253C7 |
Non-unique |
id_empleado |
|
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| hash |
varchar(50) |
|
| nombre |
varchar(255) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| hash |
varchar(50) |
|
| nombre |
varchar(255) |
|
| descripcion |
varchar(255) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| tipoautomotor |
id_tipo_automotor |
automotor |
id |
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.
Columns
| Name |
Type |
Description |
| id |
int |
|
| hash |
varchar(50) |
|
| nombre |
varchar(255) |
|
| descripcion |
varchar(255) |
|
| estado |
varchar(1) |
|
| fecha |
datetime |
|
Relationships
| Primary Table |
Primary Key |
Foreign Table |
Foreign Key |
| tiporubro |
id_tipo_rubro |
rubro |
id |
Indexes
| Name |
Type |
Columns |
Description |
| PRIMARY |
Unique |
id |
|
Notice
This document was created with the trial version of TechWriter.
This notice is removed once a valid license is purchased.
Visit www.adivo.com for purchase options.


Chat Application
Chats
User Profile
Contacts List
Create
New Group
Add Contact
Toggle navigation
Hello Krishna Chaitanya
Change Password
Logout
Browse
Update
Krishna Chaitanya Varma
Edit Profile
ID
Value:
Username
Email address
First Name
Last Name
Gender
Male
Female
Date of Birth
Contact No.
Address
State
Andhra Pradesh
Tamil Nadu
Kerala
Karnataka
Country
India
Japan
Singapore
South Africa
Postal Code
Update Profile
Username
Old Password
New Password
Retype Password
Change


1. CityJSON Object
A CityJSON object represents one 3D city model of a given area, this model may contain features of different types, as defined in the CityGML data model.
-
A CityJSON object is a JSON object.
-
A CityJSON object must have the following 4 members:
-
one member with the name
"type"
, whose value must be"CityJSON"
; -
one member with the name
"version"
, whose value must be a string with the version (X.Y) of CityJSON used. Observe that while schemas can have a version with patch version (X.Y.Z), a CityJSON object points only to the minor version (X.Y), and for validation the latest schema of that minor version should be used. -
one member with the name
"CityObjects"
. The value of this member is a collection of key-value pairs, where the key is the ID of the object, and the value is one City Object. The ID of a City Object should be unique (within one CityJSON Object). -
one member with the name
"vertices"
, whose value is an array of coordinates of each vertex of the city model. Their position in this array (0-based) is used as an index to be referenced by the Geometric Objects. The indexing mechanism of the format Wavefront OBJ is basically reused.
-
-
A CityJSON may have one member with the name
"extensions"
, used if there are Extensions used in the file. -
A CityJSON may have one member with the name
"metadata"
, whose value may be a JSON object describing the coordinate reference system used, the extent of the dataset, its creator, etc. -
A CityJSON may have one member with the name
"transform"
, whose value if a JSON object describing how to decompress the coordinates. Transform is used to reduce the file size only. -
A CityJSON may have one member with name
"appearance"
, the value may contain JSON objects representing the textures and/or materials of surfaces. -
A CityJSON may have one member with name
"geometry-templates"
, the value is a JSON object containing the templates that can be reused by different City Objects (usually for trees). This is equivalent to the concept of "implicit geometries" in CityGML. -
A CityJSON may have other members, and their value is not prescribed. Because these are not standard in CityJSON, they might be ignored by parsers.
The minimal valid CityJSON object is thus:
{ "type" : "CityJSON" , "version" : "1.0" , "CityObjects" : {}, "vertices" : [] }
An "empty" CityJSON will look like this:
{ "type" : "CityJSON" , "version" : "1.0" , "extensions" : {}, "metadata" : {}, "transform" : { "scale" : [], "translate" : [] }, "CityObjects" : {}, "vertices" : [], "appearance" : {}, "geometry-templates" : {} }
2. City Object types
A City Object is a JSON object for which the type member’s value is one of the following (of type string):
| 1st-level | 2nd-level |
|---|---|
"Building"
| "BuildingPart" , "BuildingInstallation"
|
"Bridge"
| "BridgePart" , "BridgeInstallation" , "BridgeConstructionElement"
|
"CityObjectGroup"
| |
"CityFurniture"
| |
"GenericCityObject"
| |
"LandUse"
| |
"PlantCover"
| |
"Railway"
| |
"Road"
| |
"SolitaryVegetationObject"
| |
"TINRelief"
| |
"TransportSquare"
| |
"Tunnel"
| "TunnelPart" , "TunnelInstallation"
|
"WaterBody"
|
There are 2 kinds of City Objects, this is because the schema of CityGML has been flattened out. Both types are represented as a City Object in a CityJSON Object.
-
1st-level: City Objects that can "exist by themselves".
-
2nd-level: City Objects that need to have a
"parents"
to exist.
For example, a "BuildingInstallation"
cannot be present in a dataset without being the "children"
of a "Building"
, but a "Building"
can be present by itself.
A City Object:
-
must have one member with the name
"geometry"
, whose value is an array containing 0 or more Geometry Objects. More than one Geometry Object is used to represent several different levels-of-detail (LoDs) for the same object. However, the different Geometry Objects of a given City Object do not have be of different LoDs. -
may have one member with the name
"attributes"
, whose value is an object with the different attributes allowed by CityGML. -
may have one member with the name
"geographicalExtent"
(the axis-aligned bounding box of the City Object), whose value is an array with 6 values:[minx, miny, minz, maxx, maxy, maxz]
-
may have one member
"children"
, which consists of an array of the IDs (of type string) of the 2nd-level City Objects that are part of the City Object. A City Object can have different types of City Objects as children, eg a"Building"
can have both as children"BuildingPart"
and"BuildingInstallation"
. The order of the children in the array is not relevant. -
of type 2nd-level must have one member
"parents"
, which consists of an array of the IDs (of type string) of the City Objects that are its parents. For the City Objects in the core module of CityJSON, this array will always be of size 1 (only one parent). New City Objects defined in extensions can have more than one parents. Notice that a 2nd-level City Object may also have one member"children"
(for instance for a"BuildingPart"
that contains a"BuildingInstallation"
).
"CityObjects" : { "id-1" : { "type" : "Building" , "geographicalExtent" : [ 84710.1 , 446846.0 , - 5.3 , 84757.1 , 446944.0 , 40.9 ], "attributes" : { "measuredHeight" : 22.3 , "roofType" : "gable" , "owner" : "Elvis Presley" }, "children" : [ "id-2" ], "geometry" : [{...}] }, "id-2" : { "type" : "BuildingPart" , "parents" : [ "id-1" ], ... }, "id-3" : { "type" : "BuildingInstallation" , "parents" : [ "id-1" ], ... }, "id-4" : { "type" : "LandUse" , ... } }
2.1. Attributes
The attributes prescribed by CityGML differ per City Object, and can be seen either in the official CityGML documentation or in the schemas of CityJSON.
In CityJSON, any other attributes not prescribed by the CityGML data model can be added with a JSON key-value pair ("owner" in the example above is one such attribute) in the "attributes"
of a City Object.
All the City Objects have the following 3 possible attributes:
-
"class"
-
"function"
-
"usage"
While CityGML does not prescribe the values for these, the SIG 3D maintains a codelist that can be used. In CityJSON, as can be seen in the schemas, the values should be a string, thus either the name of the values should be used, or the code as a string:
"CityObjects" : { "id-1" : { "type" : "LandUse" , "attributes" : { "function" : "Industry and Business" }, "geometry" : [{...}] }, "id-2" : { "type" : "WaterBody" , "attributes" : { "class" : "1010" }, "geometry" : [{...}] } }
2.2. Building
Three City Objects are related to buildings: "Building"
, "BuildingPart"
, and "BuildingInstallation"
.
The geometry of both "Building"
and "BuildingPart"
can only be represented with these Geometry Objects: (1) "Solid"
, (2) "CompositeSolid"
, (3) "MultiSurface"
.
The geometry of a "BuildingInstallation"
object can be represented with any of the Geometry Objects.
A City Object of type "Building"
or "BuildingPart"
may have a member "address"
, whose value is a JSON object describing the address. One location (a "MultiPoint"
) can be given, for instance to position the front door inside the building.
"CityObjects" : { "id-1" : { "type" : "Building" , "attributes" : { "roofType" : "gable" }, "geographicalExtent" : [ 84710.1 , 446846.0 , - 5.3 , 84757.1 , 446944.0 , 40.9 ], "children" : [ "id-56" , "id-832" , "mybalcony" ] }, "id-56" : { "type" : "BuildingPart" , "parents" : [ "id-1" ], ... }, "mybalcony" : { "type" : "BuildingInstallation" , "parents" : [ "id-1" ], ... } }
{ "type" : "Building" , "address" : { "CountryName" : "Canada" , "LocalityName" : "Chibougamau" , "ThoroughfareNumber" : "1" , "ThoroughfareName" : "rue de la Patate" , "PostalCode" : "H0H 0H0" }, }
2.3. Transportation
CityJSON uses 3 classes related to transportation ("Road"
, "Railway"
, "TransportSquare"
) and omits the "Track" from CityGML because it simply can be a road with specific attributes. "TransportSquare"
is used to model for instance parking lots and squares.
In CityGML, each of the 3 classes can have a number of "TrafficArea" and "AuxiliaryTrafficArea", which are defined as new surfaces. In CityJSON, these surfaces do not need to be defined again since the road surfaces become Semantic Surface Objects (with type "TrafficArea"
or "AuxiliaryTrafficArea"
). That is, the surface representing a road should be split into sub-surfaces (therefore forming a "MultiSurface"
or a "CompositeSurface"
), and each of the sub-surfaces get a semantics attached to it.
The geometry of a City Object of type "Road"
, "Railway"
, "TransportSquare"
can be of types "MultiSurface"
, "CompositeSurface"
or "MultiLineString"
.
"ma_rue" : { "type" : "Road" , "geometry" : [{ "type" : "MultiSurface" , "lod" : 2 , "boundaries" : [ [[ 0 , 3 , 2 , 1 , 4 ]], [[ 4 , 5 , 6 , 666 , 12 ]], [[ 0 , 1 , 5 ]], [[ 20 , 21 , 75 ]] ] }], "semantics" : { "surfaces" : [ { "type" : "TrafficArea" , "surfaceMaterial" : [ "asphalt" ], "function" : "road" }, { "type" : "AuxiliaryTrafficArea" , "function" : "green areas" }, { "type" : "TrafficArea" , "surfaceMaterial" : [ "dirt" ], "function" : "road" } ], "values" : [ 0 , 1 , null , 2 ] } }
2.4. TINRelief
The geometry of a City Object of type "TINRelief"
can only be of type "CompositeSurface"
.
CityJSON does not define a specific Geometry Object for a TIN (triangulated irregular network), it is simply a CompositeSurface for which every surface is a triangle (thus a polygon having 3 vertices, and no interior ring).
"myterrain01" : { "type" : "TINRelief" , "geographicalExtent" : [ 84710.1 , 446846.0 , - 5.3 , 84757.1 , 446944.0 , 40.9 ], "geometry" : [{ "type" : "CompositeSurface" , "lod" : 2 , "boundaries" : [ [[ 0 , 3 , 2 ]], [[ 4 , 5 , 6 ]], [[ 0 , 1 , 5 ]], [[ 1 , 2 , 6 ]], [[ 2 , 3 , 7 ]], [[ 3 , 0 , 4 ]] ] }] }
2.5. WaterBody
The geometry of a City Object of type "WaterBody"
can be of types: "MultiLineString"
, "MultiSurface"
, "CompositeSurface"
, "Solid"
, or "CompositeSolid"
.
"mygreatlake" : { "type" : "WaterBody" , "attributes" : { "usage" : "leisure" , }, "geometry" : [{ "type" : "Solid" , "lod" : 2 , "boundaries" : [ [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]] ] ] }] }
2.6. LandUse
The geometry of a City Object of type "LandUse"
can be of type "MultiSurface"
or "CompositeSurface"
.
"oneparcel" : { "type" : "LandUse" , "geometry" : [{ "type" : "MultiSurface" , "lod" : 1 , "boundaries" : [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]] ] }] }
2.7. PlantCover
The geometry of a City Object of type "PlantCover"
can be of type "MultiSurface"
or "MultiSolid"
.
"plants" : { "type" : "PlantCover" , "attributes" : { "averageHeight" : 11.05 }, "geometry" : [{ "type" : "MultiSolid" , "lod" : 2 , "boundaries" : [ [ [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 10 , 13 , 22 , 31 ]] ] ], [ [ [[ 5 , 34 , 31 , 12 ]], [[ 44 , 54 , 62 , 74 ]], [[ 10 , 111 , 445 , 222 ]], [[ 111 , 123 , 922 , 66 ]] ] ] ] }] }
2.8. SolitaryVegetationObject
The geometry of a City Object of type "SolitaryVegetationObject"
can be any of the following: "MultiPoint"
, "MultiLineString"
, "MultiSurface"
, "CompositeSurface"
, "Solid"
, or "CompositeSolid"
.
"onebigtree" : { "type" : "SolitaryVegetationObject" , "attributes" : { "trunkDiameter" : 5.3 , "crownDiameter" : 11.0 }, "geometry" : [{ "type" : "MultiPoint" , "lod" : 0 , "boundaries" : [ 1 ] }] }
2.9. CityFurniture
The geometry of a City Object of type "CityFurniture"
can be any of the following: "MultiPoint"
, "MultiLineString"
, "MultiSurface"
, "CompositeSurface"
, "Solid"
, or "CompositeSolid"
.
"stop" : { "type" : "CityFurniture" , "attributes" : { "function" : "bus stop" }, "geometry" : [{ "type" : "MultiSurface" , "lod" : 2 , "boundaries" : [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]] ] }] }
2.10. GenericCityObject
The geometry of a City Object of type "GenericCityObject"
can be any of the following: "MultiPoint"
, "MultiLineString"
, "MultiSurface"
, "CompositeSurface"
, "Solid"
, or "CompositeSolid"
.
"whatisthat" : { "type" : "GenericCityObject" , "attributes" : { "usage" : "it’s not clear" }, "geometry" : [{ "type" : "CompositeSurface" , "lod" : 1 , "boundaries" : [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]] ] }] }
2.11. Bridge
Four City Objects are related to bridges: "Bridge"
, "BridgePart"
, "BridgeInstallation"
, and "BridgeConstructionElement"
.
The geometry of both "Bridge"
and "BridgePart"
can only be represented with these Geometry Objects: (1) "Solid"
, (2) "CompositeSolid"
, (3) "MultiSurface"
.
The geometry of a "BridgeInstallation"
or "BridgeConstructionElement"
object can be represented with any of the Geometry Objects.
A City Object of type "Bridge"
or "BridgePart"
may have a member "address"
, whose value is a JSON object describing the address. One location (a "MultiPoint"
) can be given, for instance to locate the front door inside the building.
"CityObjects" : { "LondonTower" : { "type" : "Bridge" , "address" : { "CountryName" : "UK" , "LocalityName" : "London" }, "children" : [ "Bext1" , "Bext2" , "Inst-2017-11-14" ], "geometry" : [{ "type" : "MultiSurface" , "lod" : 2 , "boundaries" : [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 1 , 2 , 6 , 5 ]], [[ 2 , 3 , 7 , 6 ]], [[ 3 , 0 , 4 , 7 ]] ] }] } }
2.12. Tunnel
Three City Objects are related to tunnels: "Tunnel"
, "TunnelPart"
, and "TunnelInstallation"
.
The geometry of both "Tunnel"
and "TunnelPart"
can only be represented with these Geometry Objects: (1) "Solid"
, (2) "CompositeSolid"
, (3) "MultiSurface"
.
The geometry of a "TunnelInstallation"
object can be represented with any of the Geometry Objects.
"CityObjects" : { "Lærdalstunnelen" : { "type" : "Tunnel" , "attributes" : { "yearOfConstruction" : 2000 , "length" : "24.5km" }, "children" : [ "stoparea1" ], "geometry" : [{ "type" : "Solid" , "lod" : 2 , "boundaries" : [ [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]] ] ] }] } }
2.13. CityObjectGroup
The CityGML concept of groups, where City Objects are aggregated based on certain criteria (think of a neighbourhood for instance), is possible in CityJSON. As in CityGML, the group is a City Object, and it can contain, if needed, a geometry (the polygon representing the neighbourhood for instance).
A City Object of type "CityObjectGroup"
must have a member "members"
, whose value is an array of the IDs of the City Objects that the group contains. Since a "CityObjectGroup"
is also a City Object, it can be part of another group.
As for other City Objects, a City Object of type "CityObjectGroup"
may have a member "geometry"
, although only one geometry is allowed in the array of geometries.
"CityObjects" : { "my-neighbourhood" : { "type" : "CityObjectGroup" , "members" : [ "building1" , "building2" ], "geometry" : [{ "type" : "MultiSurface" , "lod" : 2 , "boundaries" : [ [[ 2 , 4 , 5 ]] ] }] } }
3. Geometry Objects
CityJSON defines the following 3D geometric primitives, all of them are embedded in 3D space (and therefore their vertices have (x, y, z) coordinates). The indexing mechanism of the format Wavefront OBJ is reused, that is a geometry does not store the locations of its vertices, but points to a vertex in a list (property "vertices"
in the CityJSON Object).
As is the case in CityGML, only linear and planar primitives are allowed; no curves or parametric surfaces can be represented.
A Geometry object is a JSON object for which the type member’s value is one of the following:
-
"MultiPoint"
-
"MultiLineString"
-
"MultiSurface"
-
"CompositeSurface"
-
"Solid"
-
"MultiSolid"
-
"CompositeSolid"
A Geometry object:
-
must have one member with the name
"lod"
, whose value is a number identifying the level-of-detail (LoD) of the geometry. This can be either an integer (following the CityGML standards), or a number following the improved LoDs by TU Delft -
must have one member with the name
"boundaries"
, whose value is a hierarchy of arrays (the depth depends on the Geometry object) with integers. An integer refers to the index in the"vertices"
array of the CityJSON object, and it is 0-based (ie the first element in the array has the index "0", the second one "1", etc.). -
may have one member
"semantics"
, whose value is a JSON Object, as defined below. -
may have one member
"material"
, whose value is a JSON Object, as defined below. -
may have one member
"texture"
, whose value is a JSON Object, as defined below.
"geometry"
member of a CityObject, the different geometries may be enumerated in the array (all with the same value for the member "lod"
). 3.1. The coordinates of the vertices
A CityJSON must have one member named "vertices"
, whose value is an array of coordinates of each vertex of the city model. Their position in this array (0-based) is used to represent the Geometric Objects.
-
one vertex must be an array with exactly 3 values, representing the (x,y,z) location of the vertex.
-
the array of vertices may be empty.
-
vertices may be repeated
"vertices" : [ [ 0.0 , 0.0 , 0.0 ], [ 1.0 , 0.0 , 0.0 ], [ 0.0 , 0.0 , 0.0 ], ... [ 1.0 , 0.0 , 0.0 ], [ 8523.134 , 487625.134 , 2.03 ] ]
3.2. Arrays to represent boundaries
-
A
"MultiPoint"
has an array with the indices of the vertices; this array can be empty. -
A
"MultiLineString"
has an array of arrays, each containing the indices of a LineString -
A
"MultiSurface"
, or a"CompositeSurface"
, has an array containing surfaces, each surface is modelled by an array of array, the first array being the exterior boundary of the surface, and the others the interior boundaries. -
A
"Solid"
has an array of shells, the first array being the exterior shell of the solid, and the others the interior shells. Each shell has an array of surfaces, modelled in the exact same way as a MultiSurface/CompositeSurface. -
A
"MultiSolid"
, or a"CompositeSolid"
, has an array containing solids, each solid is modelled as above.
//-- my comments
) are only to explain the cases, and should be removed. { "type" : "MultiPoint" , "lod" : 1 , "boundaries" : [ 2 , 44 , 0 , 7 ] }
{ "type" : "MultiLineString" , "lod" : 1 , "boundaries" : [ [ 2 , 3 , 5 ], [ 77 , 55 , 212 ] ] }
{ "type" : "MultiSurface" , "lod" : 2 , "boundaries" : [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]] ] }
{ "type" : "Solid" , "lod" : 2 , "boundaries" : [ [ [[ 0 , 3 , 2 , 1 , 22 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 1 , 2 , 6 , 5 ]] ], //-- exterior shell [ [[ 240 , 243 , 124 ]], [[ 244 , 246 , 724 ]], [[ 34 , 414 , 45 ]], [[ 111 , 246 , 5 ]] ] //-- interior shell ] }
{ "type" : "CompositeSolid" , "lod" : 3 , "boundaries" : [ [ //-- 1st Solid [ [[ 0 , 3 , 2 , 1 , 22 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 1 , 2 , 6 , 5 ]] ], [ [[ 240 , 243 , 124 ]], [[ 244 , 246 , 724 ]], [[ 34 , 414 , 45 ]], [[ 111 , 246 , 5 ]] ] ], [ //-- 2st Solid [ [[ 666 , 667 , 668 ]], [[ 74 , 75 , 76 ]], [[ 880 , 881 , 885 ]], [[ 111 , 122 , 226 ]] ] ] ] }
3.3. Semantic Surface Object
A Semantics Surface is a JSON object representing the semantics of a surface, and may also represent other attributes of the surface (eg the slope of the roof or the solar potential).
A Semantic Object:
-
must have one member with the name
"type"
, whose value is one of the allowed value. These depend on the City Object, see below. -
may have an attribute
"parent"
, whose value is an integer pointing to another Semantic Object of the same geometry (index of it, 0-based). This is used to explicitly represent to which wall or roof a window or door belongs to; there can be only one parent. -
may have an attribute
"children"
, whose value is an array of integers pointing to other Semantic Objects of the same geometry (index of it, 0-based). This is used to explicitly represent the openings (windows and doors) of walls and roofs. -
may have other attributes in the form of a JSON key-value pair, where the value must not be a JSON object (but a string/number/integer/boolean).
{ "type" : "RoofSurface" , "slope" : 16.4 , "children" : [ 2 , 37 ], "solar-potential" : 5 } { "type" : "Window" , "parent" : 2 , "type-glass" : "HR++" }
"Building"
, "BuildingPart"
, and "BuildingInstallation"
can have the following semantics for (LoD0 to LoD3; LoD4 is omitted):
-
"RoofSurface"
-
"GroundSurface"
-
"WallSurface"
-
"ClosureSurface"
-
"OuterCeilingSurface"
-
"OuterFloorSurface"
-
"Window"
-
"Door"
For "WaterBody"
:
-
"WaterSurface"
-
"WaterGroundSurface"
-
"WaterClosureSurface"
For Transportation ("Road"
, "Railway"
, "TransportSquare"
):
-
"TrafficArea"
-
"AuxiliaryTrafficArea"
Because in one given City Object (say a "Building"
) several surfaces can have the same semantics (think of a complex building that has been triangulated, there can be dozens of triangles used to model the same surface), a Semantic Surfaces object has to be declared once, and each of the surfaces used to represent it points to it. This is achieved by first declaring all the Semantic Surfaces in an array, and then having an array where each surface links to Semantic Surfaces (position in the array).
A Geometry object:
-
may have one member with the name
"semantics"
, whose values are two properties:"surfaces"
and"values"
. Both have to be present. -
the value of
"surfaces"
is an array of Semantic Surface Objects. -
the value of
"values"
is a hierarchy of arrays (the depth depends on the Geometry object; it is two less than the array"boundaries"
) with integers. An integer refers to the index in the"surfaces"
array of the same geometry, and it is 0-based. If one surface has no semantics, a value ofnull
must be used.
{ "type" : "MultiSurface" , "lod" : 2 , "boundaries" : [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 0 , 2 , 3 , 8 ]], [[ 10 , 12 , 23 , 48 ]] ], "semantics" : { "surfaces" : [ { "type" : "WallSurface" , "slope" : 33.4 , "children" : [ 2 ] }, { "type" : "RoofSurface" , "slope" : 66.6 }, { "type" : "Door" , "parent" : 0 , "colour" : "blue" } ], "values" : [ 0 , 0 , null , 1 , 2 ] } }
null
value is used to specify that a given surface has no semantics, but to avoid having arrays filled with null
, it is also possible to specify null
for a shell or a whole Solid in a MultiSolid, the null
propagates to the nested arrays. { "type" : "CompositeSolid" , "lod" : 2 , "boundaries" : [ [ //-- 1st Solid [ [[ 0 , 3 , 2 , 1 , 22 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 1 , 2 , 6 , 5 ]] ] ], [ //-- 2nd Solid [ [[ 666 , 667 , 668 ]], [[ 74 , 75 , 76 ]], [[ 880 , 881 , 885 ]], [[ 111 , 122 , 226 ]] ] ] ], "semantics" : { "surfaces" : [ { "type" : "RoofSurface" , }, { "type" : "WallSurface" , } ], "values" : [ [ //-- 1st Solid [ 0 , 1 , 1 , null ] ], [ //-- 2nd Solid get all null values null ] ] } }
4. Metadata
The metadata related to the 3D city model may be stored in a JSON object that may have different members, as follows.
Many of the members in ISO19115 are used, and a few are added because they are useful in 3D in a city modelling context (eg "presentLoDs"
and "thematicModels"
).
To see all the possible ones, look at the schema file metadata.schema.json of a given version.
"metadata" : { "datasetTitle" : "3D city model of Chibougamau, Canada" , "datasetReferenceDate" : "1977-02-28" , "geographicLocation" : "Chibougamau, Québec, Canada" , "referenceSystem" : "urn:ogc:def:crs:EPSG::2355" , "geographicalExtent" : [ 84710 , 346846 , 5 , 84757 , 346944 , 40 ], "datasetPointOfContact" : { "contactName" : "3D Geoinformation Group" , "phone" : "+31-6666666666" , "address" : "Delft University of Technology, the Netherlands" , "emailAddress"<EMAIL_ADDRESS>, "contactType" : "organization" , "website" : "https://3d.bk.tudelft.nl" }, "metadataStandard" : "ISO 19115 - Geographic Information - Metadata" , "metadataStandardVersion" : "ISO 19115:2014(E)" }
4.1. CRS
The coordinate reference system (CRS) may be given as a string. OGC CRS URNs such as "urn:ogc:def:crs:EPSG::7415"
are favoured over the legacy ones such as "EPSG:7415"
:
For instance, for the Dutch national CRS in 3D:
"metadata" : { "referenceSystem" : "urn:ogc:def:crs:EPSG::7415" }
Be aware that the CRS should be a three-dimensional one, ie the elevation/height values should be with respect to a specific datum.
4.2. Geographic Extent (bbox)
While this can be extracted from the dataset itself, it is useful to store it. It may be stored as an array with 6 values: [minx, miny, minz, maxx, maxy, maxz]
"metadata" : { "geographicalExtent" : [ 84710.1 , 446846.0 , - 5.3 , 84757.1 , 446944.0 , 40.9 ] }
4.3. Geographic location
The name of an area or a city.
"metadata" : { "geographicLocation" : "Chibougamau, Québec, Canada" }
4.4. Topic Category
A one-word category, the possible values are enumerated in the Table B.3.30 of the ISO19115-1:2014 document
"metadata" : { "datasetTopicCategory" : "planningCadastre" }
4.5. Lineage
It is possible to give the lineage of one or more city objects in the datasets. This allows us to document how certain city objects were reconstructed; if many were with the same method then their IDs should simply be listed in "featureID"
.
"lineage" : [ { "featureIDs" : [ "id-1" , "id-2" , "id-8235" ], "source" : { "description" : "Source of Terrain Data" , "sourceSpatialResolution" : "10 points/m2" , "sourceReferenceSystem" : "urn:ogc:def:crs:EPSG::4326" }, "processStep" : { "description" : "Processing of Terrain Data using 3dfier" , "processor" : { "contactName" : "3D Geoinformation Group" , "phone" : "+31-6666666666" , "address" : "Delft University of Technology, the Netherlands" , "emailAddress"<EMAIL_ADDRESS>, "contactType" : "organization" , "website" : "https://3d.bk.tudelft.nl" } } } ]
"full-date"
(thus "1977-07-11"
as a string), and should be used for the metadata above.
It’s also possible, for other attributes in a CityJSON file, to have a date with a time is a "full-time"
(thus "1985-04-12T23:20:50.52Z"
as a string).
5. Transform Object
To reduce the size of a file, it is possible to represent the coordinates of the vertices with integer values, and store the scale factor and the translation needed to obtain the original coordinates (stored with floats/doubles). To use compression, a CityJSON object may have one member "transform"
, whose values are 2 mandatory JSON objects ("scale"
and "translate"
), both arrays with 3 values.
The scheme of TopoJSON (called quantization) is reused, and here we simply add a third coordinate because our vertices are embedded in 3D space.
If a CityJSON object has a member "transform"
, to obtain the real position of a given vertex v, we must take the 3 values vi listed in the "vertices"
member and:
v[0] = (vi[0] * ["transform"]["scale"][0]) + ["transform"]["translate"][0] v[1] = (vi[1] * ["transform"]["scale"][1]) + ["transform"]["translate"][1] v[2] = (vi[2] * ["transform"]["scale"][2]) + ["transform"]["translate"][2]
If the CityJSON file does not have a "transform"
member, then the values of the vertices must be read as-is.
"transform" : { "scale" : [ 0.01 , 0.01 , 0.01 ], "translate" : [ 4424648.79 , 5482614.69 , 310.19 ] }
6. Geometry templates
CityGML’s Implicit Geometries, better known in computer graphics as templates, are one method to compress files since the geometries (eg benches, lamp posts, and trees), need only be defined once. In CityJSON, they are implemented slightly different from in CityGML: they are defined separately in the file, and each template can be reused. (While in CityGML one reuses the geometry used for another City Object.)
The Geometry Templates are defined as a JSON object that:
-
must have one member with the name
"templates"
, whose value is an array of Geometry Objects. -
must have one member with the name
"vertices-templates"
, whose value is an array of coordinates of each vertex of the templates (0-based indexing). The reason the vertices index are not global is to ensure that calculating the bounding box of a CityJSON file/dataset will not be affected by the templates (since they will often be defined locally, and translated/rotated/scaled to their final position).
"geometry-templates" : { "templates" : [ { "type" : "MultiSurface" , "lod" : 2 , "boundaries" : [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]] ] }, { "type" : "MultiSurface" , "lod" : 1 , "boundaries" : [ [[ 1 , 2 , 6 , 5 ]], [[ 2 , 3 , 7 , 6 ]], [[ 3 , 0 , 4 , 7 ]] ] } ], "vertices-templates" : [ [ 0.0 , 0.5 , 0.0 ], ... [ 1.0 , 1.0 , 0.0 ], [ 0.0 , 1.0 , 0.0 ] ] }
A given template can be used for a City Object instead of a Geometry Object. A new JSON object of type "GeometryInstance"
is defined, and it:
-
must have one member with the name
"template"
, whose value is the position of the template in the"geometry-templates"
(0-indexing). -
must have one member with the name
"boundaries"
, whose value is an array containing only one vertex index, which refers to one vertex in the"vertices"
property of a CityJSON file. (This is the "referencePoint" in CityGML.) -
must have one member with the name
"transformationMatrix"
, whose value is a 4x4 matrix (thus 16 values in an array) defining the the rotation/translation/scaling of the template (as defined in the CityGML 2.0.0 documentation).
{ "type" : "SolitaryVegetationObject" , "geometry" : [ { "type" : "GeometryInstance" , "template" : 0 , "boundaries" : [ 372 ] "transformationMatrix" : [ 2.0 , 0.0 , 0.0 , 0.0 , 0.0 , 2.0 , 0.0 , 0.0 , 0.0 , 0.0 , 2.0 , 0.0 , 0.0 , 0.0 , 0.0 , 1.0 ] } ] }
7. Appearance Object
Both textures and materials are supported, and the same mechanisms used in CityGML are reused, so the conversion back-and-forth is easy. The material is represented with the X3D specifications, as is the case for CityGML. For the texture, the COLLADA is reused, as is the case for CityGML. However:
-
the CityGML class
GeoreferencedTexture
is not supported. -
the CityGML class
TexCoordGen
is not supported, ie one must specify the UV coordinates in the texture files. -
the major difference is that in CityGML each Material/Texture object keeps a list of the primitives using it, while in CityJSON it is the opposite: if a primitive has a Material/Texture than it is stated with the primitive (with a link to it).
An Appearance Object is a JSON object that
-
may have one member with the name
"materials"
, whose value is an array of Material Objects. -
may have one member with the name
"textures"
, whose value is an array of Texture Objects. -
may have both
"materials"
and"textures"
. -
may have one member with the name
"vertex-texture"
, whose value is an array of coordinates of each so-called UV vertex of the city model. -
may have one member with the name
"default-theme-texture"
, whose value is the name of the default theme for the appearance (a string). This can be used if geometries have more than one textures, so that a viewer displays the default one. -
may have one member with the name
"default-theme-material"
, whose value is the name of the default theme for the material (a string). This can be used if geometries have more than one textures, so that a viewer displays the default one.
"appearance" : { "materials" : [], "textures" : [], "vertices-texture" : [], "default-theme-texture" : "myDefaultTheme1" , "default-theme-material" : "myDefaultTheme2" }
7.1. Geometry Object having material(s)
Each surface in a Geometry Object can have one or more materials assigned to it. To store these, a Geometry Object may have a member "material"
, the value of this member is a collection of key-value pairs, where the key is the theme of the material, and the value is one JSON object that must contain either:
-
one member
"values"
, whose value is a hierarchy of arrays with integers. Each integer refers to the position (0-based) in the"materials"
member of the"appearance"
member of the CityJSON object. If a surface has no material, thennull
should be used in the array. The depth of the array depends on the Geometry object, and is equal to the depth of the"boundary"
array minus 2, because each surface ([[]]
) gets one material. -
one member
"value"
, whose value is one integer referring to the position (0-based) in the"materials"
member of the"appearance"
member of the CityJSON object. This is used because often the materials are used to colour full objects, and repetition of materials is not necessary.
In the following, the Solid has 4 surfaces, and there are 2 themes: "irradiation" and "irradiation-2" could for instance represent different colours based on different scenarios of an solar irradiation analysis. Notice that the last surface get no material (for both themes), thus null
is used.
{ "type" : "Solid" , "lod" : 2 , "boundaries" : [ [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 1 , 2 , 6 , 5 ]] ] ], "material" : { "irradiation" : { "values" : [[ 0 , 0 , 1 , null ]] }, "irradiation-2" : { "values" : [[ 2 , 2 , 1 , null ]] } } }
7.2. Geometry Object having texture(s)
To store the texture(s) of a surface, a Geometry Object may have a member with the value "texture"
, its value is a collection of key-value pairs, where the key is the theme of the textures, and the value is one JSON object that must contain one member "values"
, whose value is a hierarchy of arrays with integers. For each ring of each surface, the first value refers to the position (0-based) in the "textures"
member of the "appearance"
member of the CityJSON object. The other indices refer to the UV positions of the corresponding vertices (as listed in the "boundaries"
member of the geometry). Each array representing a ring therefore has one more value than that to store its vertices.
The depth of the array depends on the Geometry object, and is equal to the depth of the "boundary"
array.
In the following, the Solid has 4 surfaces, and there are 2 themes: "winter-textures" and "summer-textures" could for instance represent the textures during winter and summer.. Notice that the last 2 surfaces of the first theme gets no material, thus null
is used.
{ "type" : "Solid" , "lod" : 2 , "boundaries" : [ [ [[ 0 , 3 , 2 , 1 ]], [[ 4 , 5 , 6 , 7 ]], [[ 0 , 1 , 5 , 4 ]], [[ 1 , 2 , 6 , 5 ]] ] ], "texture" : { "winter-textures" : { "values" : [ [ [[ 0 , 10 , 23 , 22 , 21 ]], [[ 0 , 1 , 2 , 6 , 5 ]], [[ null ]], [[ null ]] ] ] }, "summer-textures" : { "values" : [ [ [[ 1 , 10 , 23 , 22 , 21 ]], [[ 1 , 1 , 2 , 6 , 5 ]], [[ 1 , 66 , 12 , 64 , 5 ]], [[ 2 , 99 , 21 , 16 , 25 ]] ] ] } } }
7.3. Material Object
A Material Object:
-
must have one member with the name
"name"
, whose value is a string identifying the material. -
may have the following members (their meaning is explained there):
-
"ambientIntensity"
, whose value is a number between 0.0 and 1.0 -
"diffuseColor"
, whose value is an array with 3 numbers between 0.0 and 1.0 (RGB colour) -
"emissiveColor"
, whose value is an array with 3 numbers between 0.0 and 1.0 (RGB colour) -
"specularColor"
, whose value is an array with 3 numbers between 0.0 and 1.0 (RGB colour) -
"shininess"
, whose value is a number between 0.0 and 1.0 -
"transparency"
, whose value is a number between 0.0 and 1.0 (1.0 being completely transparent) -
"isSmooth"
, whose value is a Boolean value, is defined in CityGML as "a hint for normal interpolation. If this boolean flag is set to true, vertex normals should be used for shading (Gouraud shading). Otherwise, normals should be constant for a surface patch (flat shading)."
-
"materials" : [ { "name" : "roofandground" , "ambientIntensity" : 0.2000 , "diffuseColor" : [ 0.9000 , 0.1000 , 0.7500 ], "emissiveColor" : [ 0.9000 , 0.1000 , 0.7500 ], "specularColor" : [ 0.9000 , 0.1000 , 0.7500 ], "shininess" : 0.2 , "transparency" : 0.5 , "isSmooth" : false }, { "name" : "wall" , "ambientIntensity" : 0.4000 , "diffuseColor" : [ 0.1000 , 0.1000 , 0.9000 ], "emissiveColor" : [ 0.1000 , 0.1000 , 0.9000 ], "specularColor" : [ 0.9000 , 0.1000 , 0.7500 ], "shininess" : 0.0 , "transparency" : 0.5 , "isSmooth" : true } ]
7.4. Texture Object
A Texture Object:
-
must have one member with the name
"type"
, whose value is a string with either "PNG" or "JPG" as value -
must have one member with the name
"image"
, whose value is a string with the name of the file. This file can be a URL (eg"http://www.hugo.com/filename.jpg"
), a relative path (eg"appearances/myroof.jpg"
), or an absolute path (eg"/home/elvis/mycityjson/appearances/myroof.jpg"
). -
may have one member with the name
"wrapMode"
, whose value can be any of the following:"none"
,"wrap"
,"mirror"
,"clamp"
, or"border"
. -
may have one member with the name
"textureType"
, whose value can be any of the following:"unknown"
,"specific"
, or"typical"
. -
may have one member with the name
"borderColor"
, whose value is an array with 4 numbers between 0.0 and 1.0 (RGBA colour).
"textures" : [ { "type" : "PNG" , "image" : "http://www.hugo.com/filename.jpg" }, { "type" : "JPG" , "image" : "appearances/myroof.jpg" , "wrapMode" : "wrap" , "textureType" : "unknown" , "borderColor" : [ 0.0 , 0.1 , 0.2 , 1.0 ] } ]
7.5. Vertices-texture Object
A Appearance Object may have one member named "vertices-texture"
, whose value is an array of the (u,v) coordinates of the vertices used for texturing surfaces. Their position in this array (0-based) is used by the "texture"
member of the Geometry Objects.
-
the array of vertices may be empty.
-
one vertex must be an array with exactly 2 values, representing the (u,v) coordinates.
-
The value of u and v must be between 0.0 and 1.0.
-
vertices may be repeated
"vertices-texture" : [ [ 0.0 , 0.5 ], [ 1.0 , 0.0 ], [ 1.0 , 1.0 ], [ 0.0 , 1.0 ] ]
8. Extensions
CityJSON uses JSON Schemas to document and validate the data model, schemas should be seen as basically validating the syntax of a JSON document.
A CityJSON Extension is a JSON file that allows us to document how the core data model of CityJSON may be extended, and to validate CityJSON files. This is conceptually akin to the Application Domain Extensions (ADEs) in CityGML; see Section 10.13 of the official CityGML documentation.
The following 3 cases for extension are possible:
-
Adding new complex attributes to existing City Objects
-
Adding new properties at the root of a document
-
Creating a new City Object, or "extending" one, and defining complex geometries
CityJSON Extensions are designed such that they can be read and processed by standard CityJSON software, often no changes in the parsing code is required. This is achieved by enforcing a set of simple rules, as defined below, when adding new City Objects. If these are followed, then a CityJSON file containing Extensions will be seen as a "standard" CityJSON file.
8.1. Using an Extension in a CityJSON file
An Extension should be given a name (eg "Noise") and the URL of the Extension file should be given, along with the version that is used for this file. It is expected that the Extension is publicly available at the URL, and can be downloaded.
Several Extensions can be used in a single file, each one is indexed by its name in the "extensions"
JSON object.
In the example below we have 2 Extensions: one named "Noise" and one named "Solar_Potential".
{ "type" : "CityJSON" , "version" : "1.0" , "extensions" : { "Noise" : { "url" : "https://someurl.org/noise.json" , "version" : "1.0" }, "Solar_Potential" : { "url" : "https://someurl.org/solar.json" , "version" : "0.8" } }, "CityObjects" : {}, "vertices" : [] }
8.2. The Extension file
A CityJSON Extension is a JSON object, and it must have the following 7 members:
-
one member with the name
"type"
, whose value must be"CityJSON_Extension"
; -
one member with the name
"name"
, whose value must be a string identifying the extension; -
one member with the name
"uri"
, whose value must be a string with the URI of the location of the schema where the JSON object is located; -
one member with the name
"version"
, whose value must be a string identifying the version of the Extension; -
one member with the name
"extraRootProperties"
, whose value must be a JSON object; its content is part of a JSON schema (explained below), or an empty object; -
one member with the name
"extraAttributes"
, whose value must be a JSON object; its content is part of a JSON schema (explained below), or an empty object; -
one member with the name
"extraCityObjects"
, whose value must be a JSON object; its content is part of a JSON schema (explained below), or an empty object;
{ "type" : "CityJSON_Extension" , "name" : "Noise" , "uri" : "https://someurl.org/noise.json" , "version" : "0.1" , "description" : "Extension to model the noise" "extraRootProperties" : {}, "extraAttributes" : {}, "extraCityObjects" : {} }
A CityJSON Extension object must be in a standalone file and it must be located in a folder /extensions
in the folder where the CityJSON schemas are located.
For a new extension noise.json
the following structure would result:
|-- appearance.schema.json |-- cityjson.schema.json |-- cityobjects.schema.json |-- geomprimitives.schema.json |-- geomtemplates.schema.json |-- metadata.schema.json |-- /extensions |-- noise.json
This also means that if an element of the Extension reuses or references structures defined in the schemas of CityJSON, then the relative path ../
must be used.
An example would be to reuse the Solid type would be:
"items" : { "oneOf" : [ { "$ref" : "../geomprimitives.json#/Solid" } ] }
8.3. Case 1: Adding new complex attributes to existing City Objects
One of the philosophy of JSON is "schema-less", which means that one is allowed to define new properties for the JSON objects without documenting them in a JSON schema (watch out: this does not mean that JSON cannot have schemas!).
While this is in contrast to CityGML (and GML as a whole) where the schemas are central, the schemas of CityJSON (schema) are partly following that philosophy.
That is, for a given City Object, the "allowed" properties/attributes are listed in the schema, but it is not an error to add new ones.
The "official validator" of CityJSON (cjio with the option --validate
) does more than simply validate a dataset against the schemas, and will return a warning if an attribute is not in the schema, but it is not considered as invalid in CityJSON.
In brief, if one wants to simply add a new attribute to a given "Building"
, say to document its colour ("colour": "red"
), the easiest way is just to add a property to the City Object (notice that "storeysAboveGround"
is an allowed attributes to buildings):
{ "type" : "Building" , "attributes" : { "storeysAboveGround" : 2 , "colour" : "red" }, "geometry" : [...] }
It is also possible to add, and document in a schema, complex attributes, for example if we wanted to have the colour of the buildings as a RGBA value (red-green-blue-alpha):
{ "type" : "Building" , "attributes" : { "storeysAboveGround" : 2 , "+colour" : { "rgba" : [ 255 , 255 , 255 , 1 ], }, }, "geometry" : [...] }
Another example would be to store the area of the parcel of a building, and to document also the unit of measurement:
{ "type" : "Building" , "attributes" : { "storeysAboveGround" : 2 , "+area-parcel" : { "value" : 437 , "uom" : "m2" } }, "geometry" : [...] }
For these 2 cases, the CityJSON Extension object would look like the snippet below.
Notice that "extraAttributes"
may have several properties (the types of the City Objects are the possibilities) and then each of these have as properties the new attributes (there can be several).
An extra attribute must start with a "+"
; notice that it is good practice to prepend the attribute with the name of the Extension, to avoid that 2 attributes from 2 different extensions have the same name.
The value of the property is a JSON schema, this schema can reference and reuse JSON objects already defined in the CityJSON schemas.
"extraAttributes" : { "Building" : { "+colour" : { "type" : "object" , "properties" : { "rgba" : { "type" : "array" , "items" : { "type" : "number" }, "minItems" : 4 , "maxItems" : 4 } }, "required" : [ "rgba" ], "additionalProperties" : false }, "+area-parcel" : { "type" : "object" , "properties" : { "value" : { "type" : "number" }, "uom" : { "type" : "string" , "enum" : [ "m2" , "feet2" ] } }, "required" : [ "value" , "uom" ], "additionalProperties" : false } } }
8.4. Case 2: Adding new properties at the root of a document
It is allowed to add a new property at the root of a CityJSON file, but if one wants to document it in a schema, then this property must start with a "+"
.
Imagine we wanted to store some census data for a given neighbourhood for which we have a CityJSON file, then we could define the extra root property "+census"
as follows:
"extraRootProperties" : { "+census" : { "type" : "object" , "properties" : { "percent_men" : { "type" : "number" , "minimum" : 0.0 , "maximum" : 100.0 }, "percent_women" : { "type" : "number" , "minimum" : 0.0 , "maximum" : 100.0 } } } }
And a CityJSON file would look like this:
{ "type" : "CityJSON" , "version" : "0.9" , "CityObjects" : {...}, "vertices" : [...], "+census" : { "percent_men" : 49.5 , "percent_women" : 51.5 } }
8.5. Case 3: Creating/extending new City Objects
The creation of a new City Object is done by defining it in the CityJSON Extension object in the "extraCityObjects"
property:
"extraCityObjects" : { "+NoiseBuilding" : { "allOf" : [ { "$ref" : "../cityobjects.json#/_AbstractBuilding" }, { "properties" : { "type" : { "enum" : [ "+NoiseBuilding" ] }, "toplevel" : { "type" : "boolean" }, "attributes" : { "properties" : { "buildingLDenMin" : { "type" : "number" } } } }, "required" : [ "type" ] } ] } }
Since all City Objects are documented in the schemas of CityJSON (in cityobjects.json), it is basically a matter of copying the parts needed in a new file and modifying its content.
A new name for the City Object must be given and it must begin with a "+"
.
Because City Objects can be of different levels (1st-level ones can exist by themselves; 2nd-level ones need to have a parent), we need to explicitly state this by using the property "toplevel"
, which is a Boolean value.
It should be observed that since JSON schemas do not allow inheritance, the only way to extend a City Object is to define an entirely new one (with a new name, eg "+NoiseBuilding"
).
This is done by copying the schema of the parent City Object and extending it.
8.6. Rules to follow to define new City Objects
The challenge when creating Extensions to the core model is that we do not want to break the software packages (viewers, spatial analysis, etc) that already read and process CityJSON files. While one could define a new City Object and document it, if this new object does not follow the rules below then it will mean that new specific software needs to be built for it---this would go against the fundamental ideas behind CityJSON.
-
The name of a new City Object must begin with a
"+"
, eg"+NoiseBuilding"
. -
A new City Object must conform to the rules of CityJSON, ie it must contain a property
"type"
and one"geometry"
. If the object contains appearances, the same mechanism should be used so that the new City Objects can be processed without modification. -
A new City Object must contain the property
"toplevel"
, whose value is a Boolean (true = 1st-level; false = 2nd-level). -
All the geometries must be in the property
"geometry"
, and cannot be located somewhere else deep in a hierarchy of a new property. This ensures that all the code written to process, manipulate, and view CityJSON files will be working without modifications. -
If a new City Object contains other objects and requires different geometries, then a new City Object needs to be defined using the parent-children structure of CityJSON, as used by
"Building"
and"BuildingPart"
. -
The reuse of types defined in CityJSON, eg
"Solid"
or semantic surfaces, is allowed. -
To define a new semantic surface, a
+
must be prepended to its name, eg"+ThermalSurface"
.


{% extends "admin/layout.html" %} {% block title %}{{ _("Plugin Management") }}{% endblock %} {% block contents %}
{% trans %} Plugins extend the functionality of the pyClanSphere system. Because of security and convenience reasons you have to enable plugins by hand. Some plugins could conflict with each other so it's up to you to decide which plugins you want to enable. In case of doubt have a look at the installation instructions of the plugin you've added. {% endtrans %}
| {{ _("Plugin") }} | {{ _("Version") }} | {{ _("Description") }} | {{ _("Activate") }} |
|---|---|---|---|
| {{ plugin.html_display_name|safe }} {%- if plugin.is_bundled %} *{% endif %} | {{ (plugin.version or '?') }} | {{ plugin.description }} {{ _("Remove plugin") }}] {% endif -%} | {%- if plugin.instance_plugin and not plugin.active %} [{{ form.active_plugins[plugin.name]()|safe }} |
{% trans %} * marked plugins are bundled with pyClanSphere and upgraded as part of it. {% endtrans %}
{% trans %} If you have a plugin as pyClanSphere .plugin file you can upload it to your pyClanSphere instance using the following form. Plugins added this way can also be completely removed. {% endtrans %}


Find out where and when events are taking place in your community
Create an event to invite your friends and family members!
RSVP if you were invited
Coming Soon!
Check the weather for day of your event so you can plan accordingly.


{% set pageTitle = "Check your answers" %} {% set mainClasses = "nhsuk-main-wrapper--s" %} {% set version = "v2" %} {% extends "includes/layout.html" %} {% block backLink %}
{% endblock %} {% block content %}By sending this information you are confirming that, as far as you know, the details you are providing are correct.
Accept and send


I'm 22 years old, been using drugs since about 14 (mostly pot) and have been experimenting with pretty much all types of drugs (except for opiates which I have never used) I've never had bad trips off of ketamine, lsd, shrooms or any of the known 'freakout' drugs even at really high dosage and although I do have fiending tendencies on some drugs this is really not the case for me on dissociatives.
So, I ordered a 500 mg bag of methoxetamine from a reputable vendor (checked reports and vendor sites for about 2 weeks before ordering so felt pretty confident with my decision) and when it fell through the mailslot I immediately weighed off 2 mg for a allergy check and 10 mg for bottom effects which would be taken later that afternoon. I will not be describing that trip seeing as the effects were too weak to really distinguish from placebo and the pot I had smoked throughout the afternoon.
Since the afternoon went on smooth I called a friend who was in town for the weekend and made plans with another friend that we could trip at their house this night. Had some diner, prepared my trip kit (backpack with some easy to eat food, protein powder, water bottle, cellphone and some towels) and prepared my first dose of 20mg which would be taken just before we got on the bikes (bicycles).
20:20 The first 20 mg were insufflated and we went on our way. It was only about 15 minutes to get to the house we were going to trip at but it already seemed to come on halfway there. Some feeling of disconnection with small parts off the normal reality like time and distances that didn't seem to act very logical. Now bear in mind that my english isn't that great so explaining the effects will be quite difficult to do.
20:45 Arrived at the house, there were three people in front of the house but I could not seem to 'understand' them, why they were there who they where and what they where doing was a complete mystery to me and I felt like I had to go inside quickly before they noticed how weird I was feeling (they probably didnt even look twice) and had the feeling that if I had to explain my actions I would have a really hard time.  At this time I got my first kind of scary moment. Nothing really happened except I thought there was a chance it might go horribly wrong. Luckily my experience helped me realise quickly if I thought it would go bad it almost certainly would so got back on the positive thought track and went my merry way.
23:00 Okay things are really peaking now and I'm feeling pretty good. Kinda warm and euphoric which is sometimes said to be like mdma but I dont really see the similarity because there is no power behind this. (and with mdma I feel it running through me). There is also a very strong need to 'bounce' through the room, not like on uppers but more like taking a step, dipping down to the floor and coming back up in the most absurd ways you can think of. Pretty much all effortlessly which is a really weird feeling seeing as walking normally is totally out of the question now.
01:00 Time to go home. Decided not to take the last bump because there was no need for it whatsoever. A little trouble biking at first but was just getting my bearings on this drugs. (biked home drunk lots of times never crashed or anything so) wasn't really coming down much yet so smoked a big joint and went to bed. No problems getting to sleep an slept very good till about 12:30 which is a little long for me but woke up feeling good with pretty much no sign of a hangover or anything. (this could be because I usually drink about 10 beers on friday nights but didn't drink at all this night)
All things considered this was a very good experience for me with a little bit of a bumpy start (reading experiences of tilatimine substitution by bad vendors and a distrust of all things ordered over the internet) but a great ending with little to no immediately felt repercussions. (at this dose and frequency!!) I would recommend everyone that is going to use this to BUY A SCALE!!!!!!!!!!!!!!! and be careful with dosage and setting because this could be scary as hell at a party or something where you dont know people. Have a safety net (friends, location, that kinda thing). Other then that enjoy and bless you all on your trips to your inner selves.
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.


Our mission is to help soup kitchens help their communities by increasing productivity and making it easier to stay ahead of any challanges of everyday life.
here at I'll serve soup we pride ourselves with the work we do, we strive with passion and dedication;