COMMON LAYER INTERFACE (CLI)
VERSION 2.0
The Common Layer Interface (CLI) is a universal format for the input of geometry data to model fabrication systems based on layer manufacturing technologies (LMT). It is suitable for systems using layer-wise photo-curing of resin, sintering or binding of powder, cutting of sheet material, solidification of molten material, and any other systems which build models on a layer-by-layer basis.
CLI is intended as a simple, efficient and unambiguous format for data input to all LMT-based systems, based on a "2 1/2D" layer representation. It is independent of vendors or fabrication machines, and should require only a simple conversion to the vendor-specific internal data structure of the machine. The obligatory parts of the format are also application independent, while the USERDATA command allows user- or application-specific data to be defined in the header. This flexibility allows the format to be used for a wide range of applications, without loss of important information and without excluding data transfer between different applications. One specific application, medical scan data, is already accommodated with appropriate user data. Others can be added as they are defined.
Comments and suggestions for future versions are welcome, and should be forwarded to one of the contacts named in Appendix A.
1. Definitions and general conventions
The geometrical information of the intersection of a 3D-model with a plane is called a slice. The volume between two parallel slices is called a layer. The 2 1/2D-representation of a model is the sum total of layer-descriptions. The slicing plane is parallel to the xy- plane of a right hand cartesian coordinate system. It is assumed that the building direction is the positive z-axis.
A layer is the volume between two parallel slices, and is defined by its thickness, a set of contours and (optionally) hatches.
Contours represent the boundaries of solid material within a layer, and are defined by polylines (section 1.4). They are classified as internal and external contours (Fig.1). For correct interpretation each contour must be closed and must not intersect itself or another contour.
(Fig 1)
A polyline is defined by a set of vertex points (x,y), connected contiguously in the listed order by straight line segments. A closed polyline can also be called a polygon.
A hatch is a set of independent straight lines, each defined by one start and one end point (x,y). The purpose of hatches and open polylines is to define support structures or filling structures to obtain a solid model, which are necessary for some LMT systems.
2. ASCII Data Format
The ASCII-file is separated into sections. Each section is marked by a start and an end marker. Only the characters A...Z, a...z, , ., 0...9, $ and the separators (section 2.4) are interpreted. All other characters will be ignored. Each file must have a HEADER-section and a GEOMETRY-section. Other sections are optional. The start of the HEADER-section will be interpreted as the start of data, and the end of the GEOMETRY-section as the end of data. Data may be included before the HEADER-section and after the GEOMETRY-section, but will be ignored.
All commands have the general form:
Keyword/parameter
Keyword and parameter are separated by the character "/" (oblique stroke). If there are no parameters there should be no oblique stroke. The only exception to this rule is the command "//" (see description below).
Keywords are names according to the language description defined below. All keywords are written in ASCII upper case notation. Every keyword must start with the sequence "$$".
Parameters are numbers or ASCII-strings separated by the character "," (comma).
INTEGER:
Negative numbers must have a minus sign, positive numbers can have a plus sign. Numbers with no sign are interpreted as positive. Maximum range is +/- 2^31.
REAL:
xi,yi are numbers from 0 to 9, respectively before and after the decimal point. Realim is the maximum number of digits within a REAL and is limited to 16. A decimal point is required for all REAL numbers.
Separators are "/" (oblique stroke), "," (comma) and "//" (double stroke).
An ASCII-string is any number of valid characters enclosed within double-quotes. Valid characters are all printable characters except the double-quotes.
3.1. Non geometric commands
Command : remark
Syntax : // text //
This is an exception to the general syntax. The text between the // commands will be interpreted as a comment. Within the comment the double stroke is not allowed.
Command : start header
Syntax : $$HEADERSTART
This command starts the HEADER-section, and will be interpreted as the start of data.
___________
Command : end header
Syntax : $$HEADEREND
This command ends the HEADER-section.
___________
Command : start geometry
Syntax : $$GEOMETRYSTART
This command starts the GEOMETRY-section
___________
Command : end geometry (and end data)
Syntax : $$GEOMETRYEND
This command ends the GEOMETRY-section, and will be interpreted as the end of
data.
___________
Command : data format is binary
Syntax : $$BINARY
Indicates the data in the GEOMETRY-section to be binary.
__________
Command : data format is ASCII
Syntax : $$ASCII
Indicates the data in the GEOMETRY-section to be ASCII.
___________
Command : units are u [mm]
Syntax : $$UNITS/u
Parameter u : REAL
u indicates the units of the coordinates in mm.
__________
Command : version is v
Syntax : $$VERSION/v
Parameter v : integer
v divided by 100 gives the version number.
For example 200 --> Version 2.00
__________
All following HEADER-commands are optional.
Command : file was built on date
Syntax : $$DATE/d
Parameter d : integer
d will be interpreted in the sequence DDMMYY.
___________
Command : dimension
Syntax : $$DIMENSION/x1,y1,z1,x2,y2,z2
Parameters:
x1, y1, z1, x2, y2, z2 : REAL
Describes the dimensions of the outline box which completely contains the part in
absolute coordinates (in mm) with respect to the origin. The conditions x1 < x2 , y1 <
y2 and z1 < z2 must be satisfied.
___________
Command : number of layers inside the file is i
Syntax : $$LAYERS/i
Parameter i : INTEGER
The Parameter i indicates the number of layers inside the file.
___________
Command : align data in GEOMETRY-section to 32 bit
(for binary GEOMETRY-section only)
Syntax : $$ALIGN
Sets the alignment of geometry-data to 32 bit. The command only takes effect in case of a binary GEOMETRY-section. The GEOMETRY-section must start at the beginning of a 32-bit-word. The HEADER-section must end at the end of a 32-bit- word. Every data item within the GEOMETRY-section must start at the beginning of a 32-bit-word. A pair of coordinates (x,y) is seen as one data item. For the commands start polyline short and start hatches short a pair of coordinates (x,y) are to be written into one 32-bit-word.
Example:
($$ALIGN in HEADER-section)
Byte 1 2 3 4 5 6 7 8 9........ 127 # # # 4 1 # # 129.... ___________
Command : set a label for a part
Syntax : $$LABEL/id,text
id: Identifier to allow more than one model information in one file. For every id used in the commands start polyline (short/long/ASCII) and start hatches (short/long/ASCII) there shall be one command $$LABEL. Each id causes the building-process to build a different part.
text: An ASCII string that gives some comment on the part.
___________
Command : put user-specific data to the header
Syntax : $$USERDATA/uid,len,user-data
Parameters:
uid: user identifier - identifies user and the following user-data. uid and user-data shall be cleared and published by a central coordinator (e.g. task coordinator).
Example: $$USERDATA/"CompanyZZ9401",....
len: defines the length of user-data in bytes from the byte after the comma after the
parameter len to the byte before the following $$command.
user-data: field of user-specific data; the length of this field is defined by the parameter
len; the contents of this field is defined by the user himself.
___________
Command : start layer
Syntax : $$LAYER/z
Parameter z : REAL
Start of a layer with upper surface at height z (z*units [mm]). All layers must be sorted
in ascending order with respect to z. The thickness of the layer is given by the
difference between the z values of the current and previous layers. A thickness for the
first (lowest) layer can be specified by including a "zero-layer" with a given z value but
with no polyline.
___________
Command : start polyline
Syntax : $$POLYLINE/id,dir,n,p1x,p1y,...pnx,pny
Parameters:
id : INTEGER dir,n : INTEGER p1x..pny : REAL
Polylines representing internal contours must be clockwise, polylines representing external contours counter-clockwise (Fig 2). This orientation must be valid for the parameter "dir" and for the order the points are listed. The value of "dir " overwrites the order of listed points if there is a mismatch.
In the case of closed polylines (dir = 0,1) p1x = pnx and p1y = pny must be valid. The open line value for the dir flag can be used to indicate a non-closed polyline. This can be used as an input for correction and editing tools based on the CLI format.
Fig 2
Command : start hatches
Syntax : $$HATCHES/id,n,p1sx,p1sy,p1ex,p1ey,...pnex,pney
Parameters:
id : INTEGER n : INTEGER p1sx..pney : REAL
id : identifier to allow more than one model information in one file.
id refers to the parameter id of command $$LABEL (HEADER-section).
n : number of hatches (n*4 =number of coordinates)
p1sx..pney : coordinates of the hatches 1..n
4 parameters for every hatch (startx,starty,endx,endy)
___________
$$HEADERSTART // This is a example for the use of the Layer Format // $$ASCII $$UNITS/1 // all coordinates are given in mm // // $$UNITS/0.01 all coordinates are given in units 0.01 mm // $$DATE/070493 // 7. April 1993 // $$LAYERS/100 // 100 layers // $$HEADEREND $$GEOMETRYSTART // start of GEOMETRY-section// $$LAYER/5.5 // Layer at height z = 5.5 mm// $$POLYLINE/0,0,5,1.00,2.02,3.30,3.42,5.23,5.01,1.57,5.6,1.00,2.02 $$HATCHES/0,2,10.2,10.4,12.34,12.5,8.8,9.3,15.7,13.2 $$POLYLINE/0,1,10,1.2,4.01,........... .. .. $$LAYER/5.6 $$POLYLINE/0,0,200,10.23,12.34,.......................... .......... .. .. $$LAYER/15.5 $$POLYLINE/0,0,200,13.23,12.34,.......................... .......... .. .. $$GEOMETRYEND
5.1. File structure
The binary-data-file is separated into two sections : a header-section in ASCII data format and a geometry-section in binary data format. For header-section commands see section 3.1.3.
The start of the header-section will be interpreted as start of data.
The end of the geometry-section will be interpreted as the end of data.
The end of the header-section must be indicated by a $$HEADEREND command.
The geometry-section must directly follow the header-section (directly after the
command $$HEADEREND) without any kind of information (carriage return, line
feed etc.) in between.
All commands have the following general form:
CommandIndex,p1,p2,...pn
There is no separator between Command Index and parameters, nor within the
parameter-section.
Command Index is a number (unsigned integer) indicating the command according to the command list below.
The parameters p1.. pn are numbers according the specification below.
Numbers are specified using the IEEE standard.
Data Formats Range Precision Representation ---------------------------------------------------------------------------- Unsigned 10^4 16 Bits [15...0] (Two's Complement) Integer Long 10^(+/- 9) 32 Bits [31...0] (Two's Complement) Integer Real 10^(+/- 38) 24 Bits [31|30..23|22..0] s e f s: sign bit e: Biased Exponent f: Significand Fig. 3
if 0 < e < 255 then v = (-1)^s * 2^(e-127) * (1.f) if e=0 and f<>0 then v = (-1)^s * 2^(-126) * (0.f) if e=0 and f=0 then v = (-1)^s * 0 Where e is the Biased Exponent, s is the sign bit, f is the significand, and v the value. unsigned INTEGER : 2 Bytes range 0..65535 precision 16 Bits long INTEGER : 4 Bytes range 0..+/- 231 precision 32 Bits REAL: 4 Bytes range 10 +/- 38 precision 24 Bits most significant Byte = highest addressed Byte.
No non-geometric commands are specified in version 2.0.
Command : Start Layer long CI,z CI 127 Parameter z : REAL
Start of a layer with upper surface at height z (z*units [mm]). All layers must be sorted
in ascending order with respect to z. The thickness of the layer is given by the
difference between the z values of the current and previous layers. A thickness for the
first (lowest) layer can be specified by including a "zero-layer" with a given z value but
no polyline.
___________
Command : Start Layer short
CI,z
CI 128
Parameter z : unsigned INTEGER
Start of a layer with upper surface at height z (z*units [mm]). All layers must be sorted
in ascending order with respect to z.
___________
Command : Start PolyLine shortCommand : Start PolyLine
CI,id,dir,n,p1x,p1y,...pnx,pny
CI 129 Parameters: id : unsigned INTEGER dir,n : unsigned INTEGER p1x..pny : unsigned INTEGER
CI 130 Parameters: id : long INTEGER dir,n : long INTEGER p1x..pny : REAL
CI 131 Parameters: id : unsigned INTEGER n : unsigned INTEGER p1sx..pney : unsigned INTEGER
CI 132 Parameters: id : long INTEGER n : long INTEGER p1sx..pney : REAL
Development of the Common Layer Interface (CLI) originated in the Brite-EuRam Project "Rapid Prototyping Techniques", whose work programme identified the following need:
"Problems with the current STL interface (triangle model) force us to look for a new data format for general LMT-processes, which may only contain cross section information... The section oriented information should be vendor independent."
Simultaneously, the Brite-EuRam Project "Phidias" was working to establish and make available an interface between medical scan data and layer manufacturing technologies. Cooperation between these two projects, together with comments and contributions from third parties, led to the development of CLI version 2.0.
Further development and dissemination of the CLI is also continuing in cooperation with EARP (the European Action on Rapid Prototyping), an organization of companies and institutions throughout Europe which are actively working with rapid prototyping. The up-to- date version of CLI is (from September 1994) continuously available to Internet users under the World Wide Web, at the address given on the next page. This also provides a forum for Internet users to discuss their use of CLI and make suggestions.
Alternatively, copies of the CLI specification can be obtained from the Brite EuRam project contacts listed.
BIBA, Germany
BMW AG, Germany
Centro Recherche FIAT, Italy
CRIF, Belgium
EOS GmbH, Germany
IKP, Germany
Mercedes Benz AG, Germany
Brite EuRam project BE 5930 "Phidias - Laser Photopolymerisation Models based on Medical
Imaging: a Development Improving the Accuracy of Surgery". Partners:
Katholieke Universiteit Leuven, Belgium
Materialise NV, Belgium
Siemens Medical Engineering Group, Germany
Zeneca Ltd, United Kingdom
/p>
Internet addresses for the CLI specification, the EARP electronic book and other information on rapid prototyping (on the World Wide Web hypertext multi-media system):
http://www.cs.hut.fi~ado/rp/rp.html (Mr Andre Dolenc, Helsinki University)
http://www.cranfield.ac.uk (Mr Ron. Jamieson, Cranfield University)
Brite EuRam RPT project:
Dr M. Shellabear Tel: +49 (89) 899131-0
EOS GmbH Fax: +49 (89) 8598402
Pasinger Str. 2
D-82152 Planegg
Germany
Brite EuRam PHIDIAS project:
Prof W. Kalender Tel: +49 (9131) 84-7736
Siemens AG, UB Med Fax: +49 (9131) 84-6365
Postfach 3260
D-91052 Erlangen
Germany
Introduction
This appendix describes a proposal for a $$USERDATA header section (see 3.1.3) to be used for medical applications.
The extension of the CLI-Header proposed here describes the absolute minimum of labeling considered necessary for medical applications. The definitions are part of work performed within the Brite-Euram project Phidias towards the development of a format for the exchange of segmentation results.
The additions are primarily inserted in order to achieve unambiguous documentation and labeling of the history of the data generation process and of the patient orientation in medical applications. For the actual model building process they can be ignored. The CLI-file generation programm must ensure that if x- and y-coordinates and the positive z-direction are interpreted as righthand system, an anatomically correct model will result! With respect to the coordinate interpretation the following assumptions common in slice oriented imaging modalities are made:
The "volume"/"model"/"stack of layers" coordinate system is defined as a righthand system
with the following properties
* x- and y-axis lie within the image/layer plane with (x) pointing from left to right (y) pointing from top to bottom * The z-axis is orthogonal to the slice/image/layer plane with (z) pointing into the image plane * The patient orientation is described by another righthand system defined by three base vectors: medial-rightlateral (nose->right ear) as x-axis posterior-anterior (spine->chest) as y-axis: "FRONT-VECTOR" caudo-cranial (foot->head) as z-axis: "HEAD-VECTOR"
The "cartesian coordinates" of HEAD-VECTOR and FRONT-VECTOR in the layer coordinate system fully specify the patient orientation! Gantry tilt must be taken into account when converting image matrix coordinates into the layer coordinate system! For the sake of simplicity gantry tilt will be ignored, however, when describing patient orientation (the same effect is caused by putting the patient on a slanted couch).
The following three examples use the definitions axial: orthogonal to HEAD-VECTOR coronal: orthogonal to FRONT-VECTOR sagittal: contains HEAD-VECTOR and FRONT-VECTOR Example 1: Patient in prone position, axial images reconstructed looking in the cranial direction HEAD-VECTOR = ( 0, 0, 1) FRONT-VECTOR = ( 0, 1, 0) Example 2: Coronal reconstructions looking onto the chest of the patient HEAD-VECTOR = ( 0, -1, 0) FRONT-VECTOR = ( 0, 0, -1) Example 3: Sagittal reconstructions looking from the right to the left side of the patient HEAD-VECTOR = ( 0, -1, 0) FRONT-VECTOR = ( 1, 0, 0) Syntax The $$USERDATA section of the CLI-Header (3.1.3) contains information in ASCII-format of the following form (see also page 11) userdata: {userdata-item}...{userdata-item} userdata-item: keyword=text "/0" ("/0" = binary zero) The following keywords are possible institution-id Institution where primary data were generated source-id Additional information specifying the creation of this file, eg. software package and person generating the data set patient-id Qualifier uniquely specifying the patient study-id Qualifier specifying the type of study performed examination-date Date on which examination was performed slice-thickness Slice thickness in mm matrix-size Size of the image matrix (typically 512) pixel-size Size of one pixel in mm gantry-tilt Gantry tilt of the examination in degrees front-vector vector pointing from "spine to chest " expressed in layer coordinates in the form (x,y,z) (see introduction) head-vector vector pointing from "feet to head" expressed in layer coordinates in the form (x,y,z) (see introduction)Example
institution-id=Orthopedic Hospital University of TestTown
source-id=Siemens 3D package Vx.y interactions by Dr. Bone
patient-id=Egon BadLegs I2389/94 20-Jun-1932
study-id=Custom prosthesis left leg
examination-date=20-Jun-1994
slice-thickness=2
matrix-size=512
pixel-size=0.218
gantry-tilt=-7
front-vector=(0,0,1)
head-vector=(0,1,0)
CLI specification page 21


MSToolkit
MSToolkit is a library for handling mass spectrometry data in various file formats. Crux is capable of using MSToolkit to parse spectrum files. The ProteoWizard parser is used by default, but the MSToolkit parser can be used by commands that support the
spectrum-parser
parameter.The following is a list of spectrum file formats supported by MSToolkit.
- MS1/CMS1/BMS1
- MS2/CMS2/BMS2
- ZS
- UZS
- MSMAT
- RAW
- MZXML[.GZ]
- MZ5
- MZML[.GZ]
- MGF (Mascot Generic Format)
- SQLITE3
- PSM


Contents of this page:
VB has the concept of a user Type. A user can define a Type which can then be used to define variables which have one or more properties, each with its own type. The closest Python equivalent is a bare class. VB User Types are converted to bare classes with the appropriate properties. When a user Type is used, an istance of the class is created in the Python code.
Class properties are defined in an __init__ method to avoid having mutable class properties.
| VB | Python |
|---|---|
|
|
There are no options specific to the Type statement.


Canvuus - About
About Us
Canvuus for You and Us
We are a small startup with big ambitions.
We are changing the world. We are helping people improve their lives.
Deep Learning
New era of AI.
Our core competence involves AI technologies,
especially in the area of machine learning.
Our apps are all powered by deeep learning.


|
cds
1.2.0
|
This library is a collection of lock-free and lock-based fine-grained algorithms of data structures like maps, queues, list etc. The library contains implementation of well-known data structures and memory reclamation schemas for modern processor architectures.
Supported processor architectures and operating systems (OS) are:
Supported compilers:
For each lock-free data structure the CDS
library presents several implementation based on published papers. For example, there are several implementations of queue, each of them is divided by memory reclamation schema used. However, any implementation supports common interface for the type of data structure.
To implement any lock-free data structure, two things are needed:
The main part of lock-free data structs is garbage collecting. The garbage collector (GC) solves the problem of safe memory reclamation that is one of the main problems for lock-free programming. The library contains the implementations of several light-weight memory reclamation schemes:
Many GC requires a support from the thread. The library does not define the threading model you must use, it is developed to support various ones; about incorporating cds library to your threading model see cds::threading.
The main namespace for the library is cds
The cds is mostly header-only library. Only small part of library related to GC core functionality must be compiled. The test projects depends on the following static library from boost:
boost_thread
boost_date_time
Prerequisites: for building cds library and test suite you need:
PATH
environment variable should contain full path to Perl binary. Perl is used to generate large dictionary for testing purpose;BOOST_PATH
containing full path to boost
root directory (for example, C:\libs\boost_1_47_0
).Open solution file cds\projects\vcX\cds.sln
where vcX - version of Microsoft Visual C++ you use: vc9 for MS VC 2008, vc10 for MS VC 2010 and so on. The solution contains cds
project and several test projects. Just build the library using solution.
Warning: the solution depends on BOOST_PATH
environment variable that specifies full path to boost
library root directory. The test projects search boost
libraries in:
For Unix-like systems GCC and Clang compilers are supported. Use GCC 4.3 (or above) compiler or Clang 3.0 or above to build cds library. The distributive contains makefile and build.sh
script in build
directory. The build/sample
directory contains sample scripts for different operating systems and processor architectures. The build.sh
script supports the following options:
-c toolset
- Toolset name, possible values: gcc
(default), clang
-x compiler
- C++ compiler name (e.g. g++, g++-4.5 and so on)-p arch
- processor architecture; possible values for arch are: x86, amd64 (x86_64), sparc, ia64-o OStype
- OS family; possible values for OStype are: linux, sunos (solaris), hpux-D define
additional defines-b bits
- bits to build, accepts '64', '32'-l "options"
- extra linker options (in quotes)-z "options"
- extra compiler options (in quotes)–with-boost path
- path to boost include–debug-cxx-options "options"
- extra compiler options for debug target–debug-ld-options "options"
- extra linker options for debug target–release-cxx-options "options"
- extra compiler options for release target–release-ld-options "optons"
- extra linker options for release target–clean
- clean all before building–debug-test
- make unit test in debug mode; by defalt release unit test generated–amd64-use-128bit
- compile with supporting 128bit (16byte) CAS on amd64 (for am64 only)
Important for GCC compiler: all your projects that use libcds must be compiled with -fno-strict-aliasing compiler flag. Also, the compiler option -std=c++0x
is very useful.
To use cds
lock-free containers based on garbage collectors (GC) provided by library your application must be linked with libcds
.
The main part of lock-free programming is garbage collecting for safe memory reclamation. The library provides several types of GC schemes. One of widely used and well-tested one is Hazard Pointer memory reclamation schema discovered by M. Micheal and implemented in the library as cds::gc::HP class. Usually, the application is based on only one type of GC.
In the next example we mean that your application uses Hazard Pointer (cds::gc::HP) - based containers. Other GCs (cds::gc::HRC, cds::gc::PTB) are applied analogously.
First, in your code you should initialize cds
library and a garbage collector in main
function:
Second, any of your thread should be attached to cds
infrastructure.
After that, you can use cds
lock-free containers safely without any synchronization.
In some cases, you should work in a external thread. For example, your application is a plug-in for a server that calls your code in a thread that has been created by the server. In this case, you should use persistent mode of garbage collecting. In this mode, the thread attaches to the GC singleton only if it is not attached yet and never call detaching:


AMAZING PEOPLE MAKING DESIGN IN A FUN ENVIRONMENT
When you work with us you are part of team committed collaborators . All aspect of our software development process are integrated, interactive and agile.
Our approach unifies design, development and product management to create products.
We start each project by understanding your business goals, the user’s needs and the product requirements.
Then we help translate them into effective and elegant solutions.
Before we sign a contract 0r write a line of code our team will spend the necessary time needed to understand your product vision.
The outcome of this scoping session ia proposal or high-level statement of work.
based on your requirements, we can provide acomplete offering or just the piece you need.
Our design practice offers a full range of services including brand strategy, interaction and visual design and user experience testing.
Throughout your project, our designers create and implement visual design and workflows, solicit user feedback and work with you to make sure what gets built is what is needed.
DESIGN
All engineers are fluent in the latest enterprise, mobile and web development technologies.
They collaborate with your team to write, and improve code on a daily basis, using proven practices such as test-driven development and pair programming.
DEVELOPMENT
Planning and development is iterative. Because we are
constantly coding and testing, the products we build are always ready to go live.
This iterative process allows for changes as business
requirements evolve.
PRODUCT MANAGEMENT
GRAY
MIGHTY
ONTARIO
DUNES
JIM CARREY
GOOD DAY
Work
6
BURNED
LOGO
BAILEY
WONGER


One dead in New Zealand volcano eruption, more fatalities likely
by AFPWELLINGTON: New Zealand police said at least one person was killed and more fatalities were likely, after an island volcano popular with tourists erupted Monday, leaving dozens stranded.
“I can confirm there is one fatality” said deputy commissioner John Tims. “There is a number still remaining on the island who are currently unaccounted for,” he added, “at this stage, it is too dangerous for police and rescue services to go to the island.”
Prime Minister Jacinda Ardern confirmed some of those caught up in the disaster were foreigners. “We know that there were a number of tourists on or around the island at the time, both New Zealanders and visitors from overseas.” - AFP


This is the API documentation for version @VERSION@ of the JSimpleDB Java library.
Visit the JSimpleDB homepage at https://github.com/archiecobbs/jsimpledb/.
https://github.com/archiecobbs/jsimpledb/


HaxeFlixel Conditionals
EditWhat is "conditional compilation"?
Conditional compilation flags are a powerful feature Haxe offers to optimize your code by only compiling certain parts of it. For example, the following pseudo-code optimizes inputs based on the target platform:
#if (web || desktop)
keyboardControls();
mouseControls();
#end
#if desktop
gamepadControls();
#end
#if mobile
touchControls();
#end
Basically, this means that for web or desktop targets, we want to have mouse and keyboard controls. In case of a mobile target, we want touch input. Like you can see, these so-called defines can also be nested: We only want gamepad controls to be available on non-web targets (line 4). So, all in all, these defines can be used largely like traditional if-statements, except their syntax varies slightly.
For more information on what defines are available, by default check out the OpenFL documentation on this topic.
HaxeFlixel specific defines
If you had a look at the OpenFL documentation, you might have found out that you can also set your own defines. When working with OpenFL, it's convenient to do so in the Project XML file. HaxeFlixel makes use of this feature and allows you to optimize your game using the following defines (a list of them can also be found in the template):
// Example xml node to enable to Flixel record system.
<haxedef name="FLX_RECORD" />
FLX_RECORD
Flixel features a powerful recording / playback feature which captures mouse and keyboard input. Since it's used rarely, we decided that it makes sense to turn it off by default. Setting this define however will enable it again.
FLX_MOUSE_ADVANCED
This define is required for middle and right mouse button input. On the flash target, a minimum flash player version of 11.2 is required. Listening to right click input will also disable the right-click menu of the flash player. There is currently no HTML5 support for this feature.
FLX_NO_NATIVE_CURSOR
By default, flixel uses the flash native cursor API. This gets rid of the almost unbearable mouse lag that is unavoidable otherwise. This define allows you to disable that - reasons for this might be that you want to target a flash player version older than 10.2 or that you need to use a cursor bigger than 32x32, which is not possible using the native cursor API.
FLX_NO_MOUSE
This allows you to optimize your game by compiling it without any mouse-related code, which can make sense for mobile targets. This is why in the template, if="mobile"
is added to the haxedef set tag. Keep in mind that this might require you to use conditionals in your own code for anything related to FlxG.mouse
, which does not exist if this define is set.
FLX_NO_KEYBOARD
This allows you to optimize your game by compiling it without any keyboard-related code, which can make sense for mobile targets. This is why in the template, if="mobile"
is added to the haxedef set tag. Keep in mind that this might require you to use conditionals in your own code for anything related to FlxG.keyboard
or FlxG.keys
, which do not exist if this define is set.
FLX_NO_TOUCH
This allows you to optimize your game by compiling it without any touch-related code, which can make sense for desktop targets. This is why in the template, if="desktop"
is added to the haxedef set tag. Keep in mind that this might require you to use conditionals in your own code for anything related to FlxG.touches
, which does not exist if this define is set.
FLX_NO_GAMEPAD
This allows you to optimize your game by compiling it without any gamepad-related code. Keep in mind that this might require you to use conditionals in your own code for anything related to FlxG.gamepads
, which does not exist if this define is set.
FLX_NO_SOUND_TRAY
This disables the flixel core sound tray, which appears whenever your adjust the volume via the 0 (mute the game), + or - keys. Note that this does not disable the ability to control the game's volume using these hotkeys, just the soundtray itself. You can disable volume control entirely by setting FlxG.sound.muteKeys
, FlxG.sound.volumeUpKeys
and FlxG.sound.volumeDownKeys
to null
.
FLX_NO_FOCUS_LOST_SCREEN
Flixel automatically pauses the game when it loses focus and shows its so-called "focus lost screen", which is basically an overlay darkening the screen area with a white "play-button" in the middle. Using this define disables that screen, but not the feature to automatically pause - use the FlxG.autoPause
Bool for that.
FLX_NO_DEBUG
This disables the flixel core debugger, which you can toggle using the \ and ` keys. It makes sense to do so for release build, which is why unless="debug"
is added to this tag in the template. It basically means that the flixel debugger is disabled when compiling a release, and enabled when compiling a debug build.


XRP TipBot Stats 2019-11-15 Overall (~Dec. ‘17 - ) 2019 Known accounts (once had or still have balance) 59,272 36,650 Amount of tips 707,782 605,134 Amount of XRP tipped 1,842,301.211077 1,709,679.358355 Active (tip sending) users 13,755 9,612 » Amount of tips, specifie...


Bivek Karki
Student
Lovely Professional University
(11609886)
Jyotish Mandal
Student
Lovely Professional University
(11617152)
Dipesh Neupane
Student
Lovely Professional University
(11617061)
Baljinder Singh
Student
Lovely Professional University
(11302336)


{% extends "base.html" %} {% block title %}
Medieval catalogues > BRIGITTINES > Syon > Class-marks reconstructed from Betson's Index and from erasure
{% endif %}513 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


JavaScript Training
Fundamental
- Intro to JavaScript
- Data Type: Number, String, Bloolen, and Comparisons
- Variable
- Control Flow
- Functions
- Data Structures: Array
- Data Structures: Objects
- Loops
- Javascript Keywords
Variables, Data Type, and Operators
Examples
Exercises: Number, String, Boolean, Comparisons
Exercises
Functions & Scope
Code Examples
Exercies
Control Flow
Examples
Exercies
Advanced Features
Scope
Exercises:
Advanced Control Flow
Exercises
ES5 and ES6
let & const
Variable Declaration with let & const Code Examples
Exercises:
Blocks and IIFEs
Code Examples
String Template Literals
Code Examples
String Methods
String methods Examples
Arrow Functions
Arrow function example code
Lexical 'this' keyword
this keyword
Destructuring
Array Iteration in ES6
Example Code
Spread Operator
Example
Rest Parameters
Example
Maps
Example
Classes and Subclasses
Code Examples
ES6 Coding Exercices
Code Test Page
Objects & Functions
Example Code
Exercises:
Advance Arrays
Exercises:
Example code
Exercises:
ES7
Example Code
ES8
Example Code
Exercies:
ES8 & ES9 Async
ES10 (2019)
Feature: flat()
Code Example
ES10 Exercises
Advanced Loop
Code Example
Exercises:
Asynchronous JavaScript: Promises, Async/Await and AJAX
Asynchronous JavaScript
Code Examples
AJAX and APIs
Metaweather.com API
Code Example
React.js + Redux
Code Example


It is to the passenger's advantage to provide the required data elements as doing so may prevent delays or inconveniences at the airport which may differentiate you from individuals on the government watch list.
It is to the passenger's advantage to provide the required data elements as doing so may prevent delays or inconveniences at the airport which may differentiate you from individuals on the government watch list.
It is to the passenger's advantage to provide the required data elements as doing so may prevent delays or inconveniences at the airport which may differentiate you from individuals on the government watch list.
It is to the passenger's advantage to provide the required data elements as doing so may prevent delays or inconveniences at the airport which may differentiate you from individuals on the government watch list.
It is to the passenger's advantage to provide the required data elements as doing so may prevent delays or inconveniences at the airport which may differentiate you from individuals on the government watch list.
Sign up to our newsletter to recive directly on your email our news & latest offers:


"Creative Designer And Artist "
Your Satisfaction is our mission.
Digital art is an artistic work or practice that uses digital technology as part of the creative or presentation process...
Vector artwork is built from vector graphics, which are images created with mathematical formulas. In comparison, raster art ( ... improve modify, adapt your design.
My site contains fine art. I draw with graphite pencil in the style of realism. Original drawings and prints are for sale and I take commissions. I also offer basic to ....


| Home | Trees | Indices | Help |
|
|---|
|
|
ast ~~~ The `ast` module helps Python applications to process trees of the Python abstract syntax grammar. The abstract syntax itself might change with each Python release; this module helps to find out programmatically what the current grammar looks like and allows modifications of it. An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as a flag to the `compile()` builtin function or by using the `parse()` function from this module. The result will be a tree of objects whose classes all inherit from `ast.AST`. A modified abstract syntax tree can be compiled into a Python code object using the built-in `compile()` function. Additionally various helper functions are provided that make working with the trees simpler. The main intention of the helper functions and this module in general is to provide an easy to use interface for libraries that work tightly with the python syntax (template engines for example). :copyright: Copyright 2008 by Armin Ronacher. :license: Python License.
Version: 82160
|
|||
|
NodeVisitor A node visitor base class that walks the abstract syntax tree and calls a visitor function for every node found. |
|||
|
NodeTransformer A :class:`NodeVisitor` subclass that walks the abstract syntax tree and allows modification of nodes. |
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|
|||
PyCF_ONLY_AST = 1024
|
|||
__package__ =
|
|
Parse the source into an AST node. Equivalent to compile(source, filename, mode, PyCF_ONLY_AST). |
Safely evaluate an expression node or a string containing a Python expression. The string or node provided may only consist of the following Python literal structures: strings, numbers, tuples, lists, dicts, booleans, and None. |
Return a formatted dump of the tree in *node*. This is mainly useful for debugging purposes. The returned string will show the names and the values for fields. This makes the code impossible to evaluate, so if evaluation is wanted *annotate_fields* must be set to False. Attributes such as line numbers and column offsets are not dumped by default. If this is wanted, *include_attributes* can be set to True. |
When you compile a node tree with compile(), the compiler expects lineno and col_offset attributes for every node that supports them. This is rather tedious to fill in for generated nodes, so this helper adds these attributes recursively where not already set, by setting them to the values of the parent node. It works recursively starting at *node*. |
Increment the line number of each node in the tree starting at *node* by *n*. This is useful to "move code" to a different location in a file. |
Return the docstring for the given node or None if no docstring can be found. If the node provided does not have docstrings a TypeError will be raised. |
Recursively yield all descendant nodes in the tree starting at *node* (including *node* itself), in no specified order. This is useful if you only want to modify nodes in place and don't care about the context. |
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Mon Aug 10 11:12:34 2015 | http://epydoc.sourceforge.net |


The .NET Core ORM Cookbook
In October of 2016, InfoQ published a series of articles on the repository pattern in .NET. To illustrate the concepts three ORMs were demonstrated: Entity Framework, Dapper, and Chain.
A criticism of the articles was that it didn’t include many people’s favorite ORM. So as a follow up, this GitHub repository was created to expand on that idea and create a shared “cookbook” of design patterns for any or all of the .NET ORMs. Contributions are welcome.
In December of 2019, the ORM Cookbook project was revived with an emphasis on modern, production grade programming. This means that each example must take into consideration these factors:
- Exception handling
- .NET Core Support
- C# 8 Nullable Reference Types
- Static Code Analysis (e.g. FxCopAnalyzers)
When contributing recipes, please keep in mind the best practices for the ORM you are working with as novices may be using the code without fully understanding it.
Original InfoQ Articles
- Implementation Strategies for the Repository Pattern with Entity Framework, Dapper, and Chain
- Advanced Use Cases for the Repository Pattern in .NET
Presentation
Each ORM is presented as its own xUnit test project. The actual recipes are in the Models and Repositories folder.
To ensure each ORM is "playing by the rules", a shared set of tests will be used. The tests are arranged into "scenario" classes. Each ORM can opt in for a given scenario by inheriting from the appropriate class. This can be done multiple times if the ORM wishes to demonstrate alternate patterns.
Each scenario has a matching markdown file in which the code samples can be added along with any relevant explanations. When possible, use Projbook notation to inline code samples. This will prevent the code samples from getting out of sync with the documentation.
If you build the “Documentation” project, the cookbook will be compiled as a website.


Folders
<Go Back>
2-why-rounded-down
4-endless...-error
9-random-...in-max
1-sum-interface
3-repeat-...number
8-random-min-max
Folders: 7


Highly
Cohesive: Individual pieces function together well as an integrated whole.
Individual tasks are not sacrificed for the good of the whole.
Loosely
Coupled: Changes in implementation of one piece dont effect other pieces.(Operating
system upgrades, design changes for different modules, etc.)
Modular:
Broken down into component pieces. Easy to delegate pieces to teams.
Easy to dedicate machine resources to true cause without affecting un-related
processing. see Scaleable and Distributed.
Distributed:
Processing is shared across multiple machines; goal is to isolate resource
use so that hardware/software can be deployed to fit needs. Modularity is
logical, distribution is physical.
Extensible:
Un-anticipated requirements and/or features can be accommodated
without fundamental re-design.
Scaleable:
Huge increases in users/volumes can be accommodated without fundamental
re-design. Modules can be re-distributed without negative impacts.


Make your next musical experience worry-free with planning before the show even starts. Select a musical genre to discover events in Washington, DC Rock EDM Country Folk Hip-Hop / Rap Pop R&B Choose


| �ӿ� | ˵�� |
|---|---|
| Debug.LevelId |
Provides access to raw level value.
|
| Length |
Gets the length of the object.
|
| Offset |
Gets an offset for the object.
|
| Timeout |
The Interface Timeout.
|
| �� | ˵�� |
|---|---|
| BlockingQueuePump<T> |
The Class BlockingQueuePump.
|
| DataUtils |
Various data manipulation utilities.
|
| Debug |
Specialized debug class that provides debugging and tracing services.
|
| ExpandableString |
A special string that allows easy expandibility within it.
|
| HoldQueue<T,C> |
The Class HoldQueue.
|
| HoldQueue.HoldHandle<C> |
The Class HoldHandle.
|
| JEvent |
An event object and event related utilities.
|
| JLogger |
Java Logging mechanism.
|
| JNetPcapFormatter |
The Class JNetPcapFormatter.
|
| JPacketSupport |
A utility class that dispatches a JPacket to any number of listeners.
|
| JPacketSupport.Entry |
The Class Entry.
|
| JStringBuilder |
Subclassible delagate StringBuilder class.
|
| JThreadLocal<T> |
The Class JThreadLocal.
|
| PcapPacketArrayList |
The Class PcapPacketArrayList.
|
| PcapPacketSupport |
A utility class that dispatches a PcapPacket to any number of listeners.
|
| PcapPacketSupport.Entry |
The Class Entry.
|
| SlidingBuffer |
The Class SlidingBuffer.
|
| TimeoutQueue |
The Class TimeoutQueue.
|
| Units |
The Class Units.
|
| ö�� | ˵�� |
|---|---|
| Debug.Level |
Defines various message severity levels.
|


Shows where people are in the domain.
- Works in both HMD and desktop.
- The center is your camera location.
-
The orientation is per:
- The tablet in HMD mode.
- Your camera in desktop mode.
- Your avatar is displayed as a green dot per the settings.
-
Other peoples’ avatar dots are colored:
- Blue if above you: blueness increases with height difference.
- White if level with you.
- Red if below you: redness increases with height difference.
-
To show display names:
- Hover a dot to show the avatar’s display name.
- Click the dot to persist showing its display name.
- Stop showing a display name by clicking the dot, the display name, or the radar background.
-
To teleport:
- Click and hold on the radar circle. A green search circle is displayed.
- The horizontally closest avatar is highlighted as are any of similar elevation.
- Release the click to teleport to that position at the elevation of the closest avatar, or your
current elevation if no avatar is in the search circle.
- To cancel a teleport, drag off the radar circle.
- The scale sets the search radius and distances above and below.
- The avatars count is the number of avatars displayed.
Settings:
- Show own avatar: Configure when to show a dot for your own avatar.
- Refresh rate: Configure how often the avatar dots and radar orientation are updated.
Disclaimers:
- The user identification provided by this app is not guaranteed: users can set their display name to
whatever they like.
- The content of the display names displayed by this app is not moderated by this app.
More information: http://ctrlaltstudio.com
Copyright 2017-2020 David Rowe.
Distributed under the Apache License, 2.0..
Donations appreciated.


How I'll be Grading
I'll be grading based on in class participation - 5%, idea actualization - 5%, your project code 50%, user experience 30%, and presentation 10%.
Class Presentations
15 - 20 minutes. 5 - 10 minutes for questions.
Talk about the things you build
Look for jobs where you can strut your new python skills
You know more than you think you do.
Slowly bring python into your job.
Read books
Pro Python and Effective Python are very good for where you are right now.
Let's keep in touch
I've been thinking of doing a monthly meet up of former students and other community members of mine.


| Package | com.flashdynamix.utils |
| Class | public class SWFProfiler |
| Property | Defined by | ||
|---|---|---|---|
| averageFps : Number [static][read-only]
| SWFProfiler | ||
| currentFps : Number [static][read-only]
| SWFProfiler | ||
| currentMem : Number [static][read-only]
| SWFProfiler | ||
| fpsList : Array [static]
| SWFProfiler | ||
| history : int = 60 [static]
| SWFProfiler | ||
| maxFps : Number [static]
| SWFProfiler | ||
| maxMem : Number [static]
| SWFProfiler | ||
| memList : Array [static]
| SWFProfiler | ||
| minFps : Number [static]
| SWFProfiler | ||
| minMem : Number [static]
| SWFProfiler | ||
| refreshRate : Number = 1 [static]
| SWFProfiler |
| Method | Defined by | ||
|---|---|---|---|
|
gc():void
[static]
Garbage collect the SWF.
| SWFProfiler | ||
|
init(context:InteractiveObject):void
[static]
Iniates the SWFProfiler to the ContextMenu of the reference passed.
| SWFProfiler | ||
|
start():void
[static]
Starts updating the Profiler.
| SWFProfiler | ||
|
stop():void
[static]
Stops updating the Profiler.
| SWFProfiler |
| averageFps | property |
averageFps:Number
[read-only]Implementation
public static function get averageFps():Number
| currentFps | property |
currentFps:Number
[read-only]Implementation
public static function get currentFps():Number
| currentMem | property |
currentMem:Number
[read-only]Implementation
public static function get currentMem():Number
| fpsList | property |
public static var fpsList:Array
| history | property |
public static var history:int = 60
| maxFps | property |
public static var maxFps:Number
| maxMem | property |
public static var maxMem:Number
| memList | property |
public static var memList:Array
| minFps | property |
public static var minFps:Number
| minMem | property |
public static var minMem:Number
| refreshRate | property |
public static var refreshRate:Number = 1
| gc | () | method |
public static function gc():void
Garbage collect the SWF.
| init | () | method |
public static function init(context:InteractiveObject):void
Iniates the SWFProfiler to the ContextMenu of the reference passed.
Parameterscontext:InteractiveObject |
| start | () | method |
public static function start():void
Starts updating the Profiler.
| stop | () | method |
public static function stop():void
Stops updating the Profiler.


{% extends "base.html" %} {% block title %}
Medieval catalogues > SECULAR INSTITUTIONS: Secular Colleges > Beverley, Minster > Bequest by William de Waltham, 5 October 1416
{% endif %}2 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


Home
About
Porfolio
Services
Blog
Contact
Pages
Shop
Purchase!
Industrial Designing
Focused on Industrial, Machinery, Product & Vehicle design
Buy Throne
Filter
All
Chairs
Creative
Dishes
Lamps
Others
Tables