Jet-Set Willy II Room Format
Version 0.9.1: 10 December 2005
by John Elliott
Disclaimer: I do not guarantee this information to be correct. This is my best guess at what is going on inside JSW II, after wandering around inside it with a disassembler.
New for v0.9.1: More notes on CPC versions.
New for v0.9: Some notes on the room format used by CPC6128 JSW, upon which JSW2 is based.
New for v0.8: Some more details on lifts.
New for v0.7: Added the title screen and music formats.
New for v0.6: Added various game engine limits.
New for v0.5: Corrected various guardian values.
New for v0.4: More corrections from Andrew Cadley.
New for v0.3: Andrew Cadley has supplied details of the T4, CG0 and CG1 bytes.
1. Terminology
Unless otherwise specified, this document refers to the Spectrum version of JSW2. Notes of differences in the CPC implementations of JSW1 and JSW2 (which both appear to use a JSW2ish engine) are prefaced [CPC].
The room layouts in Jet Set Willy I were composed of four elements:
- Air
- Willy can walk or jump through it, but not stand on it.
- Water
- As Air, but Willy can also stand on it.
- Earth
- Willy can stand on it, but not walk or jump through it.
- Fire
- Willy loses a life if he touches this.
I have retained this system in describing JSW2, although ramps, conveyors and items are also "elements" now.
2.Snapshot encryption
All information has been deduced from a snapshot of JSW2 taken while the title screen was showing and before a game had been started. JSW2 is encrypted, so .TAP files and snapshots taken before the title screen appeared will not match this pattern.
[CPC] The formats used by CPC versions come from snapshots taken in a CPC emulator in CPC464 mode. I have not made more than a cursory attempt to reconcile them with the disc files (JET*.BIN) comprising CPC JSW.
3. Room entries
JSW2 contains a table of 16-bit pointers to room entries:
TABLE: DW ROOM0 DW ROOM1 ...
For JSW editor authors: This table is at BAFDh in JSW2. But you are encouraged not to treat its address as permanent. It is between two blocks of compressed data, so it may be useful to move it around as the number of rooms in the game increases or decreased. Instead, find the address of this table from the word at 7E69h.
Similarly, JSW2 has 134 entries in this table. But it's preferable to calculate the number of rooms as (ROOM0 - TABLE) / 2, since there's no game-specific reason why there shouldn't be more or fewer entries.
[CPC] In the CPC version, this table is at 38B0h (JSW1) / 5C00h (JSW2).
Each room entry is formed:
+0 DW RDATA ;Address of room shape (Room shapes: Section 4) ;In JSW2, the room shapes are stored separately from the rooms, ;with their own compression system. +2 DB HBITS ;High bits ;These are combined with the next 8 bytes to form 9-bit ;values. Bit 7 of this byte gives Bit 8 of U0; ; Bit 6 of this byte gives Bit 8 of U1; ; ... ; Bit 0 of this byte gives Bit 8 of U7. +3 DB U0 ;Cell pattern for Water (Cell patterns: Section 5) +4 DB U1 ;Cell pattern for Earth +5 DB U2 ;Cell pattern for Fire +6 DB U3 ;Cell pattern for "/" ramps +7 DB U4 ;Cell pattern for conveyor going left +8 DB U5 ;Cell pattern for item +9 DB U6 ;Cell pattern for "\" ramp +A DB U7 ;Cell pattern for conveyor going right ;[CPC] The CPC version has four additional bytes here. ;Presumably they control the palette registers, since different ;rooms appear in different colours. +B DB xname ;Number of spaces to print before the room name ;(to position it centrally). This also contains ;the border colour in bits 2-0. +C DB name ;Variable-length ASCII string, with bit 7 set on ;the last character. Bytes 1-30 are expanded to ;common words using a dictionary at 0FA81h, in the ;same format as the keyword table in the Spectrum ;ROM. Note that because bit 7 is set on the last character, ;the last character is not in the range 1-30 and is not ;expanded. ; [CPC] The CPC versions do not appear to compress ; room names. DB left ;Exit left } DB up ;Exit up } Room nos. DB right ;Exit right } DB down ;Exit down } DB T4 ;Bit 7: Set if there is a rope in the room ;Bit 6: Set to animate conveyor belt. Conveyors can only be ; animated if there is a single conveyor in the room. ; This is because the animation code assumes all ; conveyor cells in the room are contiguous, and draws ; one long animated strip starting at the first ; conveyor cell in the room. ; ;Bit 5: If conveyor belts are animated: ; 0: Only the top row of the conveyor ; animates. ; 1: The top and third rows animate. ;Bit 4: If set of T4 is set, byte T5 is present; ; otherwise byte T5 is assumed to be 0. ;Bits 0-3: Number of guardian records ; that follow. Numbers greater than 8 are ; treated as 0. ( DB T5 ;Bits 0-5: Special-case code ID. ) ;If bit 7 of this byte is set, arrows are present. DS 7 ;Guardian record 0 DS 7 ;Guardian record 1 ... DS 7 ;Guardian record {n} ( DB AC ;(if arrows present) No. of arrow records that follow DS 2 ;Arrow record 1 DS 2 ;Arrow record 2 ... DS 2 ) ;Arrow record {n} ; ;End of room ;
JSW2 allows a total of eight guardians or arrows in each room.
4. Room shape
The room shape is stored as a stream of bytes, each describing one or more character cells. The decompression code continues expanding until 512 cells been described. Cells are decompressed as horizontal sequences, starting at the top left corner.
Each byte is either:
- Less than 90h:
- Bits 0-3 give (number of repetitions - 1)
- Bits 7-4 give the cell type (0-8):
- 0
- Air
- 1
- Water
- 2
- Earth
- 3
- Fire
- 4
- Ramp going northeast ("/")
- 5
- Conveyor going left
- 6
- Item. There can be at most 16 items per room. JSW2 doesn't have a global item table; it uses a table of 16-bit words for each room. Set bits in a word correspond to untaken items.
- 7
- Ramp going northwest ("\")
- 8
- Conveyor going right
- 90h or more: Cell type is 0. Bits 7-0 give (number of repetitions + 7Fh).
Special arrangements exist for Room 108, the Cartography Room. Water cells in this room map to rooms in other parts of the game; a table at 0FBE8h gives the mapping (it starts 74h, 75h, 76h; so the first water cell depends on room 74h, the second on room 75h, and the third on room 76h).
[CPC] In CPC JSW1, this table is at 4CE5h. In CPC JSW2, this table is at 0A700h but does not appear to be populated in the snapshot I'm working from.
5. 8x8 Cells
Cells have a 9-bit number (see above). To find the address of a cell, multiply this number by 9 and add 8C78h ([CPC]: 0B60h for JSW1, 4C00h for JSW2). The cell is then formed: one attribute byte, and 8 bitmap bytes.
Bit 7 of the attribute byte means 'inverse' rather than 'flash'. The game startup code inverts any such cells and clears bit 7. All cells are drawn in bright colours, so bit 6 (bright) may also have an alternative meaning.
[CPC] The attribute byte behaves differently:
- Bits 0-1: Foreground colour 0-3
- Bits 2-3: Background colour 0-3
- Bits 4-7: Do not seem to be used
6. Guardians
A compressed guardian record is 7 bytes (CG0-CG6):
CG0: } Limits of movement. When you first enter a room a counter is CG1: } initialized with the value of CG0, this is decremented on each pass through the game loop. Each time the counter reaches 0 it is reloaded from CG1, the guardian's direction is reversed, and the process begins again. CG2: Low 8 bits of sprite number CG3: Primary movement step (8-bit signed integer). Doubling the movement step makes a sprite go twice as far as well as twice as fast, while reversing its direction swaps the limits of travel over. On horizontal sprites, this also affects the animation step. CG4: Bit 7 is bit 8 of sprite number. Bits 6-0 are initial X coordinate. CG5: Bit 7 is set if the guardian is unidirectional (cf: Megaron). Bits 6-0 are initial Y coordinate. CG6: Bits 1-0 is animation mask. This is: 0: None 1: Frames 1,2 } 2: Frames 1,3 } (taking account of reversal, see bit 6) 3: Frames 1,2,3,4 } Bits 3-2 give colour. This is 0: White 1: Yellow 2: Cyan 3: Green (A 4-byte table at 70A9h gives these colours. For some reason, unidirectional guardians are always drawn in white). Bits 4-5 give secondary movement step. For horizontal/vertical guardians, this is 0. For a diagonal guardian, if bit 7 is set, this is the vertical step; otherwise, it's the horizontal step. Bit 6 is set to swap between frames 0/1/2/3 and 4/5/6/7 when the guardian reverses. Bit 7 is set to move horizontally, clear to move vertically. Combining it with bits 4 and 5 we have: Bit 7 Bit 5 Bit 4 ================================================== 0 0 0 Vertical 0 0 1 45 degrees from horizontal 0 1 0 22 degrees from horizontal 1 1 1 18 degrees from horizontal 1 0 0 Horizontal 1 0 1 18 degrees from horizontal 1 1 0 22 degrees from horizontal 1 1 1 45 degrees from horizontal
A compressed arrow record is 2 bytes:
DB AB0 ;Arrow X position DB AB1 ;Bit 7 set if going left, else right. ;Bits 6-0 are Y positionJSW II decompresses arrows and guardians to 17-byte guardian records (UG00-UG10). Here is how it does it:
Byte Meaning How set ==================================================================== UG00 Arrow Address of arrow sprite - EB01h or EB21h. UG01 address if (AB1 & 80h) then EB01h, else EB21h. UG02 counter (initialised to CG0) UG03 counter reset value, set to CG1 UG04 X step If arrow and bit 7 of AB1 is 1: 0FFh If arrow and bit 7 of AB1 is 0: 1 If bit 7 of CG6 is 0: = Bits 4 and 5 of CG6 (2ndary step) If bit 7 of CG6 is 1: = CG3 (primary step) UG05 X If arrow, AB0 else CG4, bits 6-0 (0-7Fh) UG06 Y step If arrow, set to 0 If bit 7 of CG6 is 0: = CG3 (primary step) If bit 7 of CG6 is 1: = Bits 4 and 5 of CG6 (2ndary step) UG07 Y If arrow: (AB1 & 7Fh) else CG5, bits 6-0 (0-7Fh) UG08 Styles If arrow: 88h else (CG6 & 0F3h) UG09 Sprite Address of sprite page. Given by ((CG2 | 2*(CG4 & 80h)) UG0A address * 16) + 0D4A1h UG0B ? Used for incremental calculation of sprite position UG0C ? Used for incremental calculation of sprite position UG0D ? Used for incremental calculation of sprite position UG0E Unidirectional If arrow: 0 If bit 7 of CG5 is 1: = 0FFh. If bit 7 of CG5 is 0: = 0. If a guardian is unidirectional, and either UG04 (X step) is negative, or UG06 (Y step) is strictly positive, then the guardian isn't drawn. UG0F ? Character cell X-position of guardian UG10 Attribute (purpose of top bit unknown) If arrow: 87h If bit 7 of CG5 is 0: loaded from 70A9 + ((CG6 >> 2)& 3) This array is {87h, C6h, C5h, C4h} If bit 7 of CG5 is 1: 80h
7. Special-case code.
JSW2 has a table of special-case code at 8361h ([CPC]: 6BC1h for JSW1, 9BDAh for JSW2), which has two words for each ID. It starts at ID 1:
dw sc1a ;For ID=1 dw sc1b dw sc2a ;For ID=2 dw sc2b ... ;etc.
The two routines appear to be an initialisation function and a function called once every time the game loop is run.
A routine address can be 0 if only one of the two routines is being supplied.
Special case code IDs are:
- Central Cavern: If Willy has won, jump on the spot repeatedly.
- Lift 1: Draw lifts using the 1st pair of lift definitions.
- Lift 2: Draw lifts using the 2nd pair of lift definitions.
- Lift 3: Draw lifts using the 3rd pair of lift definitions.
- Lift 4: Draw lifts using the 4th pair of lift definitions.
- The Trouble With Tribbles: Moving floor segments.
- Is not used in Spectrum JSW2, and appears to have no effect. [CPC] Doesn't seem to be used in CPC JSW either; curious.
- Rocket Room. When Willy reaches particular coordinates, the central section of the room takes off and Willy is transported to the room above.
- The Bathroom. Draws the toilet. If Willy hits it and the game is won, then move him to room 133 (Central Cavern). Also, make Willy run to the right if the game is won.
- Master Bedroom. Removes Maria if 150 or more items have been collected. If Willy is standing on a right-moving conveyor (ie, the bed) then start him running to the right.
- Beam Me Up/Down Spotty: Enables teleporters to be used in this room.
- Belfry: Draws ropes above vertical guardians.
- Eggoids: Makes diagonal guardians reverse when they hit the top or bottom of the screen.
- The Yacht: Deals with the Yacht sailing away.
- Trip Switch: Handles what happens when Willy touches the Trip Switch. The left conveyor graphic is used for the "off" switch, and the right conveyor for the "on" switch.
- Rigor Mortis: If all items have been taken from room 75, sets the first two guardians in the room to have X steps of -1 and +1, and counter values of 28, respectively.
- Crypt Switch. Adjusts the X step and counter of the first guardian in the room.
- Foot Room. Puts a foot at the top of the room, which drops when all items have been taken from room 103.
- Lift 5: Draw lifts using the 6th pair of lift definitions.
- First Landing: Make 'fire' cells flash. Also, make Willy run to the right if the game is won.
- Lift 6: Draw lifts using the 7th pair of lift definitions. Also makes fire cells flash.
- Deserted Isle: Handle all the complicated behaviours of that complicated room. Allows teleporters to be used.
- Macaroni Ted: Make Willy run to the right if the game is won.
- Dumb Waiter: Draw lifts using the 5th pair of lift definitions. Also, make Willy run to the right if the game is won.
- Highway to Hell: Moving floor segments. [CPC] CPC JSW does not use this entry; it appears to have no effect.
- Is not used in Spectrum JSW2, and appears to have no effect.
[CPC] In JSW1 for the CPC, most of these are set to zero since they refer to rooms in the JSW2 extended areas. Those that remain keep the same numbers.
Lifts
This system is used to implement lifts. There is a table of lift definitions (in compressed guardian format) at 0FB30h ([CPC JSW2]: 7A28h). Lifts go around in pairs, like policemen; so the first two lifts will be for one room, the next two for the next room, and so on.
Each lift uses a guardian slot; so any room with lifts can only have up to six guardians.
8. Teleporters
There are four teleporters in the game; you will find their definitions at 7435h ([CPC JSW2]: 9698h). A teleporter definition is 6 bytes long:
DB from ;Room to teleport from DB x ;X location within the room DB y ;Y location within the room DB to ;Room to teleport to, plus 1 DB x ;New X location DB y ;New Y location
Teleporters only work if the special-case number for the room is 11 or 22.
9. The title screen
The title screen tune is from 0FC69h to 0FCCCh, terminated with 0FFh. It is in the same format as the JSW1 title screen music.
The title screen itself lives between 0FCCDh and 0FE72h, terminated with 0FFh. Each byte corresponds to one character cell, with the first one at x=18, y=2; the next is drawn at x=19, y=2, and so on. A byte has the following meaning:
- If bit 7 is set: Draw slope. Bit 6 is 0 for a / slope, 1 for a \ slope.
- If bit 7 is not set: Leave cell blank.
- Always: Bits 2-0 give ink, bits 5-3 give paper. Bright is always on. Flash is always off, with one exception: If ink=6 and paper=6, you instead get flashing magenta on yellow. This attribute can be found at 0FECDh.
The four 'slope' graphics live from 0FE73h to 0FE92h. Each is an 8x8 graphic in UDG format. The first two are for a / slope, and the second two for a \ slope.
10. The in-game tune
The in-game tune lives at 0FAF0h and is exactly 64 bytes long. It's in the same format as the Manic Miner / JSW1 in-game music.
John Elliott 6-12-2005.Thanks also to: Andrew Cadley.


Interactive Learning for Point-Cloud Motion Segmentation
Yerry Sofer
|
|
|
|
The Open University of Israel
|
The Open University of Israel
|
Ben-Gurion University
|
Motion segmentation of dynamic point-cloud scenes.. Given a dynamic
scene of two people walking under a bridge with their paths intersecting (left),
we simulate its scan (mid-left) and compute its fg/bg segmentation. We adaptively
refine the decision border of our classifier (mid-right) resulting in an accurate
motion (fg) separation (right).
Abstract: Segmenting a moving foreground
(fg) from its background (bg) is a fundamental step in many Machine Vision and Computer
Graphics applications. Nevertheless, hardly any attempts have been made to tackle
this problem in dynamic 3D scanned scenes. Scanned dynamic scenes are typically
challenging due to noise and large missing parts. Here, we present a novel approach
for motion segmentation in dynamic point-cloud scenes designed to cater to the unique
properties of such data. Our key idea is to augment fg/bg classification with an
active learning framework by refining the segmentation process in an adaptive manner.
Our method initially classifies the scene points as either fg or bg in an un-supervised
manner. This, by training discriminative RBF-SVM classifiers on automatically labeled,
high-certainty fg/bg points. Next, we adaptively detect unreliable classification
regions (i.e. where fg/bg separation is uncertain), locally add more training examples
to better capture the motion in these areas, and re-train the classifiers to fine-tune
the segmentation. This not only improves segmentation accuracy, but also allows
our method to perform in a coarse-to-fine manner, thereby efficiently process high-density
point-clouds. Additionally, we present a unique interactive paradigm for enhancing
this learning process, by using a manual editing tool. The user explicitly edits
the RBF-SVM decision borders in unreliable regions in order to refine and correct
the classification. We provide extensive qualitative and quantitative experiments
on both real (scanned) and synthetic dynamic .
Reference:
Y. Sofer, T. Hassner, and A. Sharf, Interactive Learning
for Point-Cloud Motion Segmentation, In Computer Graphics Forum, vol. 32, no.
7, pp. 51-60. 2013
Click here for the PDF
Click here for the BibTex
Click here for slides from the POCV14 workshop, CVPR'14
Dynamic point cloud data
We provide the data used in the experiments reported in our paper.
The data in the files below is formatted one point per row. Each row includes the
following values:
X Y Z nX nY nZ R G B
Where:
- X Y Z are the spatial coordinates of each point (float)
- nX nY nZ are the estimated normal at that point (float)
- R G B are the color values at the point, but should not be used / unreliable (integer)
Each archive contains one file per frame, where file names indicate the frame number. The following point clouds are available:
- Real scan - set2 (483Mb)
- Real scan - data2 (130Mb)
- Real scan - data3 (134Mb)
- Real scan - scan2 (106Mb)
- Synthetic scan - sc2_10 (3Mb)
- Synthetic scan - sc3_10 (4.5Mb)
- Synthetic scan - complex (12.5Mb)
This data is free to use for academic purposes only. If you use this data in your work, please provide appropriate citations to our paper.
Last update 24th of Aug., 2014
|


How to search for a seller on eBay in 2 different ways
by Kelly Laffey, Business Insider US- You can search for a seller on eBay using the site’s advanced search function.
- You can also find a seller’s page by first finding an item that they have for sale.
- Visit Business Insider’s homepage for more stories.
So you purchased an item on eBay and were particularly thrilled by the level of service you received from the seller.
If you want to buy from them again, you’re able to easily search for a seller using eBay‘s advanced search feature.
Alternatively, you can first find an item that seller has and then navigate to the seller’s store from there.
How to search for a seller on eBay
1. Click on the “Advanced Search” link to the right of the search bar on the eBay homepage. This will bring you to the advanced search screen.
2. Hit the “By Seller” link on the left side of the page.
3. Check the box that says “Only show items from” and then select the “Specific Sellers” bullet point.
4. Enter the seller’s ID in the text box, and hit “Search.”
5. If you don’t know a seller’s ID, you can find it by selecting an item that you know the seller has in his or her store. The seller’s name will be on the right side of the page under “Seller Information.” Select the name to be taken to a page that will display all the items that the seller has available for purchase.
Related coverage from How To Do Everything: Tech:
-
How to send an invoice on eBay to remind your customers to pay you
-
How to cancel a ‘Best Offer’ on eBay if your reason meets the site’s requirements
-
How to track an eBay order if the seller has provided tracking information, or contact the seller for updates
-
How to leave feedback on eBay as a buyer or seller


Spread the word with Twitter hashtag #DetroitWater.
Tweet
Over 300,000 Detroit residents face water shutoffs due to past due water bills exacerbated by Detroit's ongoing economic woes.
Do you know someone who needs help? Send them here.
We match you to a Detroit resident you can help directly by submitting a payment to the Detroit Water and Sewerage Department on their behalf.
You will receive the following information for a Detroit resident you can help with their water bill:
This project came from a discussion on Twitter between @tiffani and @KristyT who wanted to find a way to help people in Detroit with their water issues.
We were skeptical of campaigns collecting money on behalf of Detroit residents and wanted to find a way to verify past due bills and have donations paid directly to Detroit Water and Sewerage Department in order to help Detroit citizens reconnect their water.
Water is a human rights issue.
We only share information donors need to get matched to people to help with bills. Here's what we share only with the donor:
Interested in doing a story on this project? Get in touch here.
Have questions, comments, concerns, or want to find out how this project is doing? Get in touch. We'd love to hear from you.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/Proving.20r.5E2.20.3E.3D.200.html ---
I'm trying to prove the statement that
lemma r_sq_pos (r : ℝ) (H: 0 ≤ r): 0 ≤ r^2 := begin exact pow_nonneg H _ end
pow_nonneg seems to be what I need but tactic don't accept.
Could someone possibly help me? Thanks a lot.
@Mii Nguyen What is the exact error that you get? [Edit: sorry, I was talking nonsense before.]
tactic message is
r : ℝ
H : 0 ≤ r
⊢ 0 ≤ r ^ 2
@Mii Nguyen Is there an error message? Do you get red underlined squiggles somewhere? Or are you confused that the tactic state is not saying "no goals"?
If that is the confusion, try adding a comma ,
to the end of your tactic line.
Yes, this is my confusion. It is resolved with ,
. Thank you.
Last updated: Apr 24 2020 at 19:02 UTC


The Model Organism Linked Database
- About
-
MOLD is an effort to publish Model Organism Data as 5 ★ Open Linked Data.
MOLD is drawn from the respective organisms' InterMine instance, and is also linked with other LOD datasets from Bio2RDF and reuses ontologies such as Gene Ontology (GO) and Sequence Ontology (SO).
SPARQL endpoint is available at http://vt.mo-ld.org/sparql and Linked Data Fragments is available at http://ldf.mo-ld.org.
- Social activity
- GitHub
- https://github.com/mo-ld
- Docker
- https://hub.docker.com/u/mold/
- Forum
- https://groups.google.com/forum/#!forum/mo-ld
- MOLD Network
-
- Model Organisms
- Yeast
- Saccharomyces cerevisiae is a species of yeast. It is perhaps the most useful yeast, having been instrumental to winemaking, baking, and brewing since ancient times. It is believed to have been originally isolated from the skin of grapes (one can see the yeast as a component of the thin white film on the skins of some dark-color fruits such as plums; it exists among the waxes of the cuticle). (source: dbpedia )
YeatMine: http://yeastmine.yeastgenome.org
- Zebrafish
- The zebrafish (Danio rerio) is a tropical freshwater fish belonging to the minnow family (Cyprinidae) of the order Cypriniformes. Native to the Himalayan region, it is a popular aquarium fish, frequently sold under the trade name zebra danio. The zebrafish is also an important and widely-used vertebrate model organism in scientific research, and was the first vertebrate to be cloned. (source: dbpedia )
ZebrafishMine: http://www.zebrafishmine.org/
- Fly
- Drosophila melanogaster is a species of fly (the taxonomic order Diptera) in the family Drosophilidae. The species is known generally as the common fruit fly or vinegar fly. Starting with Charles W. Woodworth's proposal of the use of this species as a model organism, D. melanogaster continues to be widely used for biological research in studies of genetics, physiology, microbial pathogenesis, and life history evolution. (source: dbpedia )
FlyMine: http://www.flymine.org/
- Rat
- The brown rat, also referred to as common rat, street rat, sewer rat, Hanover rat, Norway rat, brown Norway rat, Norwegian rat, or wharf rat (Rattus norvegicus) is one of the best known and most common rats. One of the largest muroids, it is a brown or grey rodent with a body up to 25 cm (10 in) long, and a similar tail length; the male weighs on average 350 g (12 oz) and the female 250 g (9 oz). (source: dbpedia )
RatMine: http://www.ratmine.org/
- Mouse
- The house mouse (Mus musculus) is a small mammal of the order Rodentia, characteristically having a pointed snout, small rounded ears, and a long naked or almost hairless tail. It is one of the most numerous species of the genus Mus. Although a wild animal, the house mouse mainly lives in association with humans. The house mouse has been domesticated as the pet or fancy mouse, and as the laboratory mouse, which is one of the most important model organisms in biology and medicine. (source: dbpedia )
MouseMine: http://www.mousemine.org/mousemine/
- Human
- Homo sapiens (Latin: "wise man") is the binomial nomenclature (also known as the scientific name) for the human species. Homo is the human genus, which also includes Neanderthals and many other extinct species of hominid; H. sapiens is the only surviving species of the genus Homo. Modern humans are the subspecies Homo sapiens sapiens, which differentiates them from what has been argued to be their direct ancestor, Homo sapiens idaltu. (source: dbpedia )
HumanMine: http://www.humanmine.org/


{% extends "layout.html" %} {% block page_title %} Apply for European Structural and Investment Funding {% endblock %} {% block content %} {% include "includes/phase_banner_alpha.html" %} Home Call list Application overview Project Business case {% include 'includes/page_errors.html' %} Project (1 of 4) Business case Capital Projects Documents What is the project? What is it going to do? What will it achieve? Summary of the project What specific activities will be undertaken as part of the project? Who are the project's target beneficiaries? Where will the project activity take place? Outline application endorsement stage Briefly explain how you have addressed each of the conditions made at the outline application endorsement stage Condition 1 Condition 2 Save and continue Cancel and return to dashboard {% include "includes/application_info.html" %} {% include "includes/secondary_nav.html" %} {% endblock %}


Structs
The following structs are available globally.
-
An argument which precense specifies a condition. Flags have no values, rather, their precense is an indicator that a change in the programs behavior is requested.
Flags can have both a short (single character) and a long name.
Typically, flags are passed using their long name (
See more--verbose
), their short name (-v
), or as a set of consecutive flags (-abcd
).Declaration
Swift
public struct Flag: ArgumentProtocol
-
An argument which represents a key-value argument.
Options are passed using their long or short name, followed by their associated value, e.g.
--file-path /tmp/file.txt
or-f /tmp/file.txt
A set of consectutive flags can have a trailing option. If arguments include the flag
See more-a
andb
, as well as the option-f
, it’s possible to pass the arguments as-abc /tmp/file.txt
Declaration
Swift
public struct Option: ArgumentProtocol
-
An argument that is a value in itself
See moreDeclaration
Swift
public struct Parameter: ArgumentProtocol
-
Undocumented
See more


If the info argument is provided and is non-empty, it is used to initialize the global variable errorInfo. errorInfo is used to accumulate a stack trace of what was in progress when an error occurred; as nested commands unwind, the Tcl interpreter adds information to errorInfo. If the info argument is present, it is used to initialize errorInfo and the first increment of unwind information will not be added by the Tcl interpreter. In other words, the command containing the error command will not appear in errorInfo; in its place will be info. This feature is most useful in conjunction with the catch command: if a caught error cannot be handled successfully, info can be used to return a stack trace reflecting the original point of occurrence of the error:
catch {...} errMsg set savedInfo $errorInfo ... error $errMsg $savedInfo
If the code argument is present, then its value is stored in the errorCode global variable. This variable is intended to hold a machine-readable description of the error in cases where such information is available; see the tclvars manual page for information on the proper format for the variable. If the code argument is not present, then errorCode is automatically reset to ``NONE'' by the Tcl interpreter as part of processing the error generated by the command.
if {1+2 != 3} { error "something is very wrong with addition" }
Copyright © 1993 The Regents of the University of California. Copyright © 1994-1996 Sun Microsystems, Inc. Copyright © 1995-1997 Roger E. Critchlow Jr.


/** * @class Ext.Configurator * This class manages the config properties for a class. * @private */ (function () { // see end of file (and please don't indent the whole file) var ExtConfig = Ext.Config, configPropMap = ExtConfig.map, ExtObject = Ext.Object; Ext.Configurator = function (cls) { // @define Ext.class.Configurator // @define Ext.Configurator // @require Ext.Config var me = this, prototype = cls.prototype, superCfg = cls.superclass ? cls.superclass.self.$config : null; /** * @property {Ext.Class} cls The class to which this instance is associated. * @private * @readonly */ me.cls = cls; /** * The super class `Configurator` instance or `null` if there is no super class. * * @property {Ext.Configurator} superCfg * @private * @readonly */ me.superCfg = superCfg; if (superCfg) { /** * This object holds an `Ext.Config` value for each config property keyed by name. * This object has as its prototype object the `configs` of its super class. * * This map is maintained as each property is added via the `add` method. * * @property {Object} configs * @private * @readonly */ me.configs = ExtObject.chain(superCfg.configs); /** * This object holds a bool value for each cachedConfig property keyed by name. * * This map is maintained as each property is added via the `add` method. * * @property {Object} cachedConfigs * @private * @readonly */ me.cachedConfigs = ExtObject.chain(superCfg.cachedConfigs); /** * This object holds a `Number` for each config property keyed by name. This object has * as its prototype object the `initMap` of its super class. The value of each property * has the following meaning: * * * `0` - initial value is `null` and requires no processing. * * `1` - initial value must be set on each instance. * * `2` - initial value can be cached on the prototype by the first instance. * * Any `null` values will either never be added to this map or (if added by a base * class and set to `null` by a derived class) will cause the entry to be 0. * * This map is maintained as each property is added via the `add` method. * * @property {Object} initMap * @private * @readonly */ me.initMap = ExtObject.chain(superCfg.initMap); /** * This object holds the default value for each config property keyed by name. This * object has as its prototype object the `values` of its super class. * * This map is maintained as each property is added via the `add` method. * * @property {Object} values * @private * @readonly */ me.values = ExtObject.chain(superCfg.values); me.needsFork = superCfg.needsFork; //<debug> // The reason this feature is debug only is that we would have to create this // map for all classes because deprecations could be added to bases after the // derived class had created its Configurator. me.deprecations = ExtObject.chain(superCfg.deprecations); //</debug> } else { me.configs = {}; me.cachedConfigs = {}; me.initMap = {}; me.values = {}; //<debug> me.deprecations = {}; //</debug> } prototype.config = prototype.defaultConfig = me.values; cls.$config = me; }; Ext.Configurator.prototype = { self: Ext.Configurator, needsFork: false, /** * This array holds the properties that need to be set on new instances. * * This array is populated when the first instance is passed to `configure` (basically * when the first instance is created). The entries in `initMap` are iterated to find * those configs needing per-instance processing. * * @property {Ext.Config[]} initList * @private */ initList: null, /** * This method adds new config properties. This is called for classes when they are * declared, then for any mixins that class may define and finally for any overrides * defined that target the class. * * @param {Object} config The config object containing the new config properties. * @param {Ext.Class} [mixinClass] The mixin class if the configs are from a mixin. * @private */ add: function (config, mixinClass) { var me = this, Cls = me.cls, configs = me.configs, cachedConfigs = me.cachedConfigs, initMap = me.initMap, prototype = Cls.prototype, mixinConfigs = mixinClass && mixinClass.$config.configs, values = me.values, isObject, meta, isCached, merge, cfg, currentValue, name, names, s, value; for (name in config) { value = config[name]; isObject = value && value.constructor === Object; meta = isObject && '$value' in value ? value : null; if (meta) { isCached = !!meta.cached; value = meta.$value; isObject = value && value.constructor === Object; } merge = meta && meta.merge; cfg = configs[name]; if (cfg) { // Only proceed with a mixin if we have a custom merge. if (mixinClass) { merge = cfg.merge; if (!merge) { continue; } // Don't want the mixin meta modifying our own meta = null; } else { merge = merge || cfg.merge; } //<debug> // This means that we've already declared this as a config in a superclass // Let's not allow us to change it here. if (!mixinClass && isCached && !cachedConfigs[name]) { Ext.raise('Redefining config as cached: ' + name + ' in class: ' + Cls.$className); } //</debug> // There is already a value for this config and we are not allowed to // modify it. So, if it is an object and the new value is also an object, // the result is a merge so we have to merge both on to a new object. currentValue = values[name]; if (merge) { value = merge.call(cfg, value, currentValue, Cls, mixinClass); } else if (isObject) { if (currentValue && currentValue.constructor === Object) { // We favor moving the cost of an "extra" copy here because this // is likely to be a rare thing two object values for the same // property. The alternative would be to clone the initial value // to make it safely modifiable even though it is likely to never // need to be modified. value = ExtObject.merge({}, currentValue, value); } // else "currentValue" is a primitive so "value" can just replace it } // else "value" is a primitive and it can just replace currentValue } else { // This is a new property value, so add it to the various maps "as is". // In the majority of cases this value will not be overridden or need to // be forked. if (mixinConfigs) { // Since this is a config from a mixin, we don't want to apply its // meta-ness because it already has. Instead we want to use its cfg // instance: cfg = mixinConfigs[name]; meta = null; } else { cfg = ExtConfig.get(name); } configs[name] = cfg; if (cfg.cached || isCached) { cachedConfigs[name] = true; } // Ensure that the new config has a getter and setter. Because this method // is called during class creation as the "config" (or "cachedConfig") is // being processed, the user's methods will not be on the prototype yet. // // This has the following trade-offs: // // - Custom getters are rare so there is minimal waste generated by them. // // - Custom setters are more common but, by putting the default setter on // the prototype prior to addMembers, when the user methods are added // callParent can be used to call the generated setter. This is almost // certainly desirable as the setter has some very important semantics // that a custom setter would probably want to preserve by just adding // logic before and/or after the callParent. // // - By not adding these to the class body we avoid all the "is function" // tests that get applied to each class member thereby streamlining the // downstream class creation process. // // We still check for getter and/or setter but primarily for reasons of // backwards compatibility and "just in case" someone relied on inherited // getter/setter even though the base did not have the property listed as // a "config" (obscure case certainly). // names = cfg.names; if (!prototype[s = names.get]) { prototype[s] = cfg.getter || cfg.getGetter(); } if (!prototype[s = names.set]) { prototype[s] = (meta && meta.evented) ? (cfg.eventedSetter || cfg.getEventedSetter()) : (cfg.setter || cfg.getSetter()); } } if (meta) { if (cfg.owner !== Cls) { configs[name] = cfg = Ext.Object.chain(cfg); cfg.owner = Cls; } Ext.apply(cfg, meta); delete cfg.$value; } // Fork checks all the default values to see if they are arrays or objects // Do this to save us from doing it on each run if (!me.needsFork && value && (value.constructor === Object || value instanceof Array)) { me.needsFork = true; } // If the value is non-null, we need to initialize it. if (value !== null) { initMap[name] = true; } else { if (prototype.$configPrefixed) { prototype[configs[name].names.internal] = null; } else { prototype[configs[name].name] = null; } if (name in initMap) { // Only set this to false if we already have it in the map, otherwise, just leave it out! initMap[name] = false; } } values[name] = value; } }, //<debug> addDeprecations: function (configs) { var me = this, deprecations = me.deprecations, className = (me.cls.$className || '') + '#', message, newName, oldName; for (oldName in configs) { newName = configs[oldName]; // configs: { // dead: null, // // renamed: 'newName', // // removed: { // message: 'This config was replaced by pixie dust' // } // } if (!newName) { message = 'This config has been removed.'; } else if (!(message = newName.message)) { message = 'This config has been renamed to "' + newName + '"'; } deprecations[oldName] = className + oldName + ': ' + message; } }, //</debug> /** * This method configures the given `instance` using the specified `instanceConfig`. * The given `instance` should have been created by this object's `cls`. * * @param {Object} instance The instance to configure. * @param {Object} instanceConfig The configuration properties to apply to `instance`. * @private */ configure: function (instance, instanceConfig) { var me = this, configs = me.configs, //<debug> deprecations = me.deprecations, //</debug> initMap = me.initMap, initListMap = me.initListMap, initList = me.initList, prototype = me.cls.prototype, values = me.values, remaining = 0, firstInstance = !initList, cachedInitList, cfg, getter, needsInit, i, internalName, ln, names, name, value, isCached, valuesKey, field; values = me.needsFork ? ExtObject.fork(values) : ExtObject.chain(values); // Let apply/update methods know that the initConfig is currently running. instance.isConfiguring = true; if (firstInstance) { // When called to configure the first instance of the class to which we are // bound we take a bit to plan for instance 2+. me.initList = initList = []; me.initListMap = initListMap = {}; instance.isFirstInstance = true; for (name in initMap) { needsInit = initMap[name]; cfg = configs[name]; isCached = cfg.cached; if (needsInit) { names = cfg.names; value = values[name]; if (!prototype[names.set].$isDefault || prototype[names.apply] || prototype[names.update] || typeof value === 'object') { if (isCached) { // This is a cachedConfig, so it needs to be initialized with // the default value and placed on the prototype... but the // instanceConfig may have a different value so the value may // need resetting. We have to defer the call to the setter so // that all of the initGetters are set up first. (cachedInitList || (cachedInitList = [])).push(cfg); } else { // Remember this config so that all instances (including this // one) can invoke the setter to properly initialize it. initList.push(cfg); initListMap[name] = true; } // Point all getters to the initGetters. By doing this here we // avoid creating initGetters for configs that don't need them // and we can easily pick up the cached fn to save the call. instance[names.get] = cfg.initGetter || cfg.getInitGetter(); } else { // Non-object configs w/o custom setter, applier or updater can // be simply stored on the prototype. prototype[cfg.getInternalName(prototype)] = value; } } else if (isCached) { prototype[cfg.getInternalName(prototype)] = undefined; } } } // TODO - we need to combine the cached loop with the instanceConfig loop to // avoid duplication of init getter setups (for correctness if a cached cfg // calls on a non-cached cfg) ln = cachedInitList && cachedInitList.length; if (ln) { // This is only ever done on the first instance we configure. Any config in // cachedInitList has to be set to the default value to allow any side-effects // or transformations to occur. The resulting values can then be elevated to // the prototype and this property need not be initialized on each instance. for (i = 0; i < ln; ++i) { internalName = cachedInitList[i].getInternalName(prototype); // Since these are cached configs the base class will potentially have put // its cached values on the prototype so we need to hide these while we // run the inits for our cached configs. instance[internalName] = null; } for (i = 0; i < ln; ++i) { names = (cfg = cachedInitList[i]).names; getter = names.get; if (instance.hasOwnProperty(getter)) { instance[names.set](values[cfg.name]); delete instance[getter]; } } for (i = 0; i < ln; ++i) { internalName = cachedInitList[i].getInternalName(prototype); prototype[internalName] = instance[internalName]; delete instance[internalName]; } // The cachedConfigs have all been set to the default values including any of // those that may have been triggered by their getter. } // If the instanceConfig has a platformConfig in it, we need to merge the active // rules of that object to make the actual instanceConfig. if (instanceConfig && instanceConfig.platformConfig) { instanceConfig = me.resolvePlatformConfig(instance, instanceConfig); } if (firstInstance) { // Allow the class to do things once the cachedConfig has been processed. // We need to call this method always when the first instance is configured // whether or not it actually has cached configs if (instance.afterCachedConfig && !instance.afterCachedConfig.$nullFn) { instance.afterCachedConfig(instanceConfig); } } // Now that the cachedConfigs have been processed we can apply the instanceConfig // and hide the "configs" on the prototype. This will serve as the source for any // configs that need to initialize from their initial getter call. instance.config = values; // There are 2 possibilities here: // 1) If it's the first time in this function, we may have had cachedConfigs running. // these configs may have called the getters for any of the normal getters, which // means the initial getters have been clobbered on the instance and won't be able // to be called below when we iterate over the initList. As such, we need to // reinitialize them here, even though we've done it up above. // // 2) If this the second time in this function, the cachedConfigs won't be processed, // so we don't need to worry about them clobbering config values. However, since // we've already done all our setup, we won't enter into the block that sets the // initGetter, so we need to do it here anyway. // // Also note, that lazy configs will appear in the initList because we need // to spin up the initGetter. for (i = 0, ln = initList.length; i < ln; ++i) { cfg = initList[i]; instance[cfg.names.get] = cfg.initGetter || cfg.getInitGetter(); } // Give the class a chance to transform the configs. if (instance.transformInstanceConfig) { instanceConfig = instance.transformInstanceConfig(instanceConfig); } // Important: We are looping here twice on purpose. This first loop serves 2 purposes: // // 1) Ensure the values collection is fully populated before we call any setters. Since // a setter may have an updater/applier, it could potentially call another getter() to grab // the value for some other property, so this ensures they are all set on the config object. // // 2) Ensure that the initGetter is set as the getter for any config that doesn't appear in // the initList. We need to ensure that the initGetter is pushed on for everything that we will // be setting during init time. // // The merging in this loop cannot be completed by Ext.merge(), since we do NOT want to merge // non-strict values, they should always just be assigned across without modification. if (instanceConfig) { for (name in instanceConfig) { value = instanceConfig[name]; cfg = configs[name]; //<debug> if (deprecations[name]) { Ext.log.warn(deprecations[name]); if (!cfg) { // If there is a Config for this, perhaps the class is emulating // the old config... If there is not a Config we don't want to // proceed and put the property on the instance. That will likely // hide the bug during development. continue; } } //</debug> if (!cfg) { //<debug> field = instance.self.prototype[name]; if (instance.$configStrict && (typeof field === 'function') && !field.$nullFn) { // In strict mode you cannot override functions Ext.raise('Cannot override method ' + name + ' on ' + instance.$className + ' instance.'); } //</debug> // Not all "configs" use the config system so in this case simply put // the value on the instance: instance[name] = value; } else { // However we still need to create the initial value that needs // to be used. We also need to spin up the initGetter. if (!cfg.lazy) { ++remaining; } if (!initListMap[name]) { instance[cfg.names.get] = cfg.initGetter || cfg.getInitGetter(); } if (cfg.merge) { value = cfg.merge(value, values[name], instance); } else if (value && value.constructor === Object) { valuesKey = values[name]; if (valuesKey && valuesKey.constructor === Object) { value = ExtObject.merge(values[name], value); } else { value = Ext.clone(value); } } } values[name] = value; } } // Give the class a chance to hook in prior to initializing the configs. if (instance.beforeInitConfig && !instance.beforeInitConfig.$nullFn) { if (instance.beforeInitConfig(instanceConfig) === false) { return; } } if (instanceConfig) { for (name in instanceConfig) { if (!remaining) { // For classes that have few proper Config properties, this saves us // from making the full 2 passes over the instanceConfig. break; } // We can ignore deprecated configs here because we warned about them // above. Further, since we only process proper Config's here we would // not be skipping them anyway. cfg = configs[name]; if (cfg && !cfg.lazy) { --remaining; // A proper "config" property so call the setter to set the value. names = cfg.names; getter = names.get; // At this point the initGetter may have already been called and // cleared if the getter was called from the applier or updater of a // previously processed instance config. checking if the instance has // its own getter ensures the setter does not get called twice. if (instance.hasOwnProperty(getter)) { instance[names.set](values[name]); // The generated setter will remove the initGetter from the instance // but the user may have provided their own setter so we have to do // this here as well: delete instance[names.get]; } } } } // Process configs declared on the class that need per-instance initialization. for (i = 0, ln = initList.length; i < ln; ++i) { cfg = initList[i]; names = cfg.names; getter = names.get; if (!cfg.lazy && instance.hasOwnProperty(getter)) { // Since the instance still hasOwn the getter, that means we've set an initGetter // and it hasn't been cleared by calling any setter. Since we've never set the value // because it wasn't passed in the instance, we go and set it here, taking the value // from our definition config and passing it through finally clear off the getter. instance[names.set](values[cfg.name]); delete instance[getter]; } } // Expose the value from the prototype chain (false): delete instance.isConfiguring; }, getCurrentConfig: function (instance) { var defaultConfig = instance.defaultConfig, config = {}, name; for (name in defaultConfig) { config[name] = instance[configPropMap[name].names.get](); } return config; }, /** * Merges the values of a config object onto a base config. * @param {Ext.Base} instance * @param {Object} baseConfig * @param {Object} config * @return {Object} the merged config * @private */ merge: function (instance, baseConfig, config) { // Although this is a "private" method. It is used by Sencha Architect and so // its api should remain stable. var configs = this.configs, name, value, baseValue, cfg; for (name in config) { value = config[name]; cfg = configs[name]; if (cfg) { if (cfg.merge) { value = cfg.merge(value, baseConfig[name], instance); } else if (value && value.constructor === Object) { baseValue = baseConfig[name]; if (baseValue && baseValue.constructor === Object) { value = Ext.Object.merge(baseValue, value); } else { value = Ext.clone(value); } } } baseConfig[name] = value; } return baseConfig; }, /** * @private */ reconfigure: function (instance, instanceConfig, options) { var currentConfig = instance.config, configList = [], strict = instance.$configStrict && !(options && options.strict === false), configs = this.configs, defaults = options && options.defaults, cfg, getter, i, len, name, names, prop; for (name in instanceConfig) { if (defaults && instance.hasOwnProperty(name)) { continue; } currentConfig[name] = instanceConfig[name]; cfg = configs[name]; //<debug> if (this.deprecations[name]) { // See similar logic doc in configure() method. Ext.log.warn(this.deprecations[name]); if (!cfg) { continue; } } //</debug> if (cfg) { // To ensure that configs being set here get processed in the proper order // we must give them init getters just in case they depend upon each other instance[cfg.names.get] = cfg.initGetter || cfg.getInitGetter(); } else { // Check for existence of the property on the prototype before proceeding. // If present on the prototype, and if the property is a function we // do not allow it to be overridden by a property in the config object // in strict mode (unless the function on the prototype is a emptyFn or // identityFn). Note that we always check the prototype, not the instance // because calling setConfig a second time should have the same results - // the first call may have set a function on the instance. prop = instance.self.prototype[name]; if (strict) { if ((typeof prop === 'function') && !prop.$nullFn) { //<debug> Ext.Error.raise("Cannot override method " + name + " on " + instance.$className + " instance."); //</debug> continue; //<debug> } else { if (name !== 'type') { Ext.log.warn('No such config "' + name + '" for class ' + instance.$className); } //</debug> } } } configList.push(name); } for (i = 0, len = configList.length; i < len; i++) { name = configList[i]; cfg = configs[name]; if (cfg) { names = cfg.names; getter = names.get; if (instance.hasOwnProperty(getter)) { // Since the instance still hasOwn the getter, that means we've set an initGetter // and it hasn't been cleared by calling any setter. Since we've never set the value // because it wasn't passed in the instance, we go and set it here, taking the value // from our definition config and passing it through finally clear off the getter. instance[names.set](instanceConfig[name]); delete instance[getter]; } } else { cfg = configPropMap[name] || Ext.Config.get(name); names = cfg.names; if (instance[names.set]) { instance[names.set](instanceConfig[name]); } else { // apply non-config props directly to the instance instance[name] = instanceConfig[name]; } } } }, /** * This method accepts an instance config object containing a `platformConfig` * property and merges the appropriate rules from that sub-object with the root object * to create the final config object that should be used. This is method called by * `{@link #configure}` when it receives an `instanceConfig` containing a * `platformConfig` property. * * @param {Object} instanceConfig The instance config parameter. * @return {Object} The new instance config object with platformConfig results applied. * @private * @since 5.1.0 */ resolvePlatformConfig: function (instance, instanceConfig) { var platformConfig = instanceConfig && instanceConfig.platformConfig, ret = instanceConfig, i, keys, n; if (platformConfig) { keys = Ext.getPlatformConfigKeys(platformConfig); n = keys.length; if (n) { ret = Ext.merge({}, ret); // this deep copies sub-objects for (i = 0, n = keys.length; i < n; ++i) { this.merge(instance, ret, platformConfig[keys[i]]); } } } return ret; } }; // prototype }()); // closure on whole file


The field of geomatics encompasses everything that relates to data about a location. This can vary from data acquisition, data analysis to data visualization. This is usually accompanied with programming. I enjoy geomatics since it has in my opinion an essential role in making society and economy a more sustainable place.
One specific aspect I enjoy in geomatics is data visualization. Using D3.js, one is able to visualize almost everything, including geographic information in an easy and comprehensible way. I think being able to visualize complex data is very important, since it conveys the message to other people, including those not familiar with your work.
 In winter season I like to spend as much time as possible in the mountain snowboarding. In the meantime I play volleybal and recently I have started running. I like how sports keeps me focussed and it can easily distract me from worrying about everyday things.


A Single Girl (Reviewed on Nov. 25/98)
Starring Virginie Ledoyen
"A Single Girl" is filmed in real-time, which means that every minute of the first hour and 15 minutes of this movie is accounted for. I ordinarily like real-time movies. "Nick of Time", the vastly underrated Johnny Depp thriller, was exciting and fun. "A Single Girl", however, is boring and uninteresting.
Ledoyen stars as a woman who has just found out she's pregnant, and is starting work at a hotel that same day. We see her with her boyfriend at a cafe, and at the hotel. Those are the only two locations seen during much of the movie.
The problem I had with it being filmed in real-time is that Ledoyen is the focus of the movie. This means we are treated to many shots of her walking. Walking down a corridor in the hotel. Walking to and from the cafe. Walking while she smokes. I would guess that if you were to fast-forward all the scenes where there is no talking, just walking, you'd be left with a very short movie.
Ledoyen, though, gives a great performance. As with most foreign movies I watch, I didn't know or recognize any of the stars in it. Since the entire movie rests on the shoulders of Ledoyen, the quality of her performance had better be good. And it is. She's very charismatic and yet also aloof at the same time. I liked her as a character, I just wish she had been in a better movie.
I've read a few other reviews comparing "A Single Girl" to some of the French New Wave films of the early 60's. I suppose I can see that, but "A Single Girl" doesn't have the energy found in many of those films. It mostly just trods along, aimlessly wandering to its final destination, which isn't even that interesting.
Skip "A Single Girl" and rent "Breathless" instead.
**1/2 out of ****
-- David Nusair<EMAIL_ADDRESS>Come visit my "Reel Film Reviews" site! "http://chat.carleton.ca/~dnusair"
"The most annoying questions are the hypothetical, like, `what would have happened if you had quit after Siamese Dream?' Well, what would have happened? Probably, we all would have been playing samba somewhere." -Billy Corgan
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Turn an image into a scaled sprite sheet with just one line of code. Accepts images of data:uri, <img>
, and url paths.
new SimpleSprite('/images/vulture.png', 17, 13, { scale: 4, target: 'vulture', frame: 0, sequence: [0, 1, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5], repeat: true, speed: 0.3, flipX: false });


Change Faction: Text Page
This tab page of the Change Faction dialog allows you to edit the name and informational text of a player faction.
- Use the Faction Name (Alt+N) field to enter or change the name that the game will display for this faction.
- Use the large Informational Text (Alt+I) field to enter additional descriptive text for this faction. Text will wrap automatically to fit the display; you should only press Enter when you want to end a paragraph. You can also use blank lines (press Enter twice or more) to separate paragraphs.
- See Change Faction for a description of other controls in this dialog.


Salad product recall over E. coli bacteria impacts 22 states
SWEDESBORO, N.J. - The U.S. Department of Agriculture says thousands of pounds of salad products are being recalled due to a possible E. coli contamination.
The department says Missa Bay, LLC from Swedesboro, New Jersey, is recalling more than 75,000 pounds of salad products that contain meat or poultry because the lettuce may be contaminated with a strain of E. coli.
The products were sold on Oct. 14 through Oct. 16 in Alabama, Connecticut, Florida, Georgia, Illinois, Indiana, Louisiana, Maine, Maryland, Massachusetts, Michigan, Minnesota, Mississippi, Missouri, New Jersey, New York, North Carolina, Ohio, Pennsylvania, South Carolina, Virginia, and Wisconsin.
The products included in the recall are listed on the USDA.gov site.
Authorities say the Maryland Department of Health tested an unopened salad product with chicken and the lettuce came back positive for a strain of E. coli bacteria.
The Centers for Disease Control says E. coli often causes diarrhea and vomiting.


Welcome to our experiment !
Your decision. You will receive 10 coins per round for 20 rounds. Each round, you will have to choose how many coins to put directly into your personal box, and how many coins to put into a black box.
Return from personal box. Each coin that you put into your personal box each round goes one-to-one towards your final earnings in the game.
Return from black box.
The black box function will not change over the 20 rounds, and it may or may not depend on how many coins others put into the black box.
For any positive amount of coins that you put into the black box, you may or may not receive a higher amount back from the black box, but the black box will never pay you less than zero. If you put zero coins in the black box, you may or may not receive a positive amount.
Total return. The money which will be paid out to you according to a final amount of coins earned over the whole experiment is worth real fixed exchange rate of XXX.
Welcome to our experiment! 16 people, that is you and 15 others, have joined us.
Your decision. You will receive 10 coins per round for 20 rounds. Each round, you will have to choose how many coins to put directly into your personal account, and how many coins to put into a group account.
Random group matching. Each round you will be randomly assigned to a new group. Each group consists of 4 people, that is, you and three (possibly different) random others.
Return from personal account. Each coin that you put into your personal account each round goes one-to-one towards your final earnings in the game.
Return from group account. Each coin that you put into the group account will pay you back some positive amount of money as described below.
The total amount of coins in your group account is equal to the sum of the contributions to the group account by each of the group members. That amount is then multiplied by 2 and distributed equally amongst group members. In other words, you will get a return equal to half of the group account total.
| Total number of coins in your group | Your return |
|---|---|
| 0 | 0 |
| 10 | 5 |
| 15 | 7.5 |
| 28 | 14 |
| ... | ... |
| 40 | 20 |
| Any amount | Half of that amount |
Total return. The money which will be paid out to you according to a final amount of coins earned over the whole experiment is worth real fixed exchange rate of XXX.
Welcome to our experiment! 16 people, that is you and 15 others, have joined us.
Your decision. You will receive 10 coins per round for 20 rounds. Each round, you will have to choose how many coins to put directly into your personal account, and how many coins to put into a group account.
Ordered group matching. Each round you will be assigned to a new group of 4 people, that is, you and three (possibly different) others. Which group you are assigned to depends on your and others contributions to the group account in the following way.
All contributions will be ranked from 1 to 16 on a list from highest contribution to lowest contribution. Based on this order, the first 4 people in the list form Group 1, the next 4 people in the list form Group 2, the third 4 people in the list form Group 3, and the last 4 people form Group 4.
In case two or more players contributed equally in the same round, their relative position in the ranking will be decided randomly.
Return from personal account. Each coin that you put into your personal account each round goes one-to-one towards your final earnings in the game.
Return from group account. Each coin that you put into the group account will pay you back some positive amount of money as described below.
The total amount of coins in your group account is equal to the sum of the contributions to the group account by each of the group members. That amount is then multiplied by 2 and distributed equally amongst group members. In other words, you will get a return equal to half of the group account total.
| Total number of coins in your group | Your return |
|---|---|
| 0 | 0 |
| 10 | 5 |
| 15 | 7.5 |
| 28 | 14 |
| ... | ... |
| 40 | 20 |
| Any amount | Half of that amount |
Total return. The final amount of coins earned over the whole experiment is worth real money which will be paid out to you according to a fixed exchange rate of XXX.
Welcome to our experiment ! 16 people, that is you and 15 others, have joined us.
Your decision. You will receive 10 coins per round for 20 rounds. Each round, you will have to choose how many coins to put directly into your personal account, and how many coins to put into a group account.
Group matching with noise. Each round you will be assigned to a new group of 4 people, that is, you and three (possibly different) others. Which group you are assigned to depends on your and others contributions to the group account, and is determined in the following three steps.
Step 1: Preliminary ordering. First, a preliminary list is created on which contributions are ranked from 1 to 16 from highest contribution to lowest contribution. In case two or more players contributed equally in the same round, their relative position in the ranking will be decided randomly.
Step 2: Noisy ordering. From your and every other player's actual contribution, we obtain a unique noisy contribution by adding an i.i.d. (independent and identically distributed) Normal variable with mean zero and variance XXX. The noisy contributions are ranked from 1 to 16 from highest contribution to lowest contribution on the final list.
Step 3: Group matching. Based on the final list, the first 4 people on that list form Group 1, the next 4 people in the list form Group 2, the third 4 people in the list form Group 3, and the last 4 people form Group 4.
Example. Suppose two people are ranked in this noisy way. Suppose person A contributes 8 and person B contributes 6. Then, the preliminary ordering is A (contribution 8) > B (contribution 6). Now, we add to each number an iid Normal variable with mean zero and variance XXX to get the noisy contributions. Suppose the draw of the two numbers gives -1.6 for A and +1.2 for B, then the final ordering is reversed: A (noisy contribution 6.4) < B (input 7.2).
Return from personal account. Each coin that you put into your personal account each round goes one-to-one towards your final earnings in the game.
Return from group account. Each coin that you put into the group account will pay you back some positive amount of money as described below.
The total amount of coins in your group account is equal to the sum of the contributions to the group account by each of the group members. That amount is then multiplied by 2 and distributed equally among group members. In other words, you will get a return equal to half of the group account total.
| Total number of coins in your group | Your return |
|---|---|
| 0 | 0 |
| 10 | 5 |
| 15 | 7.5 |
| 28 | 14 |
| ... | ... |
| 40 | 20 |
| Any amount | Half of that amount |
Total return. The money which will be paid out to you according to a final amount of coins earned over the whole experiment is worth real fixed exchange rate of XXX.
Welcome to our experiment! 16 people, that is you and 15 others, have joined us.
You will receive 10 coins per round for 20 rounds. Each round, you will have to make two independent decisions:
Your decision 1. You have to choose how many coins to put directly into your personal account and how many coins to put into a group account.
Your decision 2. You have to choose your demand level, that is, you have to specify how much you expect others in your group to contribute for you to voluntarily form a group with them.
Group matching. Each round you will be assigned to a new group of 4 people, that is, you and three (possibly different) others. Which group you are assigned to depends on decisions 1 and 2 made by all players.
We will try to form compatible groups first, and we will start creating incompatible groups randomly once no more compatible groups can be formed.
Compatible groups are groups where the contributions of all group members are higher or equal the demand levels of all other group members.
Here are two examples, one of a compatible and one of an incompatible group:
Example 1: This group is incompatible because you demand 10 but others only contribute 1.
| Players | Contributions | Demands |
|---|---|---|
| You | 0 | 10 |
| OtherA | 1 | 0 |
| OtherB | 1 | 0 |
| OtherC | 1 | 0 |
Example 2: This group is compatible because you contribute as much as others demand, and you demand no more than others contribute. The same is true for all other players.
| Players | Contributions | Demands |
|---|---|---|
| You | 8 | 8 |
| OtherA | 9 | 7 |
| OtherB | 8 | 7 |
| OtherC | 10 | 7 |
We will begin the matching process starting from the highest contributions, and form groups going down. Depending on your and others' demands and contributions, this may either lead to:
Return from personal account. Each coin that you put into your personal account each round goes one-to-one towards your final earnings in the game.
Return from group account. Each coin that you put into the group account will pay you back some positive amount of money as described below.
The total amount of coins in your group account is equal to the sum of the contributions to the group account by each of the group members. Such amount is then multiplied by 2 and distributed equally amongst group members. In other words, you get half of the group account.
| Total number of coins in your group | Your return |
|---|---|
| 0 | 0 |
| 10 | 5 |
| 15 | 7.5 |
| 28 | 14 |
| ... | ... |
| 40 | 20 |
| Any amount | Half of that amount |
Total return. The money which will be paid out to you according to a nal amount of coins earned over the whole experiment is worth real fixed exchange rate of XXX.


| bkde {KernSmooth} | R Documentation |
Returns x and y coordinates of the binned kernel density estimate of the probability density of the data.
bkde(x, kernel = "normal", canonical = FALSE, bandwidth, gridsize = 401L, range.x, truncate = TRUE)
x |
numeric vector of observations from the distribution whose density is to be estimated. Missing values are not allowed. |
bandwidth |
the kernel bandwidth smoothing parameter. Larger values of
|
kernel |
character string which determines the smoothing kernel.
|
canonical |
logical flag: if |
gridsize |
the number of equally spaced points at which to estimate the density. |
range.x |
vector containing the minimum and maximum values of |
truncate |
logical flag: if |
This is the binned approximation to the ordinary kernel density estimate.
Linear binning is used to obtain the bin counts.
For each x
value in the sample, the kernel is
centered on that x
and the heights of the kernel at each datapoint are summed.
This sum, after a normalization, is the corresponding y
value in the output.
a list containing the following components:
x |
vector of sorted |
y |
vector of density estimates
at the corresponding |
Density estimation is a smoothing operation. Inevitably there is a trade-off between bias in the estimate and the estimate's variability: large bandwidths will produce smooth estimates that may hide local features of the density; small bandwidths may introduce spurious bumps into the estimate.
Wand, M. P. and Jones, M. C. (1995). Kernel Smoothing. Chapman and Hall, London.
data(geyser, package="MASS") x <- geyser$duration est <- bkde(x, bandwidth=0.25) plot(est, type="l")


Events
Up coming performances at our shop. On Dec 24th my Quintet," the Furballski five" will be doing a midnight show to debut our hit single "Donut make you happy?"other acts will be playing later in the month.
Follow Us
Email Updates
Join our digital mailing list and get news
deals and be first to know about events


Importing EML files into Notes (lots of them)
However on a closer look you might guess where the author of an outstanding movie got his inspiration from. RFC 2045 nicely states:" NOTE: The previous four definitions are clearly circular. This is unavoidable, since the overall structure of a MIME message is indeed recursive." So trying to parse that messages on my own was clearly out of the question. Luckily there is ready code available. On one side there is JavaEE and the the MimeMessage and on the other Apache James. An implementation of the
javax.mail.internet
classes is hidden somewhere in the Notes client, so that would favour MimeMessage. However I found it easier to work with the mime4j classes. Here is what I came up with:
import java.io.IOException ;
import java.io.InputStream ;
import lotus.domino.Document ;
import lotus.domino.NotesException ;
import lotus.domino.Session ;
import org.apache.james.mime4j.MimeException ;
import org.apache.james.mime4j.parser.ContentHandler ;
import org.apache.james.mime4j.parser.MimeStreamParser ;
public class Mime2Doc {
public void importMail (Session s, InputStream in, Document doc ) throws NotesException, MimeException, IOException {
doc. replaceItemValue ( "Form", "Memo" ) ;
MimeStreamParser parser = new MimeStreamParser ( ) ;
ContentHandler h = new DocContentHandler (s, doc ) ;
parser. setContentHandler (h ) ;
parser. parse (in ) ;
}
}
The final piece in the puzzle is the class that helps to track the MIME Parts that are put onto the Stack and returns MIME-Type and encoding derived from the header fields. You are ready to test.I used a directory full of eml files to test:
import java.io.File ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.IOException ;
import org.apache.james.mime4j.MimeException ;
import lotus.domino.Document ;
import lotus.domino.NotesException ;
import lotus.domino.NotesFactory ;
import lotus.domino.NotesThread ;
import lotus.domino.Session ;
import lotus.domino.Database ;
public class Tester {
public static void main ( String [ ] args ) {
// Change these for your own test
final String WORKDIR = "/home/user/testingmime/" ;
final String EXTENSION = ".eml" ;
final String DBNAME = "testmail.nsf" ;
final String SERVER = "" ;
NotesThread. sinitThread ( ) ;
try {
Session s = NotesFactory. createSession ( ) ;
Database db = s. getDatabase (SERVER, DBNAME ) ;
File folder = new File (WORKDIR ) ;
File [ ] tobeImported = folder. listFiles ( ) ;
Mime2Doc md = new Mime2Doc ( ) ;
for ( int i = 0 ; i < tobeImported. length ; i ++ ) {
File f = tobeImported [i ] ;
if (f. isFile ( ) && f. getName ( ). endsWith (EXTENSION ) ) {
System. out. println ( "File: " +f. getName ( ) ) ;
Document doc = db. createDocument ( ) ;
FileInputStream in = new FileInputStream (f ) ;
md. importMail (s,in, doc ) ;
doc. recycle ( ) ;
}
}
System. out. println ( "--- DONE ---" ) ;
// Cleanup
db. recycle ( ) ;
} catch (NotesException e ) {
e. printStackTrace ( ) ;
} catch ( FileNotFoundException e ) {
e. printStackTrace ( ) ;
} catch (MimeException e ) {
e. printStackTrace ( ) ;
} catch ( IOException e ) {
e. printStackTrace ( ) ;
} finally {
NotesThread. stermThread ( ) ;
}
}
}
Posted by Stephan H Wissel on 23 April 2012 | Comments (18) | categories: Show-N-Tell Thursday


Compare Org
Current Org
Select Org
Current Org
Select Object
Download Metadata File
Org Name
Select Object
Download Metadata File


<<<<<<< HEAD
Hero
Simple callout boxes and background colors.
How It Works
Getting started with Hero is really easy. View the online tutorial or dig through the index.html
file.
Alerts
Simple alert messages.
How It Works
Getting started with Alerts is really easy. View the online tutorial or dig through the index.html
file.
master
Changelog
- v1.0 (June 7, 2013)
- Switched to MIT license.
<<<<<<< HEAD
- Version 1.0 (May 18, 2013)
License
Hero is free to use under the MIT License.
License
Alerts is free to use under the MIT License.
master


Prev
Next
Playing: Shakira & Rihanna - Can't remember to forget you
+
-
Snoop Dog
Linkin park
Bon Jovi - You give love a bad name
Metallica


Hi, I'am
Om a Full Stack
Web Developer
Contact
About
Je suis Om
Salut, I'm a third-year B.Tech (CSE) student from SRM University, Chennai. I'm working towards my aim to be a professional developer, I'm good in Web-Development and always try to do new things related to the technical domain. I'm one who always tries to grab opportunities to learn that falls in my way.Highly focused and eager to leverage the in-depth knowledge of high-end technical skills.
Skills
HTML5
95%
CSS3
85%
JAVASCRIPT
65%
Node.js
60%
mongodb
73%
Git & github
80%
Bootstrap
85%


I would like you to answer the following questions in a short answer format using Markdown.
For questions that ask for a list, use the appropriate Markdown syntax to create either ordered or unordered lists.
Use bold and italic text for emphasis in your responses.
GitHub Username: NimBreitenfeld Team name: Team Dogwood Today's date: 06 July 2016
GitHub's version control capability is something that can be used in multiple disciplines (obvious ones being coding and programming, less obvious is something ilke a thesis draft). GitHub by itself is a bit of an awkward tool to use (GUI and the fact that Windows OS are not inheirantly git or bash friendly), which is why Codeanywhere is also particularly useful. Being able to access the same files across OS platform is very important to me since I work on two different OS with my UNC laptop (Windows) and my private laptop (Ubuntu).
This course is not actually the beginning of when I started to learn HTML/HTML5, but out of everything we have encountered so far, it remains to be more difficult than the rest. Initally it was remembering how to write and read HTML, then later it was correctly implementing some parts of it (images in particular have been annoying to set up).
Definitely more with git, GitHub, and Codeanywhere. Learning more about Jekyll and VIM would also be pretty neat (and I probably will start studying it on my own time).
When you are finished with the questions in file:


Sample
Home
Tabs
Header
Post Classic
Post Thumb
Post Thumb Left
Post Single
Sidebar
Testi
Pages
About Us
Profile


{% comment %} National is displayed only when selected locations is less than 2, i.e selectedLocationLevel < 1 Other Locations are displayed if its index is either equals or one less than selectedLocationLevel '>' symbol is shown only before last location {% endcomment %} {$ $ctrl.selectedMonthDisplay $} | National > {$ loc.name $}


FROM THE DESK OF:MR . RAHA. ALI dIRECTOR AUDIT AND ACCOUNTING DEPARTMENT, BANK OF AFRICA, OUAGA-BURKINA-FASO. ATTN: Please. Greetings to you, I am Mr.Raha.Ali. the Account Manager of Late Mr.Morris Thompson in Bank of Africa, here in Burkina Faso.However I got your contact through the International web directory.I decided to contact you by email because I feel that it is more secured and private. Recently i discovered a Dormant Account with a huge amount of Money Valued USD14,000,000.00 (Fourteen Million Dollars only)that belongs to one of our late Customer who died in a plane crash. During our investigation and auditing in this bank, my department came across a very huge sum of money belonging to Late Mr. Morris Thompson an American great industrialist and a resident of Alaska, who unfortunately lost his life in the plane crash of Alaska Airlines Flight 261 which crashed on January 31 2000,including his wife and only daughter. You shall read more news about the crash on visiting this site which I got during my investigation;http://www.cnn.com/2000/US/02/01/alaska.airlines.list/ andttp://www.nativefederation.org/history/people/mThompson.html The fund has been dormant in his account With this Bank without any claim of the funds in our custody either from his family or relation before our discovery of this development. The Banking law here stipulates that if such money remains unclaimed for Six years, it will be forfeited to the Bank treasury as an unclaimed bill.It is only a foreigner that can stand as a next of kin and It is upon this discovery that I decided to contact you to collaborate with you to pull out this dormant fund. In order to avert this negative development, I on behalf of my trusted colleagues now seek your permission to have you stand in as next of kin to Our late Customer so that the fund will be released and paid into your account as the beneficiary´s next of kin now that the bank is still expecting a next of kin or relative of the deceased ,Late Mr. Morris Thompson. In fact we could have done this deal alone but because of our position in this country as civil servants, we are not allowed to operate a foreign account and that would eventually raise an eye brow on our side during the time of transfer since I still work in this bank, this is the actual reason why I required a second party or fellow who will assist me forward claims as the next of kin and also provide either an existing bank account or to set up a new Bank a/c immediately to receive this fund, even an empty a/c can also serve for this purpose. On smooth conclusion of this transaction, you will be entitled to 40% as gratification for your assisting me, and the remaining 60% will be for me. What I want from you is for you to act as the deceased next of kin. I have in my possession, all the necessary informations to successfully accomplish this operation. Bear in mind that this proposal is 100% risk free. Further Information will be given to you as soon as I receive your positive response. I suggest you get back to me as soon as possible stating your interest to enable us proceed. I await your Urgent Response Regrads, MR .RAHA. ALI BANK OF AFRICA (BOA) _________________________________________________________________ MSN Hotmail : créez votre adresse e-mail gratuite & à vie ! http://www.msn.fr/newhotmail/Default.asp?Ath=f


- Rect - Class in tracer.paths
-
A rectangle, analgous to Processing's rect() function.
- Rect(float, float, float, float, int) - Constructor for class tracer.paths.Rect
-
- Rect(Point, float, float, int) - Constructor for class tracer.paths.Rect
-
- Rect(Point, Point, int) - Constructor for class tracer.paths.Rect
-
- Rect(Rect) - Constructor for class tracer.paths.Rect
-
Copy constructor.
- Rect(float, float, float) - Constructor for class tracer.paths.Rect
-
Easy constructor.
- rectModeToString(int) - Static method in class tracer.paths.Rect
-
- remainder(float, float) - Static method in class tracer.paths.Path
-
Computes the remainder of num / denom.
- remainder(float, float) - Static method in class tracer.Tracer
-
Computes the remainder of num / denom.
- remove(Path) - Method in class tracer.paths.MultiPath
-
- remove(Point) - Method in class tracer.renders.Render
-
- removeVertex(int) - Method in class tracer.paths.Gesture
-
Removes the vertex at index i.
- removeVertex(float) - Method in class tracer.paths.Gesture
-
Looks for a vertex at time coordinate t and, if found, removes it.
- removeVertex(int) - Method in class tracer.paths.MultiShape
-
- removeVertex(int) - Method in class tracer.paths.Shape
-
Remove the vertex at index i.
- Render - Class in tracer.renders
-
Draws a list of Point objects in some way using the PGraphics class from
Processing.
- Render() - Constructor for class tracer.renders.Render
-
Constructs an empty Render with no Points.
- Render(Point[]) - Constructor for class tracer.renders.Render
-
Constructs a Render containing the array of Points.
- Render(Tracer[]) - Constructor for class tracer.renders.Render
-
Constructs a Render containing the array of Tracers.
- Render(Collection<? extends Point>) - Constructor for class tracer.renders.Render
-
Constructs a Render containing the list of Points.
- RenderClique - Class in tracer.renders
-
Draws a list of Tracers as a clique (a fully-connected graph), where lines
are drawn between each Tracer and every other Tracer
- RenderClique() - Constructor for class tracer.renders.RenderClique
-
- RenderClique(Collection<? extends Point>) - Constructor for class tracer.renders.RenderClique
-
- RenderClique(Point[]) - Constructor for class tracer.renders.RenderClique
-
- RenderClique(Tracer[]) - Constructor for class tracer.renders.RenderClique
-
- RenderMesh - Class in tracer.renders
-
Draws a list of Point objects as a procedural mesh.
- RenderMesh() - Constructor for class tracer.renders.RenderMesh
-
Initialization *****
- RenderMesh(Collection<? extends Point>) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Collection<? extends Point>, float) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Collection<? extends Point>, float, float) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Point[]) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Point[], float) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Point[], float, float) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Tracer[]) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Tracer[], float) - Constructor for class tracer.renders.RenderMesh
-
- RenderMesh(Tracer[], float, float) - Constructor for class tracer.renders.RenderMesh
-
- RenderShape - Class in tracer.renders
-
Draws a list of Point objects as a shape using Processing's beginShape() and
endShape() method.
- RenderShape() - Constructor for class tracer.renders.RenderShape
-
- RenderShape(Collection<? extends Point>) - Constructor for class tracer.renders.RenderShape
-
- RenderShape(Point[]) - Constructor for class tracer.renders.RenderShape
-
- RenderShape(Tracer[]) - Constructor for class tracer.renders.RenderShape
-
- reverse() - Method in class tracer.paths.Line
-
- reverse() - Method in class tracer.paths.Path
-
Reverses the orientation of the Path.
- reverse() - Method in class tracer.paths.Shape
-
- Rose - Class in tracer.paths
-
A flower-like pattern made from two sinusoidal motions of different
frequencies.
- Rose(Point, float, float, float, float) - Constructor for class tracer.paths.Rose
-
- Rose(Rose) - Constructor for class tracer.paths.Rose
-
Copy constructor.
- Rose(float, float, float, float, float) - Constructor for class tracer.paths.Rose
-
- Rose(Point, float, float, float) - Constructor for class tracer.paths.Rose
-
- Rose(float, float, float) - Constructor for class tracer.paths.Rose
-
Easy constructor.
- Rose(Point, float) - Constructor for class tracer.paths.Rose
-
Easy constructor.
- rotate(float, float, float) - Method in class tracer.Point
-
Rotates this point around (vx,vy).