8.1 Fonts / 8.2 Status line / 8.3 Text colours / 8.4 Screen dimensions / 8.5 Screen model (V1, V2) / 8.6 Screen model (V3) / 8.7 Screen model (V4, V5) / 8.8 Screen model (V6)
Text may be printed in any font of the interpreter's choice, variable- or fixed-pitch: except that when bit 1 of 'Flags 2' in the header is set, font 4 has been selected, or when the text style has been set to Fixed Pitch, then a fixed-pitch font must be used. The fixed pitch-bit is deprecated in Version 5 and later, and interpreter support in Version 6 is optional.
In Version 5, the height and width of the current font (in units (see below)) should be written to bytes $27 and $26 of the header, respectively. In Version 6, these bytes are the other way round (height in $27, width in $26). The width of a font is defined as the width of its '0' character.
An interpreter should ideally provide 4 fonts, with ID numbers as follows:
1: the normal font 2: a picture font 3: a character graphics font 4: a Courier-style font with fixed pitch
(Selecting font ID 0 is legal, and does not change the current font.) Ideally all text styles should be available for each font (for instance, Courier bold should be obtainable) except that font 3 need only be available in Roman and Reverse Video. Each font should provide characters for character codes 32 to 126 (plus character codes for any accented characters with codes greater than 127 which are being implemented as single accented letters on-screen).
***[1.0] A game must not use fonts other than 1 unless allowed to by the interpreter: see the set_font opcode for how to give or refuse permission. (This paragraph is marked ***[1.0] because existing Infocom games determined the availability of font 3 for 'Beyond Zork' in a complicated and unsatisfactory way: see S 16.)
***[1.0] It is legal for a game to change font at any time, including halfway through the printing of a word. (This might be needed to introduce exotic foreign accents in the future.)
The specification of the "picture font" is unknown (conjecturally, it was intended to provide pictures before Version 6 was properly developed). Interpreters should not implement it, and should refuse permission to any game requesting it.
The specification of the character graphics font is given in S 16.
In Version 5 (only), an interpreter which cannot provide the character graphics font should clear bit 3 of 'Flags 2' in the header.
Any new fonts will have numbers higher than 4. Fonts 5-1023 are reserved for future Standards to specify. Local use may be made of higher font numbers.
In Versions 1 to 3, a status line should be printed by the interpreter, as follows. In Version 3, it must set bit 4 of 'Flags 1' in the header if it is unable to produce a status line.
In Versions 1 and 2, all games are "score games". In Version 3, if bit 1 of 'Flags 1' is clear then the game is a "score game"; if it is set, then the game is a "time game".
The short name of the object whose number is in the first global variable should be printed on the left hand side of the line.
Whenever the status line is being printed the first global must contain a valid object number. (It would be useful if interpreters could protect themselves in case the game accidentally violates this requirement.)
If the object's short name exceeds the available room on the status line, the author suggests that an interpreter should break it at the last space and append an ellipsis "...". There is no guaranteed maximum length for location names but an interpreter should expect names of length up to at least 49 characters.
If there is room, the right hand side of the status line should display:
For "score games": the score and number of turns, held in the values of the second and third global variables respectively. The score may be assumed to be in the range -99 to 999 inclusive, and the turn number in the range 0 to 9999.
For "time games": the time, in the form hours:minutes (held in the second and third globals). The time may be given on a 24-hour clock or the number of hours may be reduced modulo 12 (but if so, "AM" or "PM" should be appended). Either way the player should be able to see the difference between 4am and 4pm, for example. The hours global may be assumed to be in the range 0 to 23 and the minutes global in the range 0 to 59.
The status line is updated in exactly two circumstances: when a show_status opcode is executed, and just before the keyboard is read by read. (It is not displayed when the game begins.)
Under Versions 5 and later, text printing has a current foreground and background colour. In Version 6, each window has its own pair. (Note that a Version 6 interpreter going under the Amiga interpreter number must use the same pair of colours for all windows when running Infocom's games. If either is changed, then the interpreter must change the colour of all text on the screen to match. This simulates the Amiga hardware, which used two logical colours for text and switched palette to change their physical colour. This behaviour should not occur when running non-Infocom games, and modern games should never expect it. An interpreter that does not wish to handle this behaviour at all should avoid using the Amiga interpreter number when running Infocom's Version 6 games.)
The following codes are used to refer to colours:
-1 = the colour of the pixel under the cursor (if any) (true -3) [V6 only] 0 = current (true -2) 1 = default (true -1) 2 = black (true $0000, $$0000000000000000) 3 = red (true $001D, $$0000000000011101) 4 = green (true $0340, $$0000001101000000) 5 = yellow (true $03BD, $$0000001110111101) 6 = blue (true $59A0, $$0101100110100000) 7 = magenta (true $7C1F, $$0111110000011111) 8 = cyan (true $77A0, $$0111011110100000) 9 = white (true $7FFF, $$0111111111111111) 10 = light grey (true $5AD6, $$0101101011010110) 11 = medium grey (true $4631, $$0100011000110001) 12 = dark grey (true $2D6B, $$0010110101101011) 13 reserved 14 reserved 15 = transparent (true -4) [V6 only]
Colours 10, 11, 12, 15 and -1 are available only in Version 6.
***[1.1] The equivalences between the colour numbers and true colours are recommended. The interpreter may allow the user to change the mapping, but the given values should be the default. If necessary, the game can check what true colour is being used for a given colour number using window properties 17 and 18.
Interpreters may provide different colours (eg making colour 10 dark grey), but if and only if they can detect they are running an original Infocom story file.
If the interpreter cannot produce colours, it should clear bit 0 of 'Flags 1' in the header. In Version 6 it should write colours 2 and 9 (black and white), either way round, into the default background and foreground colours in bytes $2c and $2d of the header.
If the interpreter can produce colours, it should set bit 0 of 'Flags 1' in the header, and write its default background and foreground colours into bytes $2c and $2d of the header.
If a game wishes to use colours, it should have bit 6 in 'Flags 2' set in its story file. (However, an interpreter should not rule out the use of colours just because this has not been done.)
If a true colour, or an "under the cursor" colour has been requested by the game, then the foreground or background colour shown in window property 11 is implementation defined, with two exceptions:
If the colour selected was one of the standard set (2-15), then that colour is indicated in property 11.
If the colour selected was not one of the standard set (this can happen when using graphics, which may use many more colours), the colour shown in property 11 will be >= 16.
***[1.1] In Version 6 only, colour 15 is defined as transparent. This is only valid as a background colour; an attempt to select it for the foreground should produce a diagnostic. Interpreters not supporting transparency must ignore any attempt to select colour 15.
If the current background colour is transparent, then printed text is superimposed on the current window contents, without filling the background behind the text. erase_window, erase_line and erase_picture become null operations. The intent is to make it possible to superimpose text on non-uniform images. Up until now, only uniform images could be satisfactorily written on by sampling the background colour - that in itself would be problematical if the interpreter used dithering.
Scrolling with the background set to transparent is not permitted, so transparent should only be requested in a non-scrolling window. It is not valid to use Reverse Video style with the background set to transparent. Instructions that prompt for user input, such as read and save, should beavoided when the background is set to transparent, as it will not generally be possible for text entry to take place satisfactorily in the absence of a defined background colour. Printing text multiple times on top itself with the background set to transparent should be avoided, as the interpreter may use anti-aliasing, resulting in the text getting progressively heavier.
***[1.1] Standard 1.1 adds the ability for games to select many more colours with set_true_colour, which uses 15-bit RBG colour values, with the following special values:
(-1) = default setting (-2) = current setting (-3) = colour under cursor (V6 only) (-4) = transparent (V6 only)
***[1.1] The interpreter selects the closest approximations available to the requested colours. In V6, the interpreter may store the approximations in window properties 16 and 17, so the program can tell how close it got (although it is acceptable for the interpreter to just store the requested value).
In the minimal implementation, interpreters just need to match to the closest of the standard colours and internally call set_colour (although that would have to ensure window properties 16 and 17 were updated). In a full implementation this would be turned around and set_colour would internally call set_true_colour.
True colour specifications are in the sRGB colour space, $0000 being black and $7FFF being white. Colours should be gamma adjusted if necessary. See the PNG specification for a good introduction to colour spaces and gamma correction.
The screen should ideally be at least 60 characters wide by 14 lines deep. (Old Apple II interpreters had a 40 character width and some modern laptop ones have a 9 line height, but implementors should seek to avoid these extremes if possible.) The interpreter may change the exact dimensions whenever it likes but must write the current height (in lines) and width (in characters) into bytes $20 and $21 in the header.
The interpreter should use the screen height for calculating when to pause and print "[MORE]". A screen height of 255 lines means "infinite height", in which case the interpreter should never stop printing for a "[MORE]" prompt. (In case, say, the screen is actually a teletype printer, or has very good "scrollback".)
Screen dimensions are measured in notional "units". In Versions 1 to 4, one unit is simply the height or width of one character. In Version 5 and later, the interpreter is free to implement units as anything from character sizes down to individual pixels.
In Version 5 and later, the screen's width and height in units should be written to the words at $22 and $24.
The screen model for Versions 1 and 2 is as follows:
The screen can only be printed to (like a teletype) and there is no control of the cursor.
At the start of a game, the screen should be cleared and the text cursor placed at the bottom left (so that text scrolls upwards as the game gets under way).
The screen model for Version 3 is as follows:
The screen is divided into a lower and an upper window and at any given time one of these is selected. (Initially it is the lower window.) The game uses the set_window opcode to select one of the two. Each window has its own cursor position at which text is printed. Operations in the upper window do not move the cursor of the lower. Whenever the upper window is selected, its cursor position is reset to the top left. Selecting, or re-sizing, the upper window does not change the screen's appearance.
The upper window has variable height (of n lines) and the same width as the screen. This should be displayed on the n lines of the screen below the top one (which continues to hold the status line). Initially the upper window has height 0. When the lower window is selected, the game can split off an upper window of any chosen size by using the split_window opcode.
Printing onto the upper window overlays whatever text is already there.
When a screen split takes place in Version 3, the upper window is cleared.
An interpreter need not provide the upper window at all. If it is going to do so, it should set bit 5 of 'Flags 1' in the header to signal this to the game. It is only legal for a game to use set_window or split_window if this bit has been set.
Following a "restore" of the game, the interpreter should automatically collapse the upper window to size 0.
When text reaches the bottom right of the lower window, it should be scrolled upwards. The upper window should never be scrolled: it is legal for a character to be printed on the bottom right position of the upper window (but the position of the cursor after this operation is undefined: the author suggests that it stay put).
At the start of a game, the screen should be cleared and the text cursor placed at the bottom left (so that text scrolls upwards as the game gets under way).
The screen model for Versions 4 and later, except Version 6, is as follows:
Text can be printed in five different styles (modelled on the VT100 design of terminal). These are: Roman (the default), Bold, Italic, Reverse Video (usually printed with foreground and background colours reversed) and Fixed Pitch. The specification does not require the interpreter to be able to display more than one of these at once (e.g. to combine italic and bold), and most interpreters can't. If the interpreter is going to allow certain combinations, then note that changing back to Roman should turn off all the text styles currently active.
An interpreter need not provide Bold or Italic (even for font 1) and is free to interpret them broadly. (For example, rendering bold-face by changing the colour, or rendering italic with underlining.)
It is legal to change text style at any point, including in the middle of a word being printed.
***[1.1] Although a story file can determine which individual styles are available by inspecting the header, this gives no indication of which styles can be combined. To improve this situation, at least for Version 6, Standard 1.1 requires window property 10 to show the actual style combination currently in use; with this a story file can probe for the availability of particular combinations.
There are two "windows", called "upper" and "lower": at any given time one of these two is selected. (Initially it is the lower window.) The game uses the set_window opcode to select one of the two. Each window has its own cursor position at which text is printed. Operations in the upper window do not move the cursor of the lower. Whenever the upper window is selected, its cursor position is reset to the top left.
The upper window has variable height (of n lines) and the same width as the screen. (It is usual for interpreters to print the upper window on the top n lines of the screen, overlaying any text which is already there, having been printed in the lower window some time ago.) Initially the upper window has height 0. When the lower window is selected, the game can split off an upper window of any chosen size by using the split_window opcode.
It is unclear exactly what split_window should do if the upper window is currently selected. The author suggests that it should work as usual, leaving the cursor where it is if the cursor is still inside the new upper window, and otherwise moving the cursor back to the top left. (This is analogous to the Version 6 practice.)
In Version 4, the lower window's cursor is always on the bottom screen line. In Version 5 it can be at any line which is not underneath the upper window. If a split takes place which would cause the upper window to swallow the lower window's cursor position, the interpreter should move the lower window's cursor down to the line just below the upper window's new size.
When the upper window is selected, its cursor position can be moved with set_cursor. This position is given in characters in the form (row, column), with (1,1) at the top left. The opcode has no effect when the lower window is selected. It is illegal to move the cursor outside the current size of the upper window.
An interpreter should use a fixed-pitch font when printing on the upper window.
In Versions 3 to 5, text buffering is never active in the upper window (even if a game begins printing there without having turned it off).
Clearing regions of the screen:
When text reaches the bottom right of the lower window, it should be scrolled upwards. (When the text style is Reverse Video the new blank line should not have reversed colours.) The upper window should never be scrolled: it is legal for a character to be printed on the bottom right position of the upper window (but the position of the cursor after this operation is undefined: the author suggests that it stay put).
Using the opcode erase_window, the specified window can be cleared to background colour. (Even if the text style is Reverse Video the new blank space should not have reversed colours.)
In Versions 5 and later, the cursor for the window being erased should be moved to the top left. In Version 4, the lower window's cursor moves to its bottom left, while the upper window's cursor moves to top left.
Erasing window -1 clears the whole screen to the background colour of the lower screen, collapses the upper window to height 0, moves the cursor of the lower screen to bottom left (in Version 4) or top left (in Versions 5 and later) and selects the lower screen. The same operation should happen at the start of a game.
Using erase_line in the upper window should erase the current line from the cursor position to the right-hand edge, clearing it to background colour. (Even if the text style is Reverse Video the new blank space should not have reversed colours.)
The screen model for Version 6 is as follows:
The display is an array of pixels. Coordinates are usually given (in units) in the form (y,x), with (1,1) in the top left.
If the interpreter thinks the screen should be redrawn (e.g. because a menu window has been clicked over it), it may set bit 2 of 'Flags 2'. The game is expected to notice, take action and clear the bit. (However, a more efficient interpreter would handle redraws itself.)
There are eight "windows", numbered 0 to 7. The code -3 is used as a window number to mean "the currently selected window". This selection can be changed with the set_window opcode. Windows are invisible and usually lie on top of each other. All text and graphics plotting is always clipped to the current window, and anything showing through is plotted onto the screen. Subsequent movements of the window do not move what was printed and there is no sense in which characters or graphics 'belong' to any particular window once printed. Each window has a position (in units), a size (in units), a cursor position within it (in units, relative to its own origin), a number of flags called "attributes" and a number of variables called "properties".
There are four attributes, numbered as follows:
0: wrapping 1: scrolling 2: text copied to output stream 2 (the transcript, if selected) 3: buffered printing
Each can be turned on or off, using the window_style opcode.
"Wrapping" is the continuation of printed text from one line to the next. Text running up to the right margin will continue from the left margin of the following line. If "wrapping" is off then characters will be printed until no more can be fitted in without hitting the right margin, at which point the cursor will move to the right margin and stay there, so that any further text will be ignored.
"Buffered printing" means that text to be printed in the window is temporarily stored in a buffer and only flushed onto the screen at intervals convenient for the interpreter.
"Buffered printing" has two practical effects: firstly it causes a delay before printed text actually appears.
Secondly it affects the way "wrapping" is done. If "buffered printing" is on, then text is wrapped after the last word which could fit on a line. If not, then text is wrapped after the last character that could fit.
Example: suppose the text "Here is an abacus" is printed in a narrow window. The appearance (after the buffer has been flushed, if there is buffered printing) might be:
|...margins....| wrapping on buffering on Here is an abacus^ off buffering on Here is an aba^ wrapping on buffering off Here is an aba cus^ off buffering off Here is an aba^
where the caret denotes the final position of the cursor. (Games often alter "wrapping": it would normally be on for a window holding running text but off for a status-line window, which is why window 0 has "wrapping" on by default but all other windows have "wrapping" off by default. On the other hand all windows have "buffered printing" on by default and games only alter this in rare circumstances to avoid delays in the appearance of individual printed characters.)
There are 16 properties, numbered as follows:
0 y coordinate 6 left margin size 12 font number 1 x coordinate 7 right margin size 13 font size 2 y size 8 newline interrupt routine 14 attributes 3 x size 9 interrupt countdown 15 line count 4 y cursor 10 text style 16 true foreground colour 5 x cursor 11 colour data 17 true background colour
Each property is a standard Z-machine number and is readable with get_wind_prop. Properties 0 through 15 are writeable with put_wind_prop. However, a game should only use put_wind_prop to set the newline interrupt routine, the interrupt countdown and the line count: everything else is either set by the interpreter or by specialised opcodes (such as set_font). The true foreground and true background properties must not be written by put_wind_prop.
If a window has character wrapping, then text is clipped to stay inside the left and right margins. After a new-line, the cursor moves to the left margin on the next line. Margins can be set with set_margins but this should only be done just after a newline or just after the window has been selected. (These values are margin sizes in pixels, and are by default 0.)
If the interrupt countdown is set to a non-zero value (which by default it is not), then the line count is decremented on each new-line, and when it hits zero the routine whose packed address is stored in the "newline interrupt routine" property is called before text printing resumes. (This routine may, for example, meddle with margins to roll text around a crinkly-shaped picture.) The interrupt routine should not attempt to print anything.
Because of an Infocom bug, if the interpreter number is 6 (for MSDOS) and the story file is 'Zork Zero' release 393.890714, but in no other case, the interpreter must do the following instead: (1) move to the new line, (2) put the cursor at the current left margin, (3) call the interrupt routine (if it's time to do so). This is the least bad way to get around a basic inconsistency in existing Infocom story files and interpreters.
Note that the set_margins opcode, which is often used by newline interrupt routines (to adjust the shape of a margin as it flows past a picture), automatically moves the cursor if the change in margins would leave the cursor outside them. The effect will depend, unfortunately, on which sequence of events above takes place.
A line count is never decremented below -999.
The text style is set just as in Version 4, using set_text_style (which sets that for the current window). The property holds the operand of that instruction (e.g. 4 for italic).
The foreground colour is stored in the lower byte of the colour data property, the background colour in the upper byte.
The font height (in pixels) is stored in the upper byte of the font size property, the font width (in pixels) in the lower byte.
The interpreter should use the line count to see when it should print "[MORE]". A line count of -999 means "never print [MORE]". (Version 6 games often set line counts to manipulate when "[MORE]" is printed.)
If an attempt is made by the game to read the cursor position at a time when text is held unprinted in a buffer, then this text should be flushed first, to ensure that the cursor position is accurate before being read.
***[1.1] The true foreground and background colours show the actual colour being used for the foreground and background, whether it was set using set_colour or set_true_colour. Transparent is indicated as -4. If the colour was sampled from a picture then the value shown may be a 15-bit rounding of a more precise colour, leading to a slight inaccuracy if the colour is read and then written back.
All eight windows begin at (1,1). Window 0 occupies the whole screen and is initially selected. Window 1 is as wide as the screen but has zero height. Windows 2 to 7 have zero width and height. Window 0 initially has attribute 1 off and 2, 3 and 4 on (scrolling, copy to printer transcript, buffering). Windows 1 to 7 initially have attribute 4 (buffering) on, and the other attributes off.
A window can be moved with move_window and resized with window_size. If the window size is reduced so that its cursor lies outside it, the cursor should be reset to the left margin on the top line.
Each window remembers its own cursor position (relative to its own coordinates, so that the position (1,1) is at its top left). These can be changed using set_cursor (and it is legal to move the cursor for an unselected window). It is illegal to move the cursor outside the current window.
Each window can be scrolled vertically (up or down) any number of pixels, using the scroll_window opcode.
To some extent windows 0 and 1 mimic the behaviour of the lower and upper windows in the Version 4 screen model:
The split_screen opcode tiles windows 0 and 1 together to fill the screen, so that window 1 has the given height and is placed at the top left, while window 0 is placed just below it (with its height suitably shortened, possibly making it disappear altogether if window 1 occupies the whole screen).
An "unsplit" (that is, a split_screen 0) takes place when the entire screen is cleared with erase_window -1, if a "split" has previously occurred (meaning that windows 0 and 1 have been set up as above).
Screen clearing operations:
Erasing a picture is like drawing it (see below), except that the space where it would appear is painted over with background colour instead.
The current line can be erased using erase_line, either all the way to the right margin or by any positive number of pixels in that direction. The space is painted over with background colour (even if the current text style is Reverse Video).
Each window can be erased using erase_window, erasing to background colour (even if the current text style is Reverse Video).
Erasing window number -1 erases the entire screen to the background colour of window 0, unsplits windows 0 and 1 (see S <IP_ADDRESS> above) and selects window 0.
Erasing window -2 erases the entire screen to the current background colour. (It doesn't perform erase_window for all the individual windows, and it doesn't change any window attributes or cursor positions.)
Pictures may accompany the game. They are not stored in the story file (or the Z-machine) itself, and the interpreter is simply expected to know where to find them.
Pictures are numbered from 1 upwards (not necessarily contiguously). They can be "drawn" or "erased" (using draw_picture and erase_picture). Before attempting to do so, a game may ask the interpreter about the picture (using picture_data): this allows the interpreter to signal that the picture in question is unavailable, or to specify its height and width.
The game may, if it wishes, use the picture_table opcode to give the interpreter advance warning that a group of pictures will soon be needed (for instance, a collection of icons making up a control panel). The interpreter may want to load these pictures off disc and into a memory cache.
***[1.1] Interpreters may use a backing store to store the Z-machine screen state, rather than plotting directly to the screen. This would normally be the case in a windowed operating system environment. If a backing store is in use, display changes executed by the Z-machine may not be immediately made visible to the user. Standard 1.1 adds the new opcode buffer_screen to Version 6 to control screen updates. An interpreter is free to ignore the opcode if it doesn't fit its display model (in which case it must act as if buffer_screen is always set to 0).
***[1.1] When buffer_screen is set to 0 (the default), all display changes are expected to become visible to the user either immediately, or within a short period of time, at the interpreter's discretion. At a minimum, all updates become visible before waiting for input. Any intermediate display states between input requests may not be seen; for example when printing a large amount of new text into a scrolling window, all the intermediate scroll positions may or may not be shown.
When buffer_screen is set to 1, the interpreter need not change the visible display at all. Any display changes can be done purely in the backing store. A program may set buffer_screen to 1 before carrying out a complex layered graphical composition, to indicate that the intermediate states are not worth showing. It would be extremely ill-advised to prompt for input with buffer_screen set to 1.
When buffer_screen is set back to 0, the display is not necessarily updated immediately. If this is required, the game must request it seperately (see S <IP_ADDRESS> below).
***[1.1] With buffer_screen in either state, an update of the visible display can be forced immediately by issuing buffer_screen -1, without altering the current buffering state. Note that buffer_screen -1 does not flush the text buffer.
See S 16 for comment on how 'Beyond Zork' uses fonts.
Some interpreters print the status line when they begin running a Version 3 game, but this is incorrect. (It means that a small game printing text and then quitting cannot be run unless it includes an object.) The author's preferred status line formats are:
Hall of Mists 80/733 Lincoln Memorial 12:03 PM
Thus the score/turns block always fits in 3+1+4=8 characters and the time in 2+1+2+1+2=8 characters. (Games needing more exotic time lines, for example, should not be written in Version 3.)
The only existing Version 3 game to use an upper window is 'Seastalker' (for its sonarscope display).
Some ports of ITF apply buffering (i.e. word-wrapping) and scrolling to the upper window, with unfortunate consequences. This is why the standard Inform status line is one character short of the width of the screen.
The original Infocom files seldom use erase_window, except with window -1 (for instance 'Trinity' only uses it in this form). ITF does not implement it in any other case.
The Version 5 re-releases of older games make use of consecutive set_text_style instructions to attempt to combine boldface reverse video (in the hints system).
None of Infocom's Version 4 or 5 files use erase_line at all, and ITF implements it badly (with unpredictable behaviour in Reverse Video text style). (It's interesting to note that the Version 5 edition of 'Zork I' - one of the earliest Version 5 files -- blanks out lines by looking up the screen width and printing that many spaces.)
It's recommended that a Version 5 interpreter always use units to correspond to characters: that is, characters occupy $1\times 1$ units. 'Beyond Zork' was written in the expectation that it could be using either 1x1 or 8x8, and contains correct code to calculate screen positions whatever units are used. (Infocom's Version 5 interpreter for MSDOS could either run in a text mode, 1x1, or a graphics mode, 8x8.) However, the German translation of 'Zork I' contains incorrect code to calculate screen positions unless 1x1 units are used.
Note that a minor bug in Zip writes bytes $22 to $25 in the header as four values, giving the screen dimensions in the form left, right, top, bottom: provided units are characters (i.e. provided the font width and height are both 1) then since "left" and "top" are both 0, this bug has no effect.
Some details of the known IBM graphics files are given in Paul David Doherty's "Infocom Fact Sheet". See also Mark Howell's program "pix2gif", which extracts pictures to GIF files. (This is one of his "Ztools" programs.)
Although Version 6 graphics files are not specified here, and were released in several different formats by Infocom for different computers, a consensus seems to have emerged that the MCGA pictures are the ones to adopt (files with filenames *.MG1). These are visually identical to Amiga pictures (whose format has been deciphered by Mark Knibbs). However, some Version 6 story files were tailored to the interpreters they would run on, and use the pictures differently according to what they expect the pictures to be. (For instance, an Amiga-intended story file will use one big Amiga-format picture where an MSDOS-intended story file will use several smaller MCGA ones.)
The easiest option is to interpret only DOS-intended Version 6 story files and only MCGA pictures. But it may be helpful to examine the Frotz source code, as Frotz implements draw_picture and picture_data so that Amiga and Macintosh forms of Version 6 story files can also be used.
It is generally felt that newly-written graphical games should not imitate the old Infocom graphics formats, which are very awkward to construct and have been overtaken by technology. Instead, the Blorb proposal for packaging up resources with Z-machine games calls for PNG format graphics glued together in a fairly simple way. The graphics for Infocom's Version 6 games have been made available in Blorb format, so that understanding Infocom's picture-sets is no longer very useful.
The line count of -999 preventing "[MORE]" is a device used by the demonstration mode of 'Zork Zero'.
Interpreter authors are advised that all 8 windows in Version 6 must be treated identically. The only ways in which they are distinguished are:
Differences in interpreter behaviour must only arise from differences in window attributes and properties.
In V6, it is legal to position the cursor up against the right or bottom of a window - eg at (1,1) in a zero-sized window or at (641,401) in 640x400 window. Indeed, this is the default state of windows 1 to 7, and the cursor may be left at the right-hand side of a window when wrapping is off.
Attempting to print text (including new-lines) when the cursor is fewer than font_height units from the bottom of the window results in undefined behaviour - this precludes any printing in windows less than font_height units high.
It is legal for interpreters to always show the same value in property 11 if a true or sampled colour is in use. As a result, story files cannot assume that setting a value that was read from property 11 will give the same colour, if set_colour -1 has been used in that window.
The same rules apply if an interpreter offers non-standard default colours although in this case it would be ill-advised to show the same colour numbers for foreground and background - unless they can be distinguished, non-standard default colours should probably not be offered.
If the interpreter offers a limited palette, then there is no problem, as it can be arranged for there to be fewer than 240 distinct non-standard colours. In an interpreter with a higher colour-depth, a good implementation would be to use colours 16-255 to represent the last 240 distinct non-standard colours used, re-using numbers after 240 colours have been used. This will minimize potential problems caused by non-standard colours, particularly when set as defaults.
Regardless of the limitations on colour numbers, in Version 6 each window must remember accurately the colour pair selected, so it is preserved across window switches.
S <IP_ADDRESS> states that it is illegal to move the cursor outside the current size of the upper window. S <IP_ADDRESS> gives the equivalent rule for Version 6.
Many modern games have been lax in obeying this rule; in particular some of the standard Inform menu libraries have violated it. Infocom's Sherlock also miscalculated the size of the upper window to use for box quotes.
It is recommended that if the cursor is moved below the split position in V4/V5, interpreters should execute an implicit "split_window" to contain the requested cursor position, if possible. Diagnostics should be produced, but should be suppressable.
Some modern Z-Machine interpeters (mainly those using Andrew Plotkin's Glk interface standard) use a seperate text windows for the status line. While this is not Standard behaviour, it largely causes no problems. However Trinity, and many more recent Inform games, print quote boxes using a technique that is not compatible with this implementation.
Andrew Plotkin has written up some notes on the issue, including a workaround.
Infocom's Version 6 interpreters and story files disagree on the meaning of window attributes 0 and 3 and the opcode buffer_mode, in such a way that the original specification is hard to deduce from the final behaviour.  The Amiga behaviour may be due to a bug and two bugs have also been found in the MSDOS implementation.  with a row of full stops trickling out during a slow operation. Buffering would frustrate this, but fortunately on modern computers the operation is no longer slow and so the bug does not cause trouble.
Section 1 / 2 / 3 / 4 / 5 / 6 / 7 / 8 / 9 / 10 / 11 / 12 / 13 / 14 / 15 / 16
Appendix A / B / C / D / E / F


Msdos/Unix-style wildcards
Regex::Matches ( $file, $pattern, $case_sensitive = false )
Checks if a filename corresponds to a wildcard mask.
The authorized wildcards are the following :
- "?" : represents zero or one character, excepted the path delimiter.
- "*" : represents zero or more characters, excepted the path delimiter.
-
A character class : represents a range of characters. For example, "[A-Z]" means "all uppercase letters",
while "[^a-z]" means "anything but lowercase letters". For the moment, only alphanumeric character classes
are authorized.
Returns
true if
$pattern matches
$file,
false otherwise.
WildcardToRegex ( $pattern, $escaped_chars = "" )
Converts an msdos/unix-style wildcard to a regular expression.
Regular expressions
MetaPregMatchEx ( $sequence, $regex_list, $subject_array, &$matches = null, $flags = 0, $match_all = false, $missing_matches = [] )
A meta-matching artefact for regular expressions.
Suppose you have to scan a sequence of lines, such as in a log file. You want to recognize which sequence corresponds to which pattern.
A sequence in an example log file could be, for example :
- A line containing "message start"
- Any number of lines starting with "log:" and followed by any sequence of characters
- A line containing "message end"
The following listing gives an example layout of such a log file :
message start
log: message 1
log: message 2
...
log: message n
message end
The purpose is to check whether a sequence of lines would match this scheme ; a set of regular expressions
would be first needeed to match every particular line in a sequence :
$regex_list =
[
'1' => '/message start/',
'2' => 'log: \s* (?P .*),
'3' => '/message end/'
] ;
Then, to match a set of lines containing
'message start'
, having an unlimited number of lines starting with
'log:'
,
then ending with a line containing
'message end'
, you would have to provide a regular expression using a
backreference-style syntax referencing the keys of our $regex_list array, which would give :
$sequence = '\1 \2* \3' ;
meaning :
- The first line must be the one identified by
'\1'
, ie 'message start'
- There can be any number of lines identified by
'\2'
, ie starting with 'log:'
- The last line must be
'message end'
Note that each
$regex_list item is a regular expression which can contain group captures, either named or not.
If it does not contain re delimiters, then
'/ /imsx'
is assumed, so do not forget that spaces will not be significant.
Thus, checking if a set of lines (in an array) matches the regular expressions specified in
$sequence and defined in
$regex_list, a simple call will be enough :
$status = Regex::MetaPregMatchEx ( $sequence, $regex_list, $lines ) ;
In this method, the
$sequence parameter is a regular expression containing preg backreference-style constructs that
refer to array keys in the
$regex_list array.
The following preg-style backreferences are supported ('x' stands for a sequence of digits, 'name' for a group capture name) :
- \x
- \gx
- \g{x}
- (?P=name)
- \k<name>
- \k'name'
- \k{name}
- \g{name}
The
$regex_list parameter is an associative array whose keys are backreference ids
(either the 'x' or the 'name' string described in the
$sequence parameter help) and whose values are regular expressions.
Each entry is meant to match one or more lines of a sequence of lines.
If no delimiter encloses the regex, then a default delimiter '/' will be used, and the 'imsx' -preg options will be
automatically added before performing the match.
The
$subject_array parameter is an array of input lines to be matched against the specified sequence.
The
$matches parameter is a reference to an array which will receive the individual matches.
Each entry is an associative array having the following keys :
'reference'
: the original string reference.
'regex'
: the regex that matched the line.
'matches'
: array of matches. Note that since the method uses PregMatchEx(),
an additional level of indirection is added with regards to self::PregMatch, since several captures
can have the same name.
$flags is a combination of PREG_* constants.
$missing_matches, if specified, will receive the indexes of the non-matching lines.
The function will return
true if the specified lines match the sequence, and
false otherwise.
Regex::PregMatch ( $pattern, $subject, &$matches = null, $flags = 0, $offset = 0 )
Encapsulates the
preg_match()
function and optionnally wipes unnamed captures from the returned
$matches array if
the custom
PREG_WIPE_MATCHES
flag is specified.
Regex::PregMatch ( $pattern, $subject, &$matches = null, $flags = 0, $offset = 0 )
Encapsulates the
preg_match_all()
function and optionnally wipes unnamed captures from the returned
$matches array if the custom
PREG_WIPE_MATCHES
flag is specified.
Regex::PregReplace ( $pattern, $replacement, $subject, $limit = -1, $count = null )
Encapsulates the
preg_replace()
function.
Regex::PregMatchEx ( $pattern, $subject, &$matches = null, $flags = 0, $offset = 0 )
An extended version of
Regex::PregMatch()
that allows for specifying multiple named captures of the same name.
The
$matches array will hold the captured groups. Since named captures of the same name can be specified more than once,
each array item will contain an additional level of indirection : an array for each matched item.
Thus, the elements of a capture group named
<pattern>
will be accessible through the following expressions :
$matches [ 'pattern' ] [0]
will yield to the first expression matched by the named capture "pattern"
count ( $matches [ 'pattern' ] )
will give the number of expressions matched by the named capture "pattern"
Regex::PregMatchAllEx ( $pattern, $subject, &$matches = null, $flags = 0, $offset = 0 )
An extended version of
Regex::PregMatchAll()
that allows for specifying multiple named captures of the same name.
Empty subarrays or subarrays having an offset of -1 will be removed from the resulting matches.
Regex::PregStrReplace ( $pattern, $replacement, $subject, $limit = -1, $count = null ) ;
This function behaves like a mix of str_replace() and preg_replace() ; it allows to search for strings
using regular expressions, but the replacements are plain-text strings and no reference to a capture
specified in the regular expression will be interpreted.
This is useful when processing replacement strings that contain constructs such as "\00" or "$", which
are interpreted by preg_replace() as references to captures.
This function has the same parameters as preg_replace().
Expression development
Regex::DevelopExpression ( $expression, $limit = 10000 )
Expands a factorized string expression.
Sometimes, it is necessary to represent a set of values with a factorized expression,
such as the shell allows us to match a set of files using a pattern.
This method processes input strings that contains character classes and generates an array of values that represent all the
possible combinations. For example :
"file[a-c].txt"
will expand to the following array of strings :
[ "filea.txt", "fileb.txt", filec.txt" ]
Currently, character classes can only be alphabetic or alphanumeric, such as is the following example :
"file[a-b][0-1]"
which will expand to :
[ "filea0", "filea1", "fileb0", "fileb1" ]
Numeric values can be zero-padded, using an optional integer width preceded by a slash, like in the following example :
"file[0-1]/4"
which will expand to :
[ "file0000", "file0001" ]
For alphabetic character classes, the case of the first character determines the case of the expanded result ; for example :
"file[A-c]"
will give :
[ "fileA", "fileB", "fileC" ]
Finally, angle brackets can be escaped using the backslash character.
The
$limit parameter is set to an arbitrary value of 10000 to limit the number of results returned.
Various methods
Regex::CombinationsOf ( $array, $limit )
Takes an array containing values and nested arrays, and generates all the possible combinations, each nested array providing
alternatives for the generation.
For example, the following input array :
[ [ 'a', 'b' ], 1, 2, [ 'x', 'y', 'z' ] ]
will generate the following results ;
[
[0] => [ 'a', 1, 2, 'x' ]
[1] => [ 'b', 1, 2, 'x' ]
[2] => [ 'a', 1, 2, 'y' ]
[3] => [ 'b', 1, 2, 'y' ]
[4] => [ 'a', 1, 2, 'z' ]
[5] => [ 'b', 1, 2, 'z' ]
]
Note that the combination generation is computed from left to right, and that only one level of nesting is allowed.
The
$limit parameter is set to an arbitrary value of 10000 to limit the number of results returned.
Regex::IsRegex ( $expression )
Checks if the specified expression is a valid regular expression.
The
$delimiter parameter indicates the delimiter character that is to be used for the regular expression.
If not specified, the delimiter character will be taken from the first character of the specified regular expression.
IsRegex
returns
true if
$expression is a valid regular expression, and
false otherwise.
Note that the PCRE package allows for regular expressions to be delimited by the following symmetric characters :
[], {}, <> and (). The
IsRegex
method behaves the same way.
Regex::MultiSubstrReplace ( $subject, $replacements )
Performs multiple substring replacements within the same string.
$subject is the string to be processed.
$replacements is an array of arrays containing 3 elements :
- The string to be replaced in $subject
- The replacement string
- The offset, in $subject, of the string to be replaced
This function can be used with an array based on a match list returned by the
preg_match_all()
function.
Internally, this function is used by the
NormalizeMetaSequence()
and
RenumberNamedCaptures()
methods.
Internal methods
This section lists methods that are used internally by the Regex class, but are made public in case of...
Regex::GroupNamedCaptures ( $match, $replacements )
Used by the Regex::Preg*Ex methods.
Once capture groups have been renamed by the
Regex::RenumberNamedCaptures()
method to ensure unique capture names,
this function is called to rename back the matched elements returned by the
preg_*
functions in order to regroup
named captures together, using their original names.
The
$match parameter is returned by one of the
preg_*
functions.
$replacements is an associative array returned by the
Regex::RenumberNamedCaptures()
,
whose keys are the computed unique capture group names, and values are the original capture names
(which can be present several times in the original regular expression).
Regex::NormalizeMetaSequence ( $sequence, $subsequences = null )
Normalizes a meta-sequence, which uses preg-like backreference syntax to reference regular expressions indexed by the
backreference value in the $match_definitions array.
The method accepts all the backreference syntaxes that are recognized by the preg_replace function
('x' stands for a sequence of digits, 'name' for a group capture name) :
- \x
- \gx
- \g{x}
- (?P=name)
- \k<name>
- \k'name'
- \k{name}
- \g{name}
All those forms are normalized in the input sequence as *(\x)* or *(\name)*
(note the enclosing parentheses to prevent side effects when performing the match).
Regex::PregWipeMatches ( &$matches, $flags )
Removes unnamed captures from the result of a call to a
preg_*
function.
The
$flags parameter is the one supplied to a preg_match...() function ;
This is used to determine wether the
PREG_OFFSET_CAPTURE
flag has been specified.
If yes, the two-elements arrays returned in
$matches may be either an empty string, or an array where
the second element (the offset) is -1. In this case, all the two-element arrays will be removed from the result.
Regex::RenumberNamedCaptures ( $pattern, &$correspondances = [], $prefix = 'match_' )
Reassigns unique identifiers to named captures within a regular expression.
The new identifiers will have the form
"prefix_x"
, where
"prefix"
is given by the
$prefix parameter, and
"x"
a unique identifier starting from 0.
On output, the
$correspondances array will hold an associative array whose keys are the new capture group names,
and values the old ones.
Regex::ReplaceNamedPatterns ( $pattern, $subject, $replacements, $options = null )
Replace named patterns in a string. This function uses the result of
self::PregMatchAll()
to match
named patterns with the supplied input array
$replacements.
$pattern is a pattern matching subpart(s) of the specified subject string.
$subject is the string to be matched against.
$replacements is an associative array whose keys are the pattern name
(as specified in the(?P<name> re) parts of a regular expression) and whose values are also an associative array.
Each entry in the array have the following meaning :
key
: A regular expression specifying the value of the named pattern name.
Do not put anchors nor delimiters in this pattern since they are automatically added.
value
: The replacement value for the named pattern specified by the key value.
$options is a combination of
PREG_*
flags.


|
retinanet-cell-detection
1
retinanet-cell-detection: RetinaNet for cell detection.
|
Copyright (C) 2019 Bruno Gregorio - BIPG. More...
Functions | |
| def | MotionKernel (k_size=3, k_angle=0, k_type=None) |
| Create a kernel simulating the motion in the image by using random params. More... | |
| def | createPSFKernel (img_shape=None, k_type=None, k_size=None, k_param=None) |
| Create a PSF kernel to simulate image motion. More... | |
| def | LineKernel (k_size, k_angle, linetype='full') |
| Create a line kernel according to the params. More... | |
| def | CrossKernel (k_size, k_angle) |
| Create a kernel with a cross as the acumulation of two line kernels. More... | |
| def | SnakeKernel (k_size, k_pos) |
| Create a snake kernel according to the params. More... | |
Copyright (C) 2019 Bruno Gregorio - BIPG.
https://brunoggregorio.github.io
https://www.bipgroup.dc.ufscar.br
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
| def mynet.utils.point_spread_functions.createPSFKernel | ( | img_shape = None , |
|
k_type = None , |
|||
k_size = None , |
|||
k_param = None |
|||
| ) |
Create a PSF kernel to simulate image motion.
If all params are None the kernel is randomly created.
The kernel types and usage are based on the paper [VillaPinto2015]_. .. [VillaPinto2015] Villa Pinto, C. H. and Gregorio da Silva, B. C. and Freire, P. G. L. and Bernardes, D. and Carvalho-Tavares, J. and Ferrari, R. J. "Deconvolucao cega aplicada a correcao de artefatos de movimento em imagens de video de microscopia intravital para deteccao automatica de leucocitos". Revista de Informatica Teorica e Aplicada: RITA, v. 22, p. 52-74, 2015.
| img_shape | : The image shape to create kernel accordingly. |
| k_type | : The type of the kernel [0:Gaussian, 1:AiryDisk, 2:Motion]. |
| k_size | : The size of the square kernel. |
| k_param | : The kernel parameter (such as sigma or angle). |
| def mynet.utils.point_spread_functions.CrossKernel | ( | k_size, | |
| k_angle | |||
| ) |
Create a kernel with a cross as the acumulation of two line kernels.
| k_size | : The size of the kernel. |
| k_angle | : The angle of the lines in kernel. |
| def mynet.utils.point_spread_functions.LineKernel | ( | k_size, | |
| k_angle, | |||
linetype = 'full' |
|||
| ) |
Create a line kernel according to the params.
| k_size | : The size of the kernel. |
| k_angle | : The angle of the line in kernel. |
| def mynet.utils.point_spread_functions.MotionKernel | ( | k_size = 3 , |
|
k_angle = 0 , |
|||
k_type = None |
|||
| ) |
Create a kernel simulating the motion in the image by using random params.
| k_size | : The kernel size. |
| k_angle | : The angle of motion in the kernel. |
| k_type | : The kernel type {'line', 'curve'}. |
| def mynet.utils.point_spread_functions.SnakeKernel | ( | k_size, | |
| k_pos | |||
| ) |
Create a snake kernel according to the params.
| k_size | : The size of the kernel. |
| k_pos | : The position of the snake pattern. |


Owner
Repo
Config file (Use Bikeshed default | Use Respec default | Use HTML default)
ReSpec is known to have race condition issues when it's included using the async attribute. Instead, use the defer attribute like so:
async
defer
<script src="https://www.w3.org/Tools/respec/respec-w3c-common" defer class="remove" ></script>


I'll bet this is your first custom made online birthday card!
Hopefully this is cooler than a store-bought card. I looked at a bunch of cards, but none of them were very good - certainly none good enough. They were either too flowery or too cheesy.
I wanted this card to have a more personal message. I still think about how you ended some of your notes to me over the years: "Work Hard and Have Fun." That's good advice! Getting the right balance is still tricky, though.
I hope you like the "card"!
I love you! - Kevin


What is Coozilla?
CooZilla helps you hire Web freelancers in China. If you post a job on CooZilla , and the most relevant freelancers will be instantly informed by email and you will receive a periodic notification also, enabling you to find the best talent.
This is our side project, and just starts. We encourage you to publish your jobs (valid for 30 days) on CooZilla.com, although there are no enough information to offer now.
We focus on Web programming, designing, and system administration.


---
layout: post
title: begging hands
date: '2017-08-13T11:30:27+02:00'
categories:
- Sketches
picture_url: https://film-Storyboards.tumblr.com/post/164139732464/begging-hands
---
Concept sketch: Begging hands action at the supermaket’s cash register.


class: center, middle, inverse, title-slide # Exploring data and models visually
Biometrics by the Beach 2017 ## Grammar of graphics with ggplot2 ### Di Cook (
<EMAIL_ADDRESS>,
@visnut
)
Earo Wang (
<EMAIL_ADDRESS>,
@earowang
) ###
https://github.com/dicook/Biometric2017
--- class: inverse middle # Your turn ![](lorikeets.png) - What is a (data) plot? - What are the three most important data plots? --- class: inverse middle # Your turn How would you describe this plot?  --- class: inverse middle # Your turn What about this one?  --- # Using the package ggplot2 Elements of a plot - data - aesthetics: mapping of variables to graphical elements - geom: type of plot structure to use - transformations: log scale, ... Additional components - layers: multiple geoms, multiple data sets, annotation - facets: show subsets in different plots - themes: modifying style --- # Why use a grammar of graphics?

  Variable in the data is directly mapped to an element in the plot  --- # Data - Olive ```r glimpse(olive) #> Observations: 572 #> Variables: 11 #> $ label <chr> "1.North-Apulia", "2.North-Apulia", "3.North-Apuli... #> $ region <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,... #> $ area <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,... #> $ palmitic <int> 1075, 1088, 911, 966, 1051, 911, 922, 1100, 1082, ... #> $ palmitoleic <int> 75, 73, 54, 57, 67, 49, 66, 61, 60, 55, 35, 59, 70... #> $ stearic <int> 226, 224, 246, 240, 259, 268, 264, 235, 239, 213, ... #> $ oleic <int> 7823, 7709, 8113, 7952, 7771, 7924, 7990, 7728, 77... #> $ linoleic <int> 672, 781, 549, 619, 672, 678, 618, 734, 709, 633, ... #> $ linolenic <int> 36, 31, 31, 50, 50, 51, 49, 39, 46, 26, 21, 30, 50... #> $ arachidic <int> 60, 61, 63, 78, 80, 70, 56, 64, 83, 52, 65, 62, 79... #> $ eicosenoic <int> 29, 29, 29, 35, 46, 44, 29, 35, 33, 30, 24, 44, 33... ``` --- # Plotting points ```r ggplot(olive, aes(x = oleic, y = linoleic, colour = factor(region))) + geom_point() + theme(aspect.ratio = 1) ```  --- class: inverse middle # Your turn ![](lorikeets.png) How is the data mapped to graphical elements? - data: _______ - aesthetics: _________ - geom: ________ - transformations: _________ --- # Adding density layer ```r ggplot(olive, aes(x = oleic, y = linoleic, colour = factor(region))) + geom_point() + geom_density2d() + theme(aspect.ratio = 1) ```  --- class: inverse middle # Your turn ![](lorikeets.png) How is the data mapped to graphical elements? - data: _______ - aesthetics: _________ - geom: ________ - transformations: _________ --- # Too much ink ```r ggplot(olive, aes(x = oleic, y = linoleic, colour = factor(region))) + geom_point(alpha = 0.6) + geom_density2d(alpha = 0.6) + theme(aspect.ratio = 1) ```  --- class: inverse middle # Your turn ![](lorikeets.png) What do we learn about the composition of fatty acids found in the lipid fraction of Italian olive oils? --- # More example -- Soil composition data and corn yield ```r baker <- read_csv("../data/baker.csv") baker #> # A tibble: 215 x 13 #> X Y Corn97BU B Ca Cu Fe K Mg Mn Na #> <int> <int> <dbl> <dbl> <int> <dbl> <int> <int> <int> <int> <int> #> 1 0 0 174.73 2.74 2608 1.44 192 88 442 62 14 #> 2 12 0 147.43 4.23 3167 1.73 180 81 522 66 16 #> 3 24 0 155.39 2.78 2359 1.27 249 110 413 85 15 #> 4 36 0 141.46 1.92 1766 0.76 189 117 314 63 15 #> 5 48 0 148.54 3.95 1647 0.48 188 99 304 73 15 #> 6 60 0 135.30 1.99 1505 0.44 147 72 263 58 13 #> 7 72 0 145.80 1.87 1755 0.52 125 111 302 47 13 #> 8 96 0 150.83 2.00 1902 0.86 188 112 325 76 15 #> 9 108 0 146.21 1.89 1970 0.96 236 105 327 93 12 #> 10 120 0 167.43 1.73 2069 0.92 209 108 343 85 13 #> # ... with 205 more rows, and 2 more variables: P <int>, Zn <dbl> ``` --- # Plotting tiles: corn yield in the field ```r ggplot(baker, aes(x = X, y = Y, fill = Corn97BU)) + geom_tile() + theme_bw() + theme(aspect.ratio = 1) ```  --- ## Plotting points between B and Corn Yield ```r ggplot(baker, aes(x = B, y = Corn97BU)) + geom_point() + theme(aspect.ratio = 1) ```  --- ## Plotting points between Fe and Corn Yield by Cu ```r ggplot(baker, aes(x = Fe, y = Corn97BU, colour = Cu)) + geom_point() + theme(aspect.ratio = 1) ```  --- # Split Cu by high and low ```r baker_cat <- baker %>% mutate(Cu_cat = ifelse(Cu > 2.5, "High", "Low")) ggplot(baker_cat, aes(x = Fe, y = Corn97BU, colour = Cu_cat)) + geom_point() + theme(aspect.ratio = 1) ```  --- # Adding regression line ```r ggplot(baker_cat, aes(x = Fe, y = Corn97BU, colour = Cu_cat)) + geom_point(alpha = 0.6) + geom_smooth(method = "lm") + theme(aspect.ratio = 1) ```  --- # New example - Flying etiquette [41% Of Fliers Think You’re Rude If You Recline Your Seat](http://fivethirtyeight.com/datalab/airplane-etiquette-recline-seat/) ```r fly <- read_csv("../data/flying-etiquette.csv") glimpse(fly) #> Observations: 1,040 #> Variables: 27 #> $ RespondentID <dbl> ... #> $ `How often do you travel by plane?` <chr> ... #> $ `Do you ever recline your seat when you fly?` <chr> ... #> $ `How tall are you?` <int> ... #> $ `Do you have any children under 18?` <chr> ... #> $ `In a row of three seats, who should get to use the two arm rests?` <chr> ... #> $ `In a row of two seats, who should get to use the middle arm rest?` <chr> ... #> $ `Who should have control over the window shade?` <chr> ... #> $ `Is itrude to move to an unsold seat on a plane?` <chr> ... #> $ `Generally speaking, is it rude to say more than a few words tothe stranger sitting next to you on a plane?` <chr> ... #> $ `On a 6 hour flight from NYC to LA, how many times is it acceptable to get up if you're not in an aisle seat?` <chr> ... #> $ `Under normal circumstances, does a person who reclines their seat during a flight have any obligation to the person sitting behind them?` <chr> ... #> $ `Is itrude to recline your seat on a plane?` <chr> ... #> $ `Given the opportunity, would you eliminate the possibility of reclining seats on planes entirely?` <chr> ... #> $ `Is it rude to ask someone to switch seats with you in order to be closer to friends?` <chr> ... #> $ `Is itrude to ask someone to switch seats with you in order to be closer to family?` <chr> ... #> $ `Is it rude to wake a passenger up if you are trying to go to the bathroom?` <chr> ... #> $ `Is itrude to wake a passenger up if you are trying to walk around?` <chr> ... #> $ `In general, is itrude to bring a baby on a plane?` <chr> ... #> $ `In general, is it rude to knowingly bring unruly children on a plane?` <chr> ... #> $ `Have you ever used personal electronics during take off or landing in violation of a flight attendant's direction?` <chr> ... #> $ `Have you ever smoked a cigarette in an airplane bathroom when it was against the rules?` <chr> ... #> $ Gender <chr> ... #> $ Age <chr> ... #> $ `Household Income` <chr> ... #> $ Education <chr> ... #> $ `Location (Census Region)` <chr> ... ``` --- # Variables - Mix of categorical and quantiative variables. - What mappings are appropriate? - Area for counts of categories. - side-by-side boxplots for mixed pair. --- # Support ```r ggplot(fly, aes(x=`How often do you travel by plane?`)) + geom_bar() + coord_flip() ```  **Any room in improving the plot?** -- Categories are not sorted. --- # Sorted categories ```r fly <- fly %>% mutate(`How often do you travel by plane?` = fct_relevel(`How often do you travel by plane?`, "Never","Once a year or less","Once a month or less", "A few times per month","A few times per week","Every day" ) ) ggplot(fly, aes(x=`How often do you travel by plane?`)) + geom_bar() + coord_flip() ```  --- # Sorted categories ```r ggplot(fly, aes(x=`How often do you travel by plane?`, fill=`How often do you travel by plane?`) ) + geom_bar() + coord_flip() + scale_fill_brewer(palette="Dark2") ```  --- # Filter data ```r fly_sub <- fly %>% filter( `How often do you travel by plane?` %in% c("Once a year or less","Once a month or less") ) %>% drop_na(`Do you ever recline your seat when you fly?`, Age, Gender) ``` --- # Recline by height ```r fly_sub <- fly_sub %>% mutate(`Do you ever recline your seat when you fly?` = fct_relevel(`Do you ever recline your seat when you fly?`, "Never","Once in a while","About half the time","Usually","Always" ) ) ggplot(fly_sub, aes( x=`Do you ever recline your seat when you fly?`, y=`How tall are you?` )) + geom_boxplot() + coord_flip() ```  --- class: inverse middle # Your turn ![](lorikeets.png) - Take a look at the ggplot2 [Cheat sheet](https://www.rstudio.com/wp-content/uploads/2016/11/ggplot2-cheatsheet-2.1.pdf) - How many geoms are available in ggplot2? What is `geom_rug`? --- class: inverse middle # Your turn ![](lorikeets.png) What is the difference between `colour` and `fill`? --- class: inverse middle # Your turn ![](lorikeets.png) What does `coord_fixed()` do? What is the difference between this and using `theme(aspect.ratio=...)`? --- class: inverse middle # Your turn ![](lorikeets.png) What are scales? How many numeric transformation scales are there? --- class: inverse middle # Your turn ![](lorikeets.png) What are position adjustments? When would they be used? --- class: inverse middle # Your turn ![](lorikeets.png) Use your cheat sheet to work out how to make plot to explore the relationship between `Do you ever recline your seat when you fly?` and `Is it rude to recline your seat on a plane?` --- # Facets ```r ggplot(fly_sub, aes(x=`In general, is itrude to bring a baby on a plane?`)) + geom_bar() + coord_flip() + facet_wrap(~Gender) ```  --- # Facets ```r fly_sub <- fly_sub %>% mutate(Age = factor(Age, levels=c("18-29","30-44","45-60","> 60"))) ggplot(fly_sub, aes(x=`In general, is itrude to bring a baby on a plane?`)) + geom_bar() + coord_flip() + facet_grid(Age~Gender) ```  --- class: inverse middle # Your turn ![](lorikeets.png) What's the difference between `facet_wrap()` and `facet_grid()`? --- # Temporal example -- daily temperatures ``` #> # A tibble: 366 x 6 #> ID DATE TMAX TMIN MONTH DAY #> <chr> <date> <dbl> <dbl> <ord> <int> #> 1 ASN00090015 2016-01-01 20.9 17.5 Jan 1 #> 2 ASN00090015 2016-01-02 19.5 14.5 Jan 2 #> 3 ASN00090015 2016-01-03 19.3 16.2 Jan 3 #> 4 ASN00090015 2016-01-04 20.2 16.7 Jan 4 #> 5 ASN00090015 2016-01-05 20.6 16.1 Jan 5 #> 6 ASN00090015 2016-01-06 20.3 16.5 Jan 6 #> 7 ASN00090015 2016-01-07 19.7 14.8 Jan 7 #> 8 ASN00090015 2016-01-08 18.8 14.2 Jan 8 #> 9 ASN00090015 2016-01-09 19.0 11.3 Jan 9 #> 10 ASN00090015 2016-01-10 25.4 11.9 Jan 10 #> # ... with 356 more rows ``` --- # Time series plot ```r ggplot(otway_temp, aes(x = DATE)) + geom_line(aes(y = TMAX), colour = "#1b9e77") + geom_line(aes(y = TMIN), colour = "#7570b3") + ylab("Daily maximum and minimum temperatures") ```  --- # Facetted by months ```r ggplot(otway_temp) + geom_rect(aes(xmin = DAY - 0.5, xmax = DAY + 0.5, ymin = TMIN, ymax = TMAX), colour = "white", fill = "grey30") + facet_wrap(~ MONTH, ncol = 3) + xlab("Day") + ylab("Daily temperature") ```  --- # Map example -- whale sharks The whale shark data was pulled from [https://www.whaleshark.org](https://www.whaleshark.org) ```r whalesharks <- read_csv("../data/whaleshark-encounters.csv") library(lubridate) ningaloo <- whalesharks %>% filter(grepl("Ningaloo", Locality)) %>% mutate(date=ymd(paste(`Year Collected`, `Month Collected`, `Day Collected`, sep="-"))) ningaloo %>% select(date, `Marked Individual`, Longitude, Latitude) #> # A tibble: 5,195 x 4 #> date `Marked Individual` Longitude Latitude #> <date> <chr> <dbl> <dbl> #> 1 2013-08-21 A-720 113.9015 -21.90130 #> 2 2013-08-21 A-793 113.9015 -21.90130 #> 3 2013-07-27 A-749 113.9015 -21.90130 #> 4 2013-07-23 A-907 113.8903 -22.00913 #> 5 2013-07-23 A-822 113.8821 -22.06176 #> 6 2013-07-23 A-356 113.9015 -21.90130 #> 7 2013-07-23 A-720 113.9048 -21.95900 #> 8 2013-07-20 A-899 113.9015 -21.90130 #> 9 2013-07-20 A-666 113.9015 -21.90130 #> 10 2013-07-20 A-900 113.9013 -21.97340 #> # ... with 5,185 more rows ``` --- # Track one individual ```r library(ggmap) map <- get_map(location=c(lon=114.1, lat=-21.9), zoom=8) A524 <- ningaloo %>% filter(`Marked Individual`=="A-524") ggmap(map) + geom_point(data=A524, aes(x=Longitude, y=Latitude), colour="red") + geom_line(data=A524, aes(x=Longitude, y=Latitude), colour="red") ```  --- ## Histogram: the distrubition of the number of sightings ```r ningaloo_nomiss <- ningaloo %>% drop_na(`Marked Individual`) ningaloo_nomiss %>% count(`Marked Individual`, sort=TRUE) %>% ggplot(aes(x=n)) + geom_histogram(binwidth=5) ```  --- # Facetted by different individuals ```r ggmap(map) + geom_point(data=ningaloo_freqwhales, aes(x=Longitude, y=Latitude, colour=`Marked Individual`)) + geom_line(data=ningaloo_freqwhales, aes(x=Longitude, y=Latitude, colour=`Marked Individual`, group=`Marked Individual`)) + facet_wrap(~`Marked Individual`, ncol=7) + theme(legend.position="None") ```  --- # Facetted by years collected ```r ggmap(map) + geom_point(data=ningaloo_freqwhales, aes(x=Longitude, y=Latitude, colour=`Marked Individual`)) + geom_line(data=ningaloo_freqwhales, aes(x=Longitude, y=Latitude, colour=`Marked Individual`, group=`Marked Individual`)) + facet_wrap(~`Year Collected`, ncol=6) + theme(legend.position="None") ```  --- # Facet by months collected ```r ggmap(map) + geom_point(data=ningaloo_freqwhales, aes(x=Longitude, y=Latitude, colour=`Marked Individual`)) + geom_line(data=ningaloo_freqwhales, aes(x=Longitude, y=Latitude, colour=`Marked Individual`, group=`Marked Individual`)) + facet_wrap(~`Month Collected`, ncol=4) + theme(legend.position="None") ```  --- class: middle inverse center # Graphical principles --- # Color palettes - default ```r p <- ggplot(fly_sub, aes( x=`In general, is itrude to bring a baby on a plane?`, fill=Gender )) + geom_bar(position="fill") + coord_flip() + facet_wrap(~Age, ncol=4) p ```  What do we learn? --- # Color palettes - brewer ```r p + scale_fill_brewer(palette="Dark2") ```  --- # Color blind-proofing ```r library(scales) library(dichromat) clrs <- hue_pal()(3) p + theme(legend.position = "none") clrs <- dichromat(hue_pal()(3)) p + scale_fill_manual("", values=clrs) + theme(legend.position = "none") ``` --- ![](index_files/figure-html/unnamed-chunk-44-1.png)![](index_files/figure-html/unnamed-chunk-44-2.png) --- # Perceptual principles - Hierarchy of mappings: (first) position along an axis - (last) color (Cleveland, 1984; Heer and Bostock, 2009) - Pre-attentive: Some elements are noticed before you even realise it. - Color: (pre-attentive) palettes - qualitative, sequential, diverging. - Proximity: Place elements for primary comparison close together. - Change blindness: When focus is interrupted differences may not be noticed. --- # Hierarchy of mappings - 1.Position - common scale (BEST) - 2.Position - nonaligned scale - 3.Length, direction, angle - 4.Area - 5.Volume, curvature - 6.Shading, color (WORST) --- # Pre-attentive Can you find the odd one out?  --- Is it easier now?  --- # Color palettes - Qualitative: categorical variables - Sequential: low to high numeric values - Diverging: negative to positive values ---  --- # Proximity ```r ggplot(fly_sub, aes( x=`In general, is itrude to bring a baby on a plane?`,fill=Gender )) + geom_bar(position="fill") + coord_flip() + facet_wrap(~Age, ncol=5) ``` With this arrangement we can see proportion of gender within each rudeness category, and compare these across age groups. How could we arrange this differently? ---  --- # Proximity ```r ggplot(fly_sub, aes( x=Gender,fill=`In general, is itrude to bring a baby on a plane?` )) + geom_bar(position="fill") + coord_flip() + facet_wrap(~Age, ncol=5) + theme(legend.position="bottom") ``` ---  What is different about the comparison now? --- # Another arrangement ```r ggplot(fly_sub, aes( x=Age, fill=`In general, is itrude to bring a baby on a plane?`)) + geom_bar(position="fill") + coord_flip() + facet_wrap(~Gender, ncol=5) + theme(legend.position="bottom") ``` ---  --- # Themes The `ggthemes` package has many different styles for the plots. Other packages such as `xkcd`, `skittles`, `wes anderson`, `beyonce`, .... ```r library(xkcd) ggplot(fly_sub, aes( x=Gender,fill=`In general, is itrude to bring a baby on a plane?` )) + geom_bar(position="fill") + coord_flip() + facet_wrap(~Age, ncol=5) + theme_xkcd() + theme(legend.position="bottom") ``` See the [vignette](https://cran.r-project.org/web/packages/xkcd/vignettes/xkcd-intro.pdf) for instructions on installing the xkcd font. ---  --- class: inverse middle # Your turn ![](lorikeets.png) Compile the rmarkdown document that you have put together thus far in the workshop! --- # Resources - ggplot2 [Cheat sheet](https://www.rstudio.com/wp-content/uploads/2016/11/ggplot2-cheatsheet-2.1.pdf) - [ggplot2: Elegant Graphics for Data Analysis, Hadley Wickham](http://ggplot2.org/book/), [web site](http://ggplot2.org) - [R Graphics Cookbook, Winston Chang](http://www.cookbook-r.com/Graphs/) - [Naomi Robbins, Creating More Effective Graphs](http://www.nbr-graphs.com) - [Antony Unwin, Graphical Data Analysis with R](https://www.crcpress.com/Graphical-Data-Analysis-with-R/Unwin/9781498715232) --- # Share and share alike This work is licensed under the Creative Commons Attribution-Noncommercial 3.0 United States License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc/3.0/us/ or send a letter to Creative Commons, 171 Second Street, Suite 300, San Francisco, California, 94105, USA.


| code_change/3 | |
| get_connection/1 | Get a db connection, wait at most ?PGSQL_CALL_TIMEOUT seconds before giving up. |
| get_connection/2 | Get a db connection, wait at most Timeout seconds before giving up. |
| get_database/1 | Return the name of the database used for the pool. |
| get_database_opt/2 | |
| handle_call/3 | |
| handle_cast/2 | |
| handle_info/2 | |
| init/1 | |
| return_connection/2 | Return a db connection back to the connection pool. |
| start_link/2 | |
| start_link/3 | |
| status/1 | Return the current status of the connection pool. |
| stop/1 | Stop the pool, close all db connections. |
| terminate/2 |
code_change(OldVsn, State, Extra) -> any()
get_connection(P) -> any()
Get a db connection, wait at most ?PGSQL_CALL_TIMEOUT seconds before giving up.
get_connection(P, Timeout) -> any()
Get a db connection, wait at most Timeout seconds before giving up.
get_database(P) -> any()
Return the name of the database used for the pool.
get_database_opt(Opt, P) -> any()
handle_call(Request, From, State) -> any()
handle_cast(Request, State) -> any()
handle_info(Info, State) -> any()
init(X1) -> any()
return_connection(P, C) -> any()
Return a db connection back to the connection pool.
start_link(Size, Opts) -> any()
start_link(Name, Size, Opts) -> any()
status(P) -> any()
Return the current status of the connection pool.
stop(P) -> any()
Stop the pool, close all db connections
terminate(Reason, State) -> any()
Generated by EDoc, Apr 11 2012, 20:41:28.


{% extends "global/Page.html" %} {% load staticfiles otree %} {% block title %} Question {{ player.round_number }} of {{ Constants.num_rounds }}: Team {% if player.treatment == 'A' %} B {% else %} A {% endif %} {% endblock %} {% block content %}
And here is the other team's question.
Note that this is just for your information -- not for you to answer!
{{ player.other_question }}
Please click 'Next' to see your team's next question.


connect_error) { die("Connection failed: " . $conn->connect_error); } $query = $conn->query("SELECT * FROM users WHERE (email='" . $email ."' AND accounttype='" . $platform . "')"); if($query){ $row = $query->fetch_assoc(); if($row['schedule'] == ""){ header('Location: uploadschedule.html'); } }else{ mysqli_close($conn); die(); } ?>
All schedule and contact information is stored securely. We will never disclose or give out your schedule, email, name, or any other information we obtain from you. Note that your schedule is public information on WWW in the sense that anybody can compare schedule with you if they have your name or UID.  Your email will be stored for login purposes, but never disclosed to third parties or other users. We will never sign you up for pornographic newsletters. We may use your email to contact you if an issue arises, or if you use the 'Contact Us' form found here.
WatWhenWhere uses both Facebook and Google API's for login. API's are implemented using secure practices. When you create an account, we store your email in our databases, but never your password. By using OAuth2, you're entrusting your password with Google/Facebook and no-one else. At no point does WatWhenWhere have scope of your password. While data leaks are always a possibility, we have taken every measure to ensure your data security.
WatWhenWhere uses cookies to store browser session info, login state, and various temporary values. No confidential information is disclosed by our use of cookies. We also use Javascript for various client-side data processing. Specifically, our Google and Facebook OAuth2 API's are javascript. Even after logging in, we require Javascript to validate an active session with Facebook or Google. By disabling cookies or Javascript, WatWhenWhere will seize to function normally.


[1]
HI MEMORY. WATCH OUT, ITS COMIN w/ 32GB!! BEAT THAT!!!; NO DEDICATED VOLUME
[2]
Small size; Looks cheap.
[3]
Great paperweight; Terrible support


MVADetailsViewController Class Reference
| Inherits from | UIViewController |
| Declared in | MVADetailsViewController.h MVADetailsViewController.m |
Overview
This class is a subclass of UIViewController and is used to display the details of the paths.
Tasks
Other Methods
-
punto
property -
customlocation
property -
orig
property -
subwayPath
property -
busPath
property -
graphs
property -
walkDist
property -
walkTime
property -
carDist
property -
carTime
property -
initTime
property
Other Methods
-
– viewDidLoad
-
– didReceiveMemoryWarning
-
– viewWillAppear:
-
– loadSavedPaths
-
– createParallax
-
– insetView
-
– subwayView
-
– busView
-
– subwayPathView:
-
– busPathView:
-
– walkingView
-
– taxiCellView
-
– footerView
-
– starTapped:
-
– hailoTap:
-
– alertView:clickedButtonAtIndex:
-
– loadCustom
-
– loadCustomLocation
-
– customDate
-
– loadCustomDate
-
– connectedToInternet
-
– prepareForSegue:sender:
Properties
busPath
A MVAPath object that contains the bus path
@property MVAPath *busPath
Availability
version 1.0
Discussion
A MVAPath object that contains the bus path
See Also
MVAPath class
Declared In
MVADetailsViewController.h
carDist
The distance in car from the origin to the destination
@property double carDist
Availability
version 1.0
Discussion
The distance in car from the origin to the destination
Declared In
MVADetailsViewController.h
carTime
The travel time in car from the origin to the destination
@property double carTime
Availability
version 1.0
Discussion
The travel time in car from the origin to the destination
Declared In
MVADetailsViewController.h
customlocation
A custom location selected by the user. The default value is nil.
@property MVACustomLocation *customlocation
Availability
version 1.0
Discussion
A custom location selected by the user. The default value is nil.
See Also
MVACustomLocation class
Declared In
MVADetailsViewController.h
graphs
The graphs that will be used to compute the subway and bus paths.
@property MVAGraphs *graphs
Availability
version 1.0
Discussion
The graphs that will be used to compute the subway and bus paths.
See Also
MVAGraphs class
Declared In
MVADetailsViewController.h
initTime
The initial time of the paths in seconds
@property double initTime
Availability
version 1.0
Discussion
The initial time of the paths in seconds
Declared In
MVADetailsViewController.h
orig
The origin’s coordinates.
@property CLLocationCoordinate2D orig
Availability
version 1.0
Discussion
The origin’s coordinates.
Declared In
MVADetailsViewController.h
punto
The point to be displayed and that will be used to calculate the itineraries.
@property MVAPunInt *punto
Availability
version 1.0
Discussion
The point to be displayed and that will be used to calculate the itineraries.
See Also
MVAPunInt class
Declared In
MVADetailsViewController.h
subwayPath
A MVAPath object that contains the subway path
@property MVAPath *subwayPath
Availability
version 1.0
Discussion
A MVAPath object that contains the subway path
See Also
MVAPath class
Declared In
MVADetailsViewController.h
Instance Methods
alertView:clickedButtonAtIndex:
Sent to the delegate when the user clicks a button on an alert view.
- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
Parameters
- alertView
The alert view containing the button.
- buttonIndex
The index of the button that was clicked. The button indices start at 0.
Availability
version 1.0
Discussion
Sent to the delegate when the user clicks a button on an alert view.
Declared In
MVADetailsViewController.m
busPathView:
Function that gets called after the bus path view has been selected
- (void)busPathView:(UITapGestureRecognizer *)gr
Parameters
- gr
The tap gesture recognizer object
Availability
version 1.0
Discussion
Function that gets called after the bus path view has been selected
Declared In
MVADetailsViewController.m
busView
Function that creates the bus view
- (UIView *)busView
Return Value
The bus view
Availability
version 1.0
Discussion
Function that creates the bus view
Declared In
MVADetailsViewController.m
connectedToInternet
Function that checks if there’s internet connection
- (BOOL)connectedToInternet
Return Value
A bool answering the query
Availability
version 1.0
Discussion
Function that checks if there’s internet connection
Declared In
MVADetailsViewController.m
createParallax
Function that create the parallax effect
- (void)createParallax
Availability
version 1.0
Discussion
Function that create the parallax effect
Declared In
MVADetailsViewController.m
customDate
This function loads if the user has selected a custom date
- (BOOL)customDate
Return Value
A boolean
Availability
version 1.0
Discussion
This function loads if the user has selected a custom date
Declared In
MVADetailsViewController.m
didReceiveMemoryWarning
Function that gets called when there’s a memory leak or warning
- (void)didReceiveMemoryWarning
Availability
version 1.0
Discussion
Function that gets called when there’s a memory leak or warning
Declared In
MVADetailsViewController.m
footerView
Function that creates the footer view
- (UIView *)footerView
Return Value
The footer view
Availability
version 1.0
Discussion
Function that creates the footer view
Declared In
MVADetailsViewController.m
hailoTap:
Function that gets called after the taxi view has been selected
- (void)hailoTap:(UITapGestureRecognizer *)gr
Parameters
- gr
The tap gesture recognizer object
Availability
version 1.0
Discussion
Function that gets called after the taxi view has been selected
Declared In
MVADetailsViewController.m
insetView
Function that creates the insets
- (UIView *)insetView
Return Value
The insets view
Availability
version 1.0
Discussion
Function that creates the insets
Declared In
MVADetailsViewController.m
loadCustom
Function that loads the index of the custom location chosen
- (int)loadCustom
Return Value
The index of the custom location inside the custom locations array
Availability
version 1.0
Discussion
Function that loads the index of the custom location chosen
Declared In
MVADetailsViewController.m
loadCustomDate
This function loads either the custom date chosen by the user or the current date of the device
- (NSDate *)loadCustomDate
Return Value
An NSDate object
Availability
version 1.0
Discussion
This function loads either the custom date chosen by the user or the current date of the device
Declared In
MVADetailsViewController.m
loadCustomLocation
Function that loads if the user has chosen a custom location.
- (MVACustomLocation *)loadCustomLocation
Return Value
The MVACustonLocation object.
Availability
version 1.0
Discussion
Function that loads if the user has chosen a custom location.
See Also
MVACustomLocation object
Declared In
MVADetailsViewController.m
loadSavedPaths
Function that loads the paths saved by the user
- (void)loadSavedPaths
Availability
version 1.0
Discussion
Function that loads the paths saved by the user
Declared In
MVADetailsViewController.m
prepareForSegue:sender:
Called when a segue is about to be performed. (required)
- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
Parameters
- segue
The segue object containing information about the view controllers involved in the segue.
- sender
The object that initiated the segue. You might use this parameter to perform different actions based on which control (or other object) initiated the segue.
Availability
version 1.0
Discussion
Called when a segue is about to be performed. (required)
Declared In
MVADetailsViewController.m
starTapped:
Function that gets called when the user selects the star button.
- (IBAction)starTapped:(id)sender
Parameters
- sender
The star button.
Availability
version 1.0
Discussion
Function that gets called when the user selects the star button.
Declared In
MVADetailsViewController.m
subwayPathView:
Function that gets called after the subway path view has been selected
- (void)subwayPathView:(UITapGestureRecognizer *)gr
Parameters
- gr
The tap gesture recognizer object
Availability
version 1.0
Discussion
Function that gets called after the subway path view has been selected
Declared In
MVADetailsViewController.m
subwayView
Function that creates the subway view
- (UIView *)subwayView
Return Value
The subway view
Availability
version 1.0
Discussion
Function that creates the subway view
Declared In
MVADetailsViewController.m
taxiCellView
Function that creates the taxi view
- (UIView *)taxiCellView
Return Value
The taxi view
Availability
version 1.0
Discussion
Function that creates the taxi view
Declared In
MVADetailsViewController.m
viewDidLoad
Function that gets called when the view controller has loaded the view
- (void)viewDidLoad
Availability
version 1.0
Discussion
Function that gets called when the view controller has loaded the view
Declared In
MVADetailsViewController.m
viewWillAppear:
Notifies the view controller that its view is about to be added to a view hierarchy.
- (void)viewWillAppear:(BOOL)animated
Parameters
- animated
If YES, the view is being added to the window using an animation.
Availability
version 1.0
Discussion
Notifies the view controller that its view is about to be added to a view hierarchy.
Declared In
MVADetailsViewController.m


Our rooms and suites are uniquely and elegantly decorated to reflect traditional
architecture.
Each of them is equipped with air-conditioning, an en-suite bathroom and a Swahili-bed.
The rooms are placed in a perfect position where guests can enjoy the ocean view regardless
being at any room.


Register Employee Visitor
First Name
Last Name
Username
User Type
Manager
Staff
Password
Confirm Password
Phone
Address
City
State
AL
AK
AZ
AR
CA
CO
CT
DE
FL
GA
HI
ID
IL
IN
IA
KS
KY
LA
ME
MD
MA
MI
MN
MS
MO
MT
NE
NV
NH
NJ
NM
NY
NC
ND
OH
OK
OR
PA
RI
SC
SD
TN
TX
UT
VT
VA
WA
WV
WI
WY
Other
Zipcode
Email
{% for email in emails %}
{{email.Email}}
Remove
{% endfor %}
Add Email
Register
Back
{{error}}


title = "Team One" url = "/practice/:slug" layout = "default" is_hidden = 0 child_of = "mey_no_parent" hide_crumb = 0 remove_crumb_trail = 0 crumb_disabled = 0 [practice_list] [practice_info] slug = "{{ :slug }}" == {% component 'practice_info::breadcrumbs.htm' %} {% component 'practice_info' %} {%component "practice_list::left_sidebar.htm"%}


Wallabies legend Phil Kearns worried about mental well being of Israel Folau over bushfire comments
by Naveel KrishantInstead of getting angry, Wallabies legend Phil Kearns says he now just feels sorry for Israel Folau and is concerned about his mental well-being following his controversial bushfire comments.
Sacked Wallabies star Folau has caused yet another uproar by claiming the fires crippling Australia were God’s punishment for legalising abortion and same-sex marriage.
Kearns says it has got to the point where he actually just feels sorry for Folau.
He adds it is just really sad now adding, unfortunately, there is a great talent that is lost.


Jackson telling us about his blog, Journey Era..." Journey Era was inspired by a love for adventure and a curiosity for exploration. It was also influenced by a huge fear of the 9-5, the daily grind, and the deadly trap of consumerism. I travel the world, making small amounts of money for photography jobs, social media consultation, and other bits and pieces. The content is 99% our adventures and 1% some travel tips. We write about pretending to know how to travel or think we know what we are doing. The emphasis is on quality images and getting off the beaten path, which separates the blog from a lot of other travel blogs."
Jackson is a digital nomad who is exploring epic locations around the world. He is a Travel, lifestyle, and adventure photography. I really like to capture the moment someone reaches the top of a mountain when that feeling of amazement sweeps over their face, or the moment a cliff diver’s heart stops as they look at the camera while hanging upside down.
Oahu, Hawaii
Greece
Thailand
India
Himalayas
Siem Reap, Cambodia
Jackson started photography in June 2015 and shot for Surfline as a Local Pro for several months as well as freelance assignments. Having traveled extensively throughout America, Australia and Europe, Jackson has had his articles and photography published in Lei Magazine, INHNL, Kikaha Magazine (Island Air) and Hawaii Eco Living.
With a desire to travel slowly so he can get to know an area and explore places off the beaten path, Jackson uses couch surfing, cheap hotels and sponsored accommodation to be able to travel full-time. He travels and lives a very minimalist lifestyle by carrying only a backpack and camera gear.


About Me
I started web development by the age of 12. Then, during High school created small, small websites. During College days created and maintained website for our department. But officially became a Front End Web Developer in the year 2016 through udacity Front End Web Developer Nanodegree and started creating responsive and elegant websites
Apart from this I love to cook a lot with the vegetables, which I grew in either my roof top or in my farm. While the food is cooking I love to make some tattoo arts
A money collector will have very few coins at first, but the thing which we put inside it makes it worth at the end. Likewise, my project history might have less number of projects, but if you drop a project inside my brain you might come to know my talent at the end of the project.


Adds text labels to the GoogleEarth visualization.
Adds text labels to the GoogleEarth visualization.
| kmlStr = ge_text(X,Y,Z,'S') |
| kmlStr = ge_plot(X,Y,Z,'S',Parameter,Value) |
| kmlStr = ge_text(X,Y,Z,'S') |
Places the string argument 'S' at location specified by X (longitude), Y (latitude), and Z (altitude).
| kmlStr = ge_text(X,Y,Z,'S',Parameter,Value) |
Some options can be used in combination with ge_text. Assigning values to the parameters is accomplished by inclusion of an alternating sequence of parameters and their value. The table below provides an overview of the authorized options. The order in which the parameters are included does not matter. Please be aware that the options are case-sensitive. Examples are provided further down.
| Parameter | Description |
| 'altitude' | Height difference relative to the plane of reference (see parameter 'altitudeMode'). |
| 'altitudeMode' | Specifies which plane of reference to use. Must be one of 'absolute', 'relativeToGround' or 'clampToGround'. |
| 'description' | A description of the object can be included using this parameter. Its value must be passed as a character array. Including a description will cause a text balloon to pop up from the map at the object's location. This balloon contains the character array included in 'description'. |
| 'msgToScreen' | Defines whether verbose feedback is provided by the function when it is accessed and when it finishes. Default is false (which is equivalent to logical(0), but quicker). |
| 'snippet' | A short description of the feature. In Google Earth, this description is displayed in the Places panel under the name of the feature. If a Snippet is not supplied, the first two lines of the description are used |
| 'timeSpanStart' | See Dynamic visualization. |
| 'timeSpanStop' | See Dynamic visualization. |
| 'visibility' | Defines whether the object is visible. Must be passed as numerical value 1 or 0. |
Latitudes on the Southern hemisphere should be passed to ge_text() as negative values. Same for longitudes on the Western hemisphere.
Latitudes and longitudes should be passed in units of decimal degrees (also known as fractional degrees). Google Earth uses Simple Cylindrical projection (also known as Plate Carée) with a WGS84 datum. Altitudes are in meters.
A line can consist of multiple sections; these will all be assigned identical properties such as line width and color. When different lines should be assigned different line styles, use multiple calls to ge_plot() with different line style parameters. Disconnected lines with identical linestyles can be generated using coordinate vectors separated by NaNs.
See the demo file demo_ge_text for more details.


General support queries. User Guides: https://support.komodoplatform.com/ Support staff: Angelina#6231 gcharang#6833. If you want to ask JL777 a question, use the #ask-jl777 channel.
100 messages
Before 05-Dec-19 12:00 AM
jl777c04-Jul-18 10:11 AM
there is only one issuing of coins at the start with ac_supply
GatewayBOT04-Jul-18 10:43 AM
[slack] <kso> Thank you very much @jl777c!
Hermes04-Jul-18 11:56 AM
@StakeSourcePoS When you make a new installation of Agama the essential or key information is not lost , basically the new version will be rewritten on top .(edited)
guess not, but agama needs an auto update feature, or at least a notification that says the version you are using is now out of date
Hermes04-Jul-18 01:54 PM
Make sure you have the latest Agama version 2.41
LordTricky04-Jul-18 01:58 PM
i have but these constant updates are getting incestuous, they need to automate the process.
Hermes04-Jul-18 01:59 PM
Are you experiencing a server connection error with version 2.41?
Chris1111104-Jul-18 04:39 PM
I can't seem to be getting around a javascript error when trying to open agama. I have rebooted, uninstalled, reinstalled all twice over. Nothing seems to be working.
Hermes04-Jul-18 04:47 PM
@Chris11111 you are installing and selecting the english version of the wallet right? Please send us a ticket at<EMAIL_ADDRESS>and we will try to replicate, also send us your machines Windows version and screenshots of the error if possible.
LordTricky04-Jul-18 04:53 PM
@Hermes sorry, no mate. 2.41 works at the mo
Chris1111104-Jul-18 05:07 PM
Yes, I am using the English version. I sent in a ticket and tried to provide as much detail as possible.
Hermes04-Jul-18 05:35 PM
Ok I will get back to you on the ticket I will be testing and seeing what can be causing the issue
GatewayBOT04-Jul-18 05:43 PM
[slack] <rhex1> I will resynch from scratch now
[slack] <rhex1> Yeah it's synching!
Hermes04-Jul-18 05:49 PM
Good to know that
Let us know if it finishes synching
GatewayBOT04-Jul-18 06:00 PM
[slack] <rhex1>
Lumbi04-Jul-18 07:27 PM
electrum1 & electrum2 unreachable in agama?
Hermes04-Jul-18 07:36 PM
Which version of the wallet you currently have 2.41?
@Lumbi
Lumbi04-Jul-18 07:51 PM
v<IP_ADDRESS>c-beta
@Hermes
Hermes04-Jul-18 07:52 PM
Please update to 2.41 this should resolve the issue
[slack] <kso> Hi @jl777c, may I please ask to confirm whether my understanding is correct or not. Say we create an assetchain with ac_supply=270000000 coins
and ac_reward=3 coins
After the second block gets mined and assuming all block rewards and the premine of 270000000 go to the same node, will that node now have two utxo's like this:
utxo #1: 270000000
utxo #2: 3
Giving a balance of 270000003.
Then after the 3rd block gets mined will that node now have 3 utxos like this:
utxo #1: 270000000
utxo #2: 3
utxo #3: 3
Giving a balance of 270000006 coins for that node.
jl777c05-Jul-18 07:52 AM
yees
but at a block reward of 3 it will take a long time to get to a billion coins
GatewayBOT05-Jul-18 07:57 AM
[slack] <kso> Thanks very much @jl777c for the confirmation! Yes we'll need to calculate a bigger block reward! Have a nice day!
ok just to have it documented please send a ticket at<EMAIL_ADDRESS>, Nabob or me will get back to you shortly @Chris11111(edited)
Nabob06-Jul-18 03:08 AM
@Chris11111 please be cautious using web wallet, never use large amount funds. its still in early development phase
meanwhile, move all your funds to agama wallet
Chris1111106-Jul-18 03:09 AM
I only was using it because I was having trouble with a Javascript error when using desktop wallet
That's the only reason I used it unfortunately is because I can't get Agama desktop app to run
Nabob06-Jul-18 03:10 AM
post the error screenshot of agama wallet, will help you to fix
Chris1111106-Jul-18 03:10 AM
I sent in a support ticket the other day with the screenshot
Nabob06-Jul-18 03:11 AM
ok
Chris1111106-Jul-18 03:11 AM
I believe the support ticket number is 9636
tipmebits06-Jul-18 06:58 AM
Is Agama wallet all good? cannot connect to server
Acura06-Jul-18 07:40 AM
@tipmebits please update your Agama
1
tipmebits06-Jul-18 07:44 AM
Damn, used to give me the ol' "please update" BAM - updated
SRG06-Jul-18 07:50 AM
I lost my interest after claiming it
Hermes06-Jul-18 12:14 PM
@SRG Please file a ticket at<EMAIL_ADDRESS>so we can review this , if you are using native mode most likely is in a change address. You can trigger a wallet rescan and you should be able to see it.
SRG06-Jul-18 12:38 PM
I used Agama web wallet
Hermes06-Jul-18 01:17 PM
For now don't use the web wallet is on testing mode , please use the app. send us the tx id that you have for this and we will look into it
SRG06-Jul-18 05:26 PM
Below is the Tx Id used for claiming the interest cd27d83edea975af27487ad1d65615cc302e12a8a594f0341d3dc77d3b34fe84
ComputerGenie06-Jul-18 05:33 PM
@SRG did what did you use to pull those funds from the z_addy?
SRG06-Jul-18 05:34 PM
Didn't get you @ComputerGenie
I simply tried to claim the interest that I earned(edited)
@SRG Thanks for reporting. Agama web wallet is now fixed and live by @pbca26
Please note: The web wallet is highly experimental and under active development. Don't use the web wallet with large sum of funds.
Hermes06-Jul-18 05:39 PM
@SRG Over here is difficult to give you a proper answer to your issue please send a ticket to<EMAIL_ADDRESS>to also have it documented
True I just tested it a while ago and it works
SRG06-Jul-18 05:43 PM
@shossain what about my funds that I lost?
ComputerGenie06-Jul-18 05:43 PM
I could be wrong, but what it looks like to me is that when it came out of the z addy and was initially split into the 450 it didn't get timelock stamp
SHossain06-Jul-18 05:44 PM
accrued rewards may have ended up to miner
SRG06-Jul-18 05:44 PM
Then now?
@shossain so I lost those funds permanently?
SHossain06-Jul-18 05:48 PM
Yes and you already received a reward for submitting the bug. that should cover your losses.