Class JXG.Board
↳ JXG.Board
JXG.Board controls all properties and methods used to manage a geonext board like managing geometric
elements, managing mouse and touch events, etc. You probably don't want to use this constructor directly.
Please use JXG.JSXGraph#initBoard to initialize a board.
Defined in: board.js.
| Constructor Attributes | Constructor Name and Description |
|---|---|
|
JXG.Board(container, renderer, id, origin, zoomX, zoomY, unitX, unitY, canvasWidth, canvasHeight, attributes)
Constructs a new Board object.
|
| Field Attributes | Field Name and Description |
|---|---|
|
Alias of JXG.Board#on.
|
|
|
Stores all the objects that are currently running an animation.
|
|
| <constant> |
Board is in drag mode, objects aren't highlighted on mouse over and the object referenced in
{JXG.Board#mouse} is updated on mouse movement.
|
| <constant> |
In this mode a mouse move changes the origin's screen coordinates.
|
| <constant> |
Board is in no special mode, objects are highlighted on mouse over and objects may be
clicked to start drag&drop.
|
| <constant> |
Update is made with high quality, e.g.
|
| <constant> |
Update is made with high quality, e.g.
|
| <constant> |
Update is made with low quality, e.g.
|
|
Canvas Height
|
|
|
Canvas width.
|
|
|
The html-id of the html element containing the board.
|
|
|
Pointer to the html element containing the board.
|
|
|
Cached result of getCoordsTopLeftCorner for touch/mouseMove-Events to save some DOM operations.
|
|
|
Deprecated name for JXG.Board#create.
|
|
|
The current color blindness deficiency is stored in this property.
|
|
|
An array containing all other boards that are updated after this board has been updated.
|
|
|
Dimension of the board.
|
|
|
Pointer to the document element containing the board.
|
|
|
Collects all elements that triggered a mouse down event.
|
|
|
The distance from the mouse to the dragged object in x direction when the user clicked the mouse button.
|
|
|
The distance from the mouse to the dragged object in y direction when the user clicked the mouse button.
|
|
|
The last position where a drag event has been fired.
|
|
|
An associative array to store the objects of the board by name.
|
|
|
Holds the registered event handlers.
|
|
|
If GEONExT constructions are displayed, then this property should be set to true.
|
|
|
Grids keeps track of all grids attached to this board.
|
|
|
An associative array containing all groups belonging to the board.
|
|
|
This bool flag stores the current state of the mobile Safari specific gesture event handlers.
|
|
|
A flag which tells if the board registers mouse events.
|
|
|
A flag which tells if the board the JXG.Board#mouseUpListener is currently registered.
|
|
|
A flag which stores if the board registered pointer events.
|
|
|
A flag which tells us if the board has a pointerUp event registered at the moment.
|
|
|
A flag which tells if the board the JXG.Board#touchEndListener is currently registered.
|
|
|
A flag which tells if the board registers touch events.
|
|
|
An associative array containing all highlighted elements belonging to the board.
|
|
|
During the update process this is set to false to prevent an endless loop.
|
|
|
If true updates are skipped.
|
|
|
The board mode the board is currently in.
|
|
|
References to the object that is dragged with the mouse on the board.
|
|
|
Full updates are needed after zoom and axis translates.
|
|
|
Number of objects ever created on this board.
|
|
|
An associative array containing all geometric objects belonging to the board.
|
|
|
An array containing all geometric objects on the board in the order of construction.
|
|
|
Some standard options
|
|
|
Coordinates of the boards origin.
|
|
|
Contains the last time (epoch, msec) since the last getCoordsTopLeftCorner call which was not thrown away.
|
|
|
If reducedUpdate is set to true then only the dragged element and few (e.g.
|
|
|
Alias of JXG.Board#off.
|
|
|
A reference to this boards renderer.
|
|
|
Keeps track on touched elements, like JXG.Board#mouse does for mouse events.
|
|
|
Contains the last time (epoch, msec) since the last touchMove event which was not thrown away or since
touchStart because Android's Webkit browser fires too much of them.
|
|
|
The number of pixels which represent one unit in user-coordinates in x direction.
|
|
|
The number of pixels which represent one unit in user-coordinates in y direction.
|
|
|
The update quality of the board.
|
|
|
A string containing the XML text of the construction.
|
|
|
Zoom factor in X direction.
|
|
|
Zoom factor in Y direction.
|
| Method Attributes | Method Name and Description |
|---|---|
|
addAnimation(element)
Adds an animation.
|
|
|
addChild(board)
Adds a dependent board to this board.
|
|
|
addConditions(str)
Add conditional updates to the elements.
|
|
|
Add all possible event handlers to the board object
|
|
|
addGrid()
Adds a grid to the board according to the settings given in board.options.
|
|
|
addHook(hook, m, context)
Please use JXG.Board#on instead.
|
|
|
Registers mouse move, down and wheel event handlers.
|
|
|
Registers the MSPointer* event handlers.
|
|
|
addTouchEventHandlers(appleGestures)
Register touch start and move and gesture start and change event handlers.
|
|
|
animate()
General purpose animation function.
|
|
|
Apply update on all objects with the new zoom-factors.
|
|
|
Calculates adequate snap sizes.
|
|
|
Delete the elements drawn as part of a trace of an element.
|
|
|
Handler for click on down arrow in the navigation bar
|
|
|
Handler for click on left arrow in the navigation bar
|
|
|
Handler for click on right arrow in the navigation bar
|
|
|
Handler for click on up arrow in the navigation bar
|
|
|
create(elementType, parents, attributes)
Creates a new geometric element of type elementType.
|
|
|
createRoulette(c1, c2, start_c1, stepsize, direction, time, pointlist)
Function to animate a curve rolling on another curve.
|
|
|
Remove highlighting of all elements.
|
|
|
emulateColorblindness(deficiency)
Initializes color blindness simulation.
|
|
|
finalizeAdding(obj)
After construction of the object the visibility is set
and the label is constructed if necessary.
|
|
|
Runs through all elements and calls their update() method and update the conditions.
|
|
|
Generates unique id for a board.
|
|
|
generateName(object)
Generates an unique name for the given object.
|
|
|
Triggered on iOS/Safari while the user inputs a gesture (e.g.
|
|
|
gestureStartListener(evt)
Called by iOS/Safari as soon as the user starts a gesture (only works on iOS/Safari).
|
|
|
Collects all elements under current mouse position.
|
|
|
getAllUnderMouse(evt)
Collects all elements under current mouse position plus current user coordinates of mouse cursor.
|
|
|
Get the bounding box of the board.
|
|
|
Calculates mouse coordinates relative to the boards container.
|
|
|
getMousePosition(e, i)
Get the position of the mouse in screen coordinates, relative to the upper left corner
of the host tag.
|
|
|
getScrCoordsOfMouse(x, y)
Returns the input parameters in an array.
|
|
|
getUsrCoordsOfMouse(evt)
This method calculates the user coords of the current mouse coordinates.
|
|
|
hasPoint(x, y)
Checks if the given point is inside the boundingbox.
|
|
|
highlightCustomInfobox(text, el)
Changes the text of the info box to what is provided via text.
|
|
|
highlightInfobox(x, y, el)
Changes the text of the info box to show the given coordinates.
|
|
|
Initialize some objects which are contained in every GEONExT construction by default,
but are not contained in the gxt files.
|
|
|
Initialize the info box object which is used to display
the coordinates of points near the mouse pointer,
|
|
|
initMoveObject(x, y, evt, type)
Collects all elements below the current mouse pointer and fulfilling the following constraints:
|
|
|
initMoveOrigin(x, y)
Initiate moving the origin.
|
|
|
migratePoint(src, dest, copyName)
Migrate the dependency properties of the point src
to the point dest and delete the point src.
|
|
|
mouseDownListener(evt)
This method is called by the browser when the mouse button is clicked.
|
|
|
mouseMoveListener(evt)
This method is called by the browser when the mouse is moved.
|
|
|
mouseUpListener(evt)
This method is called by the browser when the mouse button is released.
|
|
|
mouseWheelListener(evt)
Handler for mouse wheel events.
|
|
|
moveObject(x, y, o, evt, type)
Moves an object.
|
|
|
moveOrigin(x, y, diff)
Moves the origin and initializes an update of all elements.
|
|
|
off(event, handler)
Unregister an event handler.
|
|
|
on(event, handler, context)
Register a new event handler.
|
|
|
pointerDownListener(evt, object)
This method is called by the browser when a pointing device is pressed on the screen.
|
|
|
pointerMoveListener(evt)
Called periodically by the browser while the user moves a pointing device across the screen.
|
|
|
pointerUpListener(evt)
Triggered as soon as the user stops touching the device with at least one finger.
|
|
|
Sets for all objects the needsUpdate flag to "true".
|
|
|
removeAncestors(object)
Removes the ancestors of an object an the object itself from board and renderer.
|
|
|
removeChild(board)
Deletes a board from the list of dependent boards.
|
|
|
Remove all event handlers from the board object
|
|
|
Removes all grids assigned to this board.
|
|
|
removeHook(id)
Please use JXG.Board#off instead.
|
|
|
De-register mouse event handlers.
|
|
|
removeObject(object)
Removes object from board and renderer.
|
|
|
Remove MSPointer* Event handlers.
|
|
|
Remove all registered touch event handlers.
|
|
|
resizeContainer(canvasWidth, canvasHeight, dontset)
Change the height and width of the board's container.
|
|
| <private> |
saveStartPos(obj, targets)
Helper function which returns a reasonable starting point for the object being dragged.
|
|
select(str)
Select a single or multiple elements at once.
|
|
|
setBoundingBox(bbox, keepaspectratio)
Set the bounding box of the board.
|
|
|
setId(obj, type)
Composes an id for an element.
|
|
|
setZoom(fX, fY)
Sets the zoom level to fX resp fY.
|
|
|
Lists the dependencies graph in a new HTML-window.
|
|
|
showXML()
Lists the XML code of the construction in a new HTML-window.
|
|
|
Cancels all running animations.
|
|
|
Stop updates of the board.
|
|
|
touchEndListener(evt)
Triggered as soon as the user stops touching the device with at least one finger.
|
|
|
touchMoveListener(evt)
Called periodically by the browser while the user moves his fingers across the device.
|
|
|
touchStartListener(evt)
This method is called by the browser when a finger touches the surface of the touch-device.
|
|
|
triggerEventHandlers(event, args)
Triggers all event handlers of this element for a given event.
|
|
|
twoFingerMove(p1, p2, o, evt)
Moves elements in multitouch mode.
|
|
|
twoFingerTouchObject(np1c, np2c, o, drag)
Moves a line or polygon with two fingers
|
|
|
Enable updates of the board.
|
|
|
update(drag)
Runs through most elements and calls their update() method and update the conditions.
|
|
|
updateConditions()
|
|
|
Update the coords object of all elements which possess this
property.
|
|
|
Update CSS transformations of sclaing type.
|
|
|
updateElements(drag)
Runs through all elements and calls their update() method.
|
|
|
updateHooks(m)
Runs through all hooked functions and calls them.
|
|
|
updateInfobox(el)
Updates and displays a little info box to show coordinates of current selected points.
|
|
|
Runs through all elements and calls their update() method.
|
|
|
Runs through all elements and calls their update() method.
|
|
|
zoom100()
Resets zoom factor to 100%.
|
|
|
Zooms the board so every visible point is shown.
|
|
|
zoomElements(elements)
Reset the bounding box and the zoom level to 100% such that a given set of elements is within the board's viewport.
|
|
|
zoomIn(x, y)
Zooms into the board by the factors board.attr.zoom.factorX and board.attr.zoom.factorY and applies the zoom.
|
|
|
zoomOut(x, y)
Zooms out of the board by the factors board.attr.zoom.factorX and board.attr.zoom.factorY and applies the zoom.
|
| Event Attributes | Event Name and Description |
|---|---|
|
The bounding box of the board has changed.
|
|
|
down(e)
Whenever the user starts to touch or click the board.
|
|
|
hit(e, el, target)
Whenever an element is highlighted this event is fired.
|
|
|
mousedown(e)
Whenever the user starts to click on the board.
|
|
|
mousehit(e, el, target)
Whenever an element is highlighted this event is fired.
|
|
|
mousemove(e, mode)
This event is fired whenever the user is moving the mouse over the board.
|
|
|
mouseup(e)
Whenever the user releases the mousebutton over the board.
|
|
|
move(e, mode)
This event is fired whenever the user is moving the finger or mouse pointer over the board.
|
|
|
touchend(e)
Whenever the user stops touching the board.
|
|
|
touchmove(e, mode)
This event is fired whenever the user is moving the finger over the board.
|
|
|
touchstart(e)
Whenever the user starts to touch the board.
|
|
|
up(e)
Whenever the user stops to touch or click the board.
|
|
|
update()
This board is updated.
|
Class Detail
JXG.Board(container, renderer, id, origin, zoomX, zoomY, unitX, unitY, canvasWidth, canvasHeight, attributes)
Constructs a new Board object.
- Parameters:
- {String} container
- The id or reference of the HTML DOM element the board is drawn in. This is usually a HTML div.
- {JXG.AbstractRenderer} renderer
- The reference of a renderer.
- {String} id
- Unique identifier for the board, may be an empty string or null or even undefined.
- {JXG.Coords} origin
- The coordinates where the origin is placed, in user coordinates.
- {Number} zoomX
- Zoom factor in x-axis direction
- {Number} zoomY
- Zoom factor in y-axis direction
- {Number} unitX
- Units in x-axis direction
- {Number} unitY
- Units in y-axis direction
- {Number} canvasWidth
- The width of canvas
- {Number} canvasHeight
- The height of canvas
- {Object} attributes
- The attributes object given to JXG.JSXGraph#initBoard
Field Detail
addEvent
Alias of JXG.Board#on.
{Object}
animationObjects
Stores all the objects that are currently running an animation.
<constant>
{Number}
BOARD_MODE_DRAG
Board is in drag mode, objects aren't highlighted on mouse over and the object referenced in
{JXG.Board#mouse} is updated on mouse movement.
- See:
- JXG.Board#drag_obj
<constant>
{Number}
BOARD_MODE_MOVE_ORIGIN
In this mode a mouse move changes the origin's screen coordinates.
<constant>
{Number}
BOARD_MODE_NONE
Board is in no special mode, objects are highlighted on mouse over and objects may be
clicked to start drag&drop.
<constant>
{Number}
BOARD_MODE_ZOOM
Update is made with high quality, e.g. graphs are evaluated at much more points.
<constant>
{Number}
BOARD_QUALITY_HIGH
Update is made with high quality, e.g. graphs are evaluated at much more points.
<constant>
{Number}
BOARD_QUALITY_LOW
Update is made with low quality, e.g. graphs are evaluated at a lesser amount of points.
{Number}
canvasHeight
Canvas Height
{Number}
canvasWidth
Canvas width.
{String}
container
The html-id of the html element containing the board.
{Object}
containerObj
Pointer to the html element containing the board.
{Array}
cPos
Cached result of getCoordsTopLeftCorner for touch/mouseMove-Events to save some DOM operations.
createElement
Deprecated name for JXG.Board#create.
currentCBDef
The current color blindness deficiency is stored in this property. If color blindness is not emulated
at the moment, it's value is 'none'.
{Array}
dependentBoards
An array containing all other boards that are updated after this board has been updated.
{Number}
dimension
Dimension of the board.
- Default Value:
- 2
{Object}
document
Pointer to the document element containing the board.
{Array}
downObjects
Collects all elements that triggered a mouse down event.
{Number}
drag_dx
The distance from the mouse to the dragged object in x direction when the user clicked the mouse button.
- See:
- JXG.Board#drag_dy
- JXG.Board#drag_obj
{Number}
drag_dy
The distance from the mouse to the dragged object in y direction when the user clicked the mouse button.
- See:
- JXG.Board#drag_dx
- JXG.Board#drag_obj
{Array}
drag_position
The last position where a drag event has been fired.
- See:
- JXG.Board#moveObject
{Object}
elementsByName
An associative array to store the objects of the board by name. the name of the object is the key and value is a reference to the object.
{Object}
eventHandlers
Holds the registered event handlers.
Defined in: event.js.
Defined in: event.js.
{Boolean}
geonextCompatibilityMode
If GEONExT constructions are displayed, then this property should be set to true.
At the moment there should be no difference. But this may change.
This is set in JXG.GeonextReader#readGeonext.
- See:
- JXG.GeonextReader#readGeonext
- Default Value:
- false
grids
Grids keeps track of all grids attached to this board.
{Object}
groups
An associative array containing all groups belonging to the board. Key is the id of the group and value is a reference to the object.
hasGestureHandlers
This bool flag stores the current state of the mobile Safari specific gesture event handlers.
- Default Value:
- false
{Boolean}
hasMouseHandlers
A flag which tells if the board registers mouse events.
- Default Value:
- false
{Boolean}
hasMouseUp
A flag which tells if the board the JXG.Board#mouseUpListener is currently registered.
- Default Value:
- false
hasPointerHandlers
A flag which stores if the board registered pointer events.
- Default Value:
- false
hasPointerUp
A flag which tells us if the board has a pointerUp event registered at the moment.
- Default Value:
- false
{Boolean}
hasTouchEnd
A flag which tells if the board the JXG.Board#touchEndListener is currently registered.
- Default Value:
- false
{Boolean}
hasTouchHandlers
A flag which tells if the board registers touch events.
- Default Value:
- false
{Object}
highlightedObjects
An associative array containing all highlighted elements belonging to the board.
{Boolean}
inUpdate
During the update process this is set to false to prevent an endless loop.
- Default Value:
- false
{Boolean}
isSuspendedRedraw
If true updates are skipped.
{Number}
mode
The board mode the board is currently in. Possible values are
- JXG.Board.BOARD_MODE_NONE
- JXG.Board.BOARD_MODE_DRAG
- JXG.Board.BOARD_MODE_MOVE_ORIGIN
{.}
mouse
References to the object that is dragged with the mouse on the board.
- See:
{Boolean}
needsFullUpdate
Full updates are needed after zoom and axis translates. This saves some time during an update.
- Default Value:
- false
{Number}
numObjects
Number of objects ever created on this board. This includes every object, even invisible and deleted ones.
{Object}
objects
An associative array containing all geometric objects belonging to the board. Key is the id of the object and value is a reference to the object.
objectsList
An array containing all geometric objects on the board in the order of construction.
{JXG.Options}
options
Some standard options
{Object}
origin
Coordinates of the boards origin. This a object with the two properties
usrCoords and scrCoords. usrCoords always equals [1, 0, 0] and scrCoords
stores the boards origin in homogeneous screen coordinates.
{Number}
positionAccessLast
Contains the last time (epoch, msec) since the last getCoordsTopLeftCorner call which was not thrown away.
{Boolean}
reducedUpdate
If reducedUpdate is set to true then only the dragged element and few (e.g. 2) following
elements are updated during mouse move. On mouse up the whole construction is
updated. This enables us to be fast even on very slow devices.
- Default Value:
- false
removeEvent
Alias of JXG.Board#off.
{JXG.AbstractRenderer}
renderer
A reference to this boards renderer.
{Array}
touches
Keeps track on touched elements, like JXG.Board#mouse does for mouse events.
- See:
{Number}
touchMoveLast
Contains the last time (epoch, msec) since the last touchMove event which was not thrown away or since
touchStart because Android's Webkit browser fires too much of them.
{Number}
unitX
The number of pixels which represent one unit in user-coordinates in x direction.
{Number}
unitY
The number of pixels which represent one unit in user-coordinates in y direction.
{Number}
updateQuality
The update quality of the board. In most cases this is set to JXG.Board#BOARD_QUALITY_HIGH.
If JXG.Board#mode equals JXG.Board#BOARD_MODE_DRAG this is set to
JXG.Board#BOARD_QUALITY_LOW to speed up the update process by e.g. reducing the number of
evaluation points when plotting functions. Possible values are
- BOARD_QUALITY_LOW
- BOARD_QUALITY_HIGH
- See:
- JXG.Board#mode
{String}
xmlString
A string containing the XML text of the construction. This is set in JXG.FileReader#parseString.
Only useful if a construction is read from a GEONExT-, Intergeo-, Geogebra-, or Cinderella-File.
{Number}
zoomX
Zoom factor in X direction. It only stores the zoom factor to be able
to get back to 100% in zoom100().
{Number}
zoomY
Zoom factor in Y direction. It only stores the zoom factor to be able
to get back to 100% in zoom100().
Method Detail
{JXG.Board}
addAnimation(element)
Adds an animation. Animations are controlled by the boards, so the boards need to be aware of the
animated elements. This function tells the board about new elements to animate.
- Parameters:
- {JXG.GeometryElement} element
- The element which is to be animated.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
addChild(board)
Adds a dependent board to this board.
- Parameters:
- {JXG.Board} board
- A reference to board which will be updated after an update of this board occured.
- Returns:
- {JXG.Board} Reference to the board
addConditions(str)
Add conditional updates to the elements.
- Parameters:
- {String} str
- String containing coniditional update in geonext syntax
addEventHandlers()
Add all possible event handlers to the board object
{JXG.Board}
addGrid()
Adds a grid to the board according to the settings given in board.options.
- Returns:
- {JXG.Board} Reference to the board.
{Number}
addHook(hook, m, context)
Please use JXG.Board#on instead.
- Parameters:
- {Function} hook
- A function to be called by the board after an update occured.
- {String} m Optional, Default: 'update'
- When the hook is to be called. Possible values are mouseup, mousedown and update.
- {Object} context Optional, Default: board
- Determines the execution context the hook is called. This parameter is optional, default is the board object the hook is attached to.
- Returns:
- {Number} Id of the hook, required to remove the hook from the board.
addMouseEventHandlers()
Registers mouse move, down and wheel event handlers.
addPointerEventHandlers()
Registers the MSPointer* event handlers.
addTouchEventHandlers(appleGestures)
Register touch start and move and gesture start and change event handlers.
- Parameters:
- {Boolean} appleGestures
- If set to false the gesturestart and gesturechange event handlers will not be registered.
{JXG.Board}
animate()
General purpose animation function. This currently only supports moving points from one place to another. This
is faster than managing the animation per point, especially if there is more than one animated point at the same time.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
applyZoom()
Apply update on all objects with the new zoom-factors. Clears all traces.
- Returns:
- {JXG.Board} Reference to the board.
{JXG.Board}
calculateSnapSizes()
Calculates adequate snap sizes.
- Returns:
- {JXG.Board} Reference to the board.
{JXG.Board}
clearTraces()
Delete the elements drawn as part of a trace of an element.
- Returns:
- {JXG.Board} Reference to the board
clickDownArrow()
Handler for click on down arrow in the navigation bar
clickLeftArrow()
Handler for click on left arrow in the navigation bar
clickRightArrow()
Handler for click on right arrow in the navigation bar
clickUpArrow()
Handler for click on up arrow in the navigation bar
{Object}
create(elementType, parents, attributes)
Creates a new geometric element of type elementType.
- Parameters:
- {String} elementType
- Type of the element to be constructed given as a string e.g. 'point' or 'circle'.
- {Array} parents
- Array of parent elements needed to construct the element e.g. coordinates for a point or two points to construct a line. This highly depends on the elementType that is constructed. See the corresponding JXG.create* methods for a list of possible parameters.
- {Object} attributes Optional
- An object containing the attributes to be set. This also depends on the elementType. Common attributes are name, visible, strokeColor.
- Returns:
- {Object} Reference to the created element. This is usually a GeometryElement, but can be an array containing two or more elements.
createRoulette(c1, c2, start_c1, stepsize, direction, time, pointlist)
Function to animate a curve rolling on another curve.
- Parameters:
- {Curve} c1
- JSXGraph curve building the floor where c2 rolls
- {Curve} c2
- JSXGraph curve which rolls on c1.
- {number} start_c1
- The parameter t such that c1(t) touches c2. This is the start position of the rolling process
- {Number} stepsize
- Increase in t in each step for the curve c1
- {Number} direction
- {Number} time
- Delay time for setInterval()
- {Array} pointlist
- Array of points which are rolled in each step. This list should contain all points which define c2 and gliders on c2.
- Examples:
// Line which will be the floor to roll upon. var line = brd.create('curve', [function (t) { return t;}, function (t){ return 1;}], {strokeWidth:6}); // Center of the rolling circle var C = brd.create('point',[0,2],{name:'C'}); // Starting point of the rolling circle var P = brd.create('point',[0,1],{name:'P', trace:true}); // Circle defined as a curve. The circle "starts" at P, i.e. circle(0) = P var circle = brd.create('curve',[ function (t){var d = P.Dist(C), beta = JXG.Math.Geometry.rad([C.X()+1,C.Y()],C,P); t += beta; return C.X()+d*Math.cos(t); }, function (t){var d = P.Dist(C), beta = JXG.Math.Geometry.rad([C.X()+1,C.Y()],C,P); t += beta; return C.Y()+d*Math.sin(t); }, 0,2*Math.PI], {strokeWidth:6, strokeColor:'green'}); // Point on circle var B = brd.create('glider',[0,2,circle],{name:'B', color:'blue',trace:false}); var roll = brd.createRoulette(line, circle, 0, Math.PI/20, 1, 100, [C,P,B]); roll.start() // Start the rolling, to be stopped by roll.stop()
{JXG.Board}
dehighlightAll()
Remove highlighting of all elements.
- Returns:
- {JXG.Board} Reference to the board.
{JXG.Board}
emulateColorblindness(deficiency)
Initializes color blindness simulation.
- Parameters:
- {String} deficiency
- Describes the color blindness deficiency which is simulated. Accepted values are 'protanopia', 'deuteranopia', and 'tritanopia'.
- Returns:
- {JXG.Board} Reference to the board
finalizeAdding(obj)
After construction of the object the visibility is set
and the label is constructed if necessary.
- Parameters:
- {Object} obj
- The object to add.
{JXG.Board}
fullUpdate()
Runs through all elements and calls their update() method and update the conditions.
This is necessary after zooming and changing the bounding box.
- Returns:
- {JXG.Board} Reference to the board
{String}
generateId()
Generates unique id for a board. The result is randomly generated and prefixed with 'jxgBoard'.
- Returns:
- {String} Unique id for a board.
{String}
generateName(object)
Generates an unique name for the given object. The result depends on the objects type, if the
object is a JXG.Point, capital characters are used, if it is of type JXG.Line
only lower case characters are used. If object is of type JXG.Polygon, a bunch of lower
case characters prefixed with P_ are used. If object is of type JXG.Circle the name is
generated using lower case characters. prefixed with k_ is used. In any other case, lower case
chars prefixed with s_ is used.
- Parameters:
- {Object} object
- Reference of an JXG.GeometryElement that is to be named.
- Returns:
- {String} Unique name for the object.
{Boolean}
gestureChangeListener(evt)
Triggered on iOS/Safari while the user inputs a gesture (e.g. pinch) and is used to zoom into the board. Only works on iOS/Safari.
- Parameters:
- {Event} evt
- Browser event object
- Returns:
- {Boolean}
{Boolean}
gestureStartListener(evt)
Called by iOS/Safari as soon as the user starts a gesture (only works on iOS/Safari).
- Parameters:
- {Event} evt
- Returns:
- {Boolean}
{Array}
getAllObjectsUnderMouse(evt)
Collects all elements under current mouse position.
- Parameters:
- {Event} evt
- Event object containing the mouse coordinates.
- Returns:
- {Array} Array of elements at the current mouse position.
{Array}
getAllUnderMouse(evt)
Collects all elements under current mouse position plus current user coordinates of mouse cursor.
- Parameters:
- {Event} evt
- Event object containing the mouse coordinates.
- Returns:
- {Array} Array of elements at the current mouse position plus current user coordinates of mouse.
{Array}
getBoundingBox()
Get the bounding box of the board.
- Returns:
- {Array} bounding box [x1,y1,x2,y2] upper left corner, lower right corner
{Array}
getCoordsTopLeftCorner()
Calculates mouse coordinates relative to the boards container.
- Returns:
- {Array} Array of coordinates relative the boards container top left corner.
{Array}
getMousePosition(e, i)
Get the position of the mouse in screen coordinates, relative to the upper left corner
of the host tag.
- Parameters:
- {Event} e
- Event object given by the browser.
- {Number} i Optional
- Only use in case of touch events. This determines which finger to use and should not be set for mouseevents.
- Returns:
- {Array} Contains the mouse coordinates in user coordinates, ready for JXG.Coords
{Array}
getScrCoordsOfMouse(x, y)
Returns the input parameters in an array. This method looks pointless and it really is, but it had a purpose
once.
- Parameters:
- {Number} x
- X coordinate in screen coordinates
- {Number} y
- Y coordinate in screen coordinates
- Returns:
- {Array} Coordinates of the mouse in screen coordinates.
{Array}
getUsrCoordsOfMouse(evt)
This method calculates the user coords of the current mouse coordinates.
- Parameters:
- {Event} evt
- Event object containing the mouse coordinates.
- Returns:
- {Array} Coordinates of the mouse in screen coordinates.
{Boolean}
hasPoint(x, y)
Checks if the given point is inside the boundingbox.
- Parameters:
- {Number|JXG.Coords} x
- User coordinate or JXG.Coords object.
- {Number} y Optional
- User coordinate. May be omitted in case x is a JXG.Coords object.
- Returns:
- {Boolean}
{JXG.Board}
highlightCustomInfobox(text, el)
Changes the text of the info box to what is provided via text.
- Parameters:
- {String} text
- {JXG.GeometryElement} el Optional
- Returns:
- {JXG.Board} Reference to the board.
{JXG.Board}
highlightInfobox(x, y, el)
Changes the text of the info box to show the given coordinates.
- Parameters:
- {Number} x
- {Number} y
- {JXG.GeometryElement} el Optional
- The element the mouse is pointing at
- Returns:
- {JXG.Board} Reference to the board.
{JXG.Board}
initGeonextBoard()
Initialize some objects which are contained in every GEONExT construction by default,
but are not contained in the gxt files.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
initInfobox()
Initialize the info box object which is used to display
the coordinates of points near the mouse pointer,
- Returns:
- {JXG.Board} Reference to the board
{Array}
initMoveObject(x, y, evt, type)
Collects all elements below the current mouse pointer and fulfilling the following constraints:
- isDraggable
- visible
- not fixed
- not frozen
- Parameters:
- {Number} x
- Current mouse/touch coordinates
- {Number} y
- current mouse/touch coordinates
- {Object} evt
- An event object
- {String} type
- What type of event? 'touch' or 'mouse'.
- Returns:
- {Array} A list of geometric elements.
initMoveOrigin(x, y)
Initiate moving the origin. This is used in mouseDown and touchStart listeners.
- Parameters:
- {Number} x
- Current mouse/touch coordinates
- {Number} y
- Current mouse/touch coordinates
{JXG.Board}
migratePoint(src, dest, copyName)
Migrate the dependency properties of the point src
to the point dest and delete the point src.
For example, a circle around the point src
receives the new center dest. The old center src
will be deleted.
- Parameters:
- {JXG.Point} src
- Original point which will be deleted
- {JXG.Point} dest
- New point with the dependencies of src.
- {Boolean} copyName
- Flag which decides if the name of the src element is copied to the dest element.
- Returns:
- {JXG.Board} Reference to the board
{Boolean}
mouseDownListener(evt)
This method is called by the browser when the mouse button is clicked.
- Parameters:
- {Event} evt
- The browsers event object.
- Returns:
- {Boolean} True if no element is found under the current mouse pointer, false otherwise.
mouseMoveListener(evt)
This method is called by the browser when the mouse is moved.
- Parameters:
- {Event} evt
- The browsers event object.
mouseUpListener(evt)
This method is called by the browser when the mouse button is released.
- Parameters:
- {Event} evt
{Boolean}
mouseWheelListener(evt)
Handler for mouse wheel events. Used to zoom in and out of the board.
- Parameters:
- {Event} evt
- Returns:
- {Boolean}
moveObject(x, y, o, evt, type)
Moves an object.
- Parameters:
- {Number} x
- Coordinate
- {Number} y
- Coordinate
- {Object} o
- The touch object that is dragged: {JXG.Board#mouse} or {JXG.Board#touches}.
- {Object} evt
- The event object.
- {String} type
- Mouse or touch event?
{JXG.Board}
moveOrigin(x, y, diff)
Moves the origin and initializes an update of all elements.
- Parameters:
- {Number} x
- {Number} y
- {Boolean} diff Optional, Default: false
- Returns:
- {JXG.Board} Reference to this board.
off(event, handler)
Unregister an event handler.
Defined in: event.js.
Defined in: event.js.
- Parameters:
- {String} event
- {Function} handler Optional
- Returns:
- Reference to the object.
on(event, handler, context)
Register a new event handler. For a list of possible events see documentation of the elements and objects implementing
the EventEmitter interface.
Defined in: event.js.
Defined in: event.js.
- Parameters:
- {String} event
- {Function} handler
- {Object} context Optional
- The context the handler will be called in, default is the element itself.
- Returns:
- Reference to the object.
{Boolean}
pointerDownListener(evt, object)
This method is called by the browser when a pointing device is pressed on the screen.
- Parameters:
- {Event} evt
- The browsers event object.
- {Object} object
- If the object to be dragged is already known, it can be submitted via this parameter
- Returns:
- {Boolean} ...
{Boolean}
pointerMoveListener(evt)
Called periodically by the browser while the user moves a pointing device across the screen.
- Parameters:
- {Event} evt
- Returns:
- {Boolean}
{Boolean}
pointerUpListener(evt)
Triggered as soon as the user stops touching the device with at least one finger.
- Parameters:
- {Event} evt
- Returns:
- {Boolean}
{JXG.Board}
prepareUpdate()
Sets for all objects the needsUpdate flag to "true".
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
removeAncestors(object)
Removes the ancestors of an object an the object itself from board and renderer.
- Parameters:
- {JXG.GeometryElement} object
- The object to remove.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
removeChild(board)
Deletes a board from the list of dependent boards.
- Parameters:
- {JXG.Board} board
- Reference to the board which will be removed.
- Returns:
- {JXG.Board} Reference to the board
removeEventHandlers()
Remove all event handlers from the board object
{JXG.Board}
removeGrids()
Removes all grids assigned to this board. Warning: This method also removes all objects depending on one or
more of the grids.
- Returns:
- {JXG.Board} Reference to the board object.
{JXG.Board}
removeHook(id)
Please use JXG.Board#off instead.
- Parameters:
- {Number|function} id
- The number you got when you added the hook or a reference to the event handler.
- Returns:
- {JXG.Board} Reference to the board
removeMouseEventHandlers()
De-register mouse event handlers.
{JXG.Board}
removeObject(object)
Removes object from board and renderer.
- Parameters:
- {JXG.GeometryElement} object
- The object to remove.
- Returns:
- {JXG.Board} Reference to the board
removePointerEventHandlers()
Remove MSPointer* Event handlers.
removeTouchEventHandlers()
Remove all registered touch event handlers.
{JXG.Board}
resizeContainer(canvasWidth, canvasHeight, dontset)
Change the height and width of the board's container.
- Parameters:
- {Number} canvasWidth
- New width of the container.
- {Number} canvasHeight
- New height of the container.
- {Boolean} dontset Optional, Default: false
- Do not set the height of the DOM element.
- Returns:
- {JXG.Board} Reference to the board
<private>
saveStartPos(obj, targets)
Helper function which returns a reasonable starting point for the object being dragged.
Formerly known as initXYstart().
- Parameters:
- {JXG.GeometryElement} obj
- The object to be dragged
- {Array} targets
- Array of targets. It is changed by this function.
{JXG.GeometryElement|JXG.Composition}
select(str)
Select a single or multiple elements at once.
- Parameters:
- {String|Object|function} str
- The name, id or a reference to a JSXGraph element on this board. An object will be used as a filter to return multiple elements at once filtered by the properties of the object.
- Returns:
- {JXG.GeometryElement|JXG.Composition}
- Examples:
// select the element with name A board.select('A'); // select all elements with strokecolor set to 'red' (but not '#ff0000') board.select({ strokeColor: 'red' }); // select all points on or below the x axis and make them black. board.select({ elementClass: JXG.OBJECT_CLASS_POINT, Y: function (v) { return v <= 0; } }).setAttribute({color: 'black'}); // select all elements board.select(function (el) { return true; });
{JXG.Board}
setBoundingBox(bbox, keepaspectratio)
Set the bounding box of the board.
- Parameters:
- {Array} bbox
- New bounding box [x1,y1,x2,y2]
- {Boolean} keepaspectratio Optional, Default: false
- If set to true, the aspect ratio will be 1:1, but the resulting viewport may be larger.
- Returns:
- {JXG.Board} Reference to the board
{String}
setId(obj, type)
Composes an id for an element. If the ID is empty ('' or null) a new ID is generated, depending on the
object type. Additionally, the id of the label is set. As a side effect JXG.Board#numObjects
is updated.
- Parameters:
- {Object} obj
- Reference of an geometry object that needs an id.
- {Number} type
- Type of the object.
- Returns:
- {String} Unique id for an element.
{JXG.Board}
setZoom(fX, fY)
Sets the zoom level to fX resp fY.
- Parameters:
- {Number} fX
- {Number} fY
- Returns:
- {JXG.Board}
{JXG.Board}
showDependencies()
Lists the dependencies graph in a new HTML-window.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
showXML()
Lists the XML code of the construction in a new HTML-window.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
stopAllAnimation()
Cancels all running animations.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
suspendUpdate()
Stop updates of the board.
- Returns:
- {JXG.Board} Reference to the board
{Boolean}
touchEndListener(evt)
Triggered as soon as the user stops touching the device with at least one finger.
- Parameters:
- {Event} evt
- Returns:
- {Boolean}
{Boolean}
touchMoveListener(evt)
Called periodically by the browser while the user moves his fingers across the device.
- Parameters:
- {Event} evt
- Returns:
- {Boolean}
{Boolean}
touchStartListener(evt)
This method is called by the browser when a finger touches the surface of the touch-device.
- Parameters:
- {Event} evt
- The browsers event object.
- Returns:
- {Boolean} ...
triggerEventHandlers(event, args)
Triggers all event handlers of this element for a given event.
Defined in: event.js.
Defined in: event.js.
- Parameters:
- {Array} event
- {Array} args
- The arguments passed onto the event handler
- Returns:
- Reference to the object.
twoFingerMove(p1, p2, o, evt)
Moves elements in multitouch mode.
- Parameters:
- {Array} p1
- x,y coordinates of first touch
- {Array} p2
- x,y coordinates of second touch
- {Object} o
- The touch object that is dragged: {JXG.Board#touches}.
- {Object} evt
- The event object that lead to this movement.
twoFingerTouchObject(np1c, np2c, o, drag)
Moves a line or polygon with two fingers
- Parameters:
- {JXG.Coords} np1c
- x,y coordinates of first touch
- {JXG.Coords} np2c
- x,y coordinates of second touch
- {object} o
- The touch object that is dragged: {JXG.Board#touches}.
- {object} drag
- The object that is dragged:
{JXG.Board}
unsuspendUpdate()
Enable updates of the board.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
update(drag)
Runs through most elements and calls their update() method and update the conditions.
- Parameters:
- {JXG.GeometryElement} drag Optional
- Element that caused the update.
- Returns:
- {JXG.Board} Reference to the board
updateConditions()
{JXG.Board}
updateCoords()
Update the coords object of all elements which possess this
property. This is necessary after changing the viewport.
- Returns:
- {JXG.Board} Reference to this board.
updateCSSTransforms()
Update CSS transformations of sclaing type. It is used to correct the mouse position
in JXG.Board#getMousePosition.
The inverse transformation matrix is updated on each mouseDown and touchStart event.
It is up to the user to call this method after an update of the CSS transformation
in the DOM.
{JXG.Board}
updateElements(drag)
Runs through all elements and calls their update() method.
- Parameters:
- {JXG.GeometryElement} drag
- Element that caused the update.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
updateHooks(m)
Runs through all hooked functions and calls them.
- Parameters:
- m
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
updateInfobox(el)
Updates and displays a little info box to show coordinates of current selected points.
- Parameters:
- {JXG.GeometryElement} el
- A GeometryElement
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
updateRenderer()
Runs through all elements and calls their update() method.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
updateRendererCanvas()
Runs through all elements and calls their update() method.
This is a special version for the CanvasRenderer.
Here, we have to do our own layer handling.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
zoom100()
Resets zoom factor to 100%.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
zoomAllPoints()
Zooms the board so every visible point is shown. Keeps aspect ratio.
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
zoomElements(elements)
Reset the bounding box and the zoom level to 100% such that a given set of elements is within the board's viewport.
- Parameters:
- {Array} elements
- A set of elements given by id, reference, or name.
- Returns:
- {JXG.Board} Reference to the board.
{JXG.Board}
zoomIn(x, y)
Zooms into the board by the factors board.attr.zoom.factorX and board.attr.zoom.factorY and applies the zoom.
- Parameters:
- {Number} x Optional
- {Number} y Optional
- Returns:
- {JXG.Board} Reference to the board
{JXG.Board}
zoomOut(x, y)
Zooms out of the board by the factors board.attr.zoom.factorX and board.attr.zoom.factorY and applies the zoom.
- Parameters:
- {Number} x Optional
- {Number} y Optional
- Returns:
- {JXG.Board} Reference to the board
Event Detail
boundingbox()
The bounding box of the board has changed.
down(e)
Whenever the user starts to touch or click the board.
- Parameters:
- {Event} e
- The browser's event object.
hit(e, el, target)
Whenever an element is highlighted this event is fired.
- Parameters:
- {Event} e
- The browser's event object.
- {JXG.GeometryElement} el
- The hit element.
- target
mousedown(e)
Whenever the user starts to click on the board.
- Parameters:
- {Event} e
- The browser's event object.
mousehit(e, el, target)
Whenever an element is highlighted this event is fired.
- Parameters:
- {Event} e
- The browser's event object.
- {JXG.GeometryElement} el
- The hit element.
- target
mousemove(e, mode)
This event is fired whenever the user is moving the mouse over the board.
- Parameters:
- {Event} e
- The browser's event object.
- {Number} mode
- The mode the board currently is in
- See:
mouseup(e)
Whenever the user releases the mousebutton over the board.
- Parameters:
- {Event} e
- The browser's event object.
move(e, mode)
This event is fired whenever the user is moving the finger or mouse pointer over the board.
- Parameters:
- {Event} e
- The browser's event object.
- {Number} mode
- The mode the board currently is in
- See:
touchend(e)
Whenever the user stops touching the board.
- Parameters:
- {Event} e
- The browser's event object.
touchmove(e, mode)
This event is fired whenever the user is moving the finger over the board.
- Parameters:
- {Event} e
- The browser's event object.
- {Number} mode
- The mode the board currently is in
- See:
touchstart(e)
Whenever the user starts to touch the board.
- Parameters:
- {Event} e
- The browser's event object.
up(e)
Whenever the user stops to touch or click the board.
- Parameters:
- {Event} e
- The browser's event object.
update()
This board is updated.


AngularJS Sample Application for: DOM » ng-if
Click me:
Show when checked:
This is removed when the checkbox is unchecked.


Ans) Batches 4-5 p.m. and 5:30 to 6:30 p.m. every Friday and Saturday.
Ans) Landscape, human figures, sketches, animal drawing, object drawing, still life, portraits, flowers and craft items– this is the general course of the topics taught for all age groups.
Ans) Pencil sketching, pencil shading, oil pastels, watercolors, poster colors, acrylic, oil paints (on canvas), ceramic paints, fabric paints.
Ans) Yes, Summer camp during months May-June and Winter camp during December. All age groups are accommodated in two different batches based on number of students and timing preference.


Fecha_Creacion: 2017-11-18T11:31:15.248Z
Dimension: Fantasy Dimension
Id_Locacion: 14
Nombre: Giant's Town
Residentes: ['https://rickandmortyapi.com/api/character/89', 'https://rickandmortyapi.com/api/character/399', 'https://rickandmortyapi.com/api/character/400']
Tipo: Fantasy town
URL: https://rickandmortyapi.com/api/location/14


Redux like state management in a minute
This page demonstrates using ReactContextRedux
ReactContextRedux uses React16's context API


SODO Urbanworks (Formerly City Commerce Business Park) is a multi-tenant property located in the heart of South Seattle. The park’s eclectic mix of tenants and spaces reflects the old-world industry and progressive urban renewal that characterize the SODO neighborhood.
See Available Spaces >


django-treasurehunt is an online treasure hunt engine built using Django.
Okay, but what exactly is an online treasure hunt?
An online treasure hunt is one type of treasure hunt where players or treasure hunters search for answers to the questions given online. The answers or clues can be hidden anywhere on the Internet. Players use clues and hints given along with the question to get the answer. Once they enter the correct answer they are presented with the next question until they have finished all the questions. The players who complete all the questions


Rules
- The goal is to reach 100 points.The first player to reach 100 points wins
- The players should then decide on how many times each will roll e.g 3times of 4times
- If a player roles 1 is turn ends and the 1 will not be added to the total
- When a player reaches a total of 100 or more points, the game ends and that player is the winner.
Result
Player 1
Dice roll is:
Total is:
Player 2
Dice roll is:
Total is:


 Chambers is fine as Rose, even though her sexual abilities are put under constraints by the conservative nature of the script. She plays a carefree, attractive girl who gets into a motorcycle accident while on an isolated road outside of Montreal, with her boyfriend Hart (Frank Moore) responsible for the accident. It results in a botched plastic surgery job for her, as she is taken to the nearby private Keloid Clinic, run by plastic surgeons Dan and Roxanne Keloid (Howard Ryshpan and Patricia Gage) and their business partner Murray Cypher (Joel Silver), who is seen talking to the doctors about becoming a plastic surgery franchise just as the accident is taking place. Because Rose is in critical condition and will probably die in a short time, Keloid does an emergency experimental procedure to try and save her, a radical grafting of her thigh tissue, inducing a morphogenic, which means that there is the ability to form any kind of tissue in her system. The side effect that occurs is freaky indeed -- she develops a fanged phallus under her armpit. With this new organism, she has the urge to bite her victim and draw blood from them to get nourishment and she thereby infects them with an incurable type of unknown rabies, whereby the victim forgets what happened and becomes like a zombie and goes mad, ready to bite the next victim. Rose will be the source of a plague that sweeps across Montreal and forces that city to be under martial law. Hart had only a few broken bones and is sent home to recover, where he spends his time worrying that she's in a coma.
Director-writer David Cronenberg (Shivers) is obsessed with the connection between sex and body functions. He has some fun with this theme, taking on the subject matter with mock seriousness, showing a series of attacks caused by Marilyn. The first bite victim is Lloyd Walsh, who is pounced on by the writhing Marilyn, as she gets up from her coma in her hospital bed and manages to sexually arouse the patient who only wanted to calm her down after he heard her screams; she then bites a drunken farmer who tries a little hanky-panky with her in the barn, where she has her arms wrapped around a cow; and after she bites the farmer, he goes into a diner and attacks the customers; she then attacks Judy Glasburg in the sauna, who is awaiting an unneeded cosmetic plastic surgery; and, finally she sneaks out of the hospital and lures a kind-hearted truck driver Smooth Eddy to give her a hitch before he gets his bite. As the rabies spreads to the general population, a random attack in a crowded subway car occurs and my favorite one, an attack in a mall, where Santa gets shot in the fracas, as the police go after the biter. There is also an incident in the porno theater, which could have been funnier. It had Marilyn Chambers sitting alone, the only woman in the theater, when a guy with a long coat hovers over her and caresses her and moves to sit next to her for sexual favors, and naturally gets what he deserves.
 The film ably depicts the city in a panic and shows the victims foaming at the mouth, reduced to madness. These scenes are mostly played for shock value, but have a certain sophisticated humor about them and relate a concern about medical procedures, alerting us to the fact that doctors have the power to do just about anything to their patients. One of film's main faults, is that it offered no characters that we could care about, but it instead developed an offbeat story that had some kind of political message hidden in its humor. It was quite enjoyable in a less than biting way.
REVIEWED ON 12/17/2000 GRADE: C+
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


This page is a very simple basic webpage tutorial to show 'how a web page works' i.e. 'how to create a 'first' basic simple HTML page'.
For an alternate start, some prefer A Basic HTML Generator (HTML editor) - or more advanced users may prefer the newer CSS Template Generator or the complete PHP (includes) Template Tutorial - followed by a complete php / css / html combination Template Code Maker.
This page shows how to practice / make changes on your local computer. After the index.html file has been created, it can be uploaded to the host server with FTP software (Such as: WS-FTP LE Tutorial.)
To create a simple web page, the first step is to learn a few HTML tags. And copy n paste, the HTML tags into a file using a text editor (such as WordPad or notepad). Then save the file as an ASCII (DOS text) file with the name index.html. BTW: index.html is the default name for the homepage on most web host.
Here are some basic HTML tags that show how a web page is created. For a fast start, just copy n paste this code into a text editor - save as index.html. Then read the 'practice' tips on this page.
favorites / bookmark title goes here
My first page
This is my first web page and I can say anything I want in here - I do that by putting text or images in the body section - where I'm typing right now :)
Notes:
Most HTML tags require an 'opening' and 'closing'
A web page requires an opening and closing HTML tag i.e. .. web page here..
The top section of the web page requires a 'head' section i.e. ...
Inside the 'head' you can place a title (which will be the name you see when you add the site to your favorites / bookmarks) i.e. ..text for favorites..
After closing the , the next section is the In other words the body is inside the and but it's below the ... section.
Summary:
... favorites title ...
.... all the web page is here ...
That's really all you need for a web page e.g :
Just put in a title (favorite bookmark)
Add some text or images in the body section
Save the file as ASCII (text) file with the name index.html
Then upload the index.html file to the public_html (www) directory
Practice:
Now Practice Practice Practice before you upload / publish your web page. In other words, it is better to practice and finalize your web page on your local computer. To do this with MSIE browser:
Locate your index.html file on the hard drive (i.e. know the path)
Open MSIE browser (either work offline or online)
From MSIE, use 'file' 'open' and 'browse' to the location of the index.html - then 'open' - 'ok'
Now that the web page is open on your screen, just minimize it so you can edit / make changes.
Open up a text editor (such as WordPad / notepad) and load the index.html file. Make changes to the file such as adding more text or use the tag with a closing =
Save the new index.html i.e. just use save to overwrite the old index.html.
Now restore (bring back up) the MSIE browser window and click on refresh. The new reworked web page will now appear.
Summary: By saving the index.html file - then opening it in MSIE browser - then switching back to the text editor - making changes to the info between the body tags - saving the changes - restore the MSIE view - use refresh. Using this 'back n forth' procedure you can design - finalize the web page - all on the local computer. Then when it's finished just upload it to your web host.
Second Example (more tags :)
After playing with the tags in the first example, here a few more to 'practice' with:
favorites / bookmark title goes here
second page - smaller heading e.g. h2
This is my second web page with a few more HTML tags.
Let's start with a tag for a horizontal line =
Now let's put in an image (that is in the same folder as this file so we don't have to put the full path / URL
Razorback Hog Logo
This example only added two new tags but it shows how to improve you page as you learn new HTML tags. Also keep in mind that a lot of HTML tags have more attributes. For example, the
tag in this example could be changed to
Now that you know the basic 'structure' of a web page all you need to do is start learning HTML tags (and their attributes) to use in the ......... sections.


Head on over to https://atom.io, and download the appropriate version for your OS. This installer should be self-extracting, and pretty straightforward.
Once Atom is installed, head up to the "File" menu, and select "Settings". This should open a new tab with various settings modules down the left-hand column. Select the "Install" module. In the top search box, type "codelink-tools" (without quotes), and press the "Install" button.
With both of these items installed, Atom will be looking for files ending with ".lcs" (no quotes) to determine that this file should be handled by CodeLINK. Once a file is opened/edited, CodeLINK will run a background process (CodeLink_ServiceCmd.exe) which is going to be doing the actual parsing/compilation work.
NOTE: The CodeLink package and CodeLink_ServiceCmd.exe require TCP and UDP access to communicate between Atom and CodeLink_ServiceCmd.exe. You may need to allow network access to "CodeLink_ServiceCmd.exe" for the CodeLink package to function properly!
While editing a .lcs file, CodeLINK parsing results will be displayed directly in the editor window, as well as in the "CodeLink Parser" console, at the bottom of the screen.
In the long term, this package will also facilitate creating a 'solution', a complete package of multiple projects, and compiling the lot, as well as debugging. At the moment, we're pretty much just doing the parse job, but hey, it's a start!
Ideally, Atom would inform you of an updated package, or you could simply open the "File" -> "Settings" tab, head to "Packages" and click "Update" on the "CodeLINK" package to check for updates manually. Unfortunately, we're still working out some bugs! As such, if you need to update your Atom package, you'll need to go into "Task Manager" -> "Details", and kill the "CodeLink_ServiceCmd.exe" manually before attempting an update. Sorry for the inconvenience!


pyspecdata.core.fitdata¶
- class pyspecdata.core.fitdata(*args, **kwargs)¶
Inherits from an nddata and enables curve fitting through use of a sympy expression.
The user creates a fitdata class object from an existing nddata class object, and on this fitdata object can define the
functional_form()
of the curve it would like to fit to the data of the original nddata. This functional form must be provided as a sympy expression, with one of its variables matching the name of the dimension that the user would like to fit to. The user provides fit coefficients usingfit_coeff()
and obtains output usingfit()
andeval()
.If you haven’t done this before, create a jupyter notebook (not checked in, just for your own playing around) with:
` import sympy as s s.init_printing() `
you can then use s.symbols( to create symbols/variables that allow you to build the mathematical expression for your fitting function- __init__(*args, **kwargs)¶
initialize nddata – several options. Depending on the information available, one of several formats can be used.
- 3 arguments:
nddata(inputarray, shape, dimlabels)
- inputarray:
np.ndarray storing the data – note that the size is ignored and the data is reshaped as needed
- shape:
a list (or np.array, etc.) giving the size of each dimension, in order
- dimlabels:
a list giving the names of each dimension, in order
- 2 arguments:
nddata(inputarray, dimlabels)
- inputarray:
np.ndarray storing the data – the data is not reshaped
- dimlabels:
a list giving the names of each dimension, in order
- 2 arguments:
nddata(inputarray, single_dimlabel)
- inputarray:
np.ndarray storing the data – must be 1D inputarray is also used to label the single axis
- single_dimlabel:
a list giving the name of the single axis
- 1 argument:
nddata(inputarray, shape, dimlabels)
- inputarray:
np.ndarray storing the data – reduced to 1D A single dimension, called “INDEX” is set. This suppresses the printing of axis labels. This is used to store numbers and arrays that might have error and units, but aren’t gridded data.
- keyword args
these can be used to set the labels, etc, and are passed to
__my_init__()
Methods
__init__
(*args, **kwargs)initialize nddata -- several options.
add_noise
(intensity)Add Gaussian (box-muller) noise to the data.
aligndata
(arg)This is a fundamental method used by all of the arithmetic operations.
along
(dimname)Specifies the dimension for the next matrix multiplication (represents the rows/columns).
Not up to date
argmax
(*args, **kwargs)find the max along a particular axis, and get rid of that axis, replacing it with the index number of the max value
argmin
(*axes, **kwargs)If np.argmin('axisname') find the min along a particular axis, and get rid of that axis, replacing it with the index number of the max value.
axis
(axisname)returns a 1-D axis for further manipulation
axlen
(axis)return the size (length) of an axis, by name
axn
(axis)Return the index number for the axis with the name "axis"
bootstrap
(points[, swap_out, seedval, ...])cdf
([normalized, max_bins])calculate the Cumulative Distribution Function for the data along axis_name
check_axis_coords_errors
()chunk
(axisin, *otherargs)"Chunking" is defined here to be the opposite of taking a direct product, increasing the number of dimensions by the inverse of the process by which taking a direct product decreases the number of dimensions. This function chunks axisin into multiple new axes arguments.:
chunk_auto
(axis_name, which_field[, dimname])assuming that axis "axis_name" is currently labeled with a structured np.array, choose one field ("which_field") of that structured np.array to generate a new dimension Note that for now, by definition, no error is allowed on the axes.
circshift
(axis, amount)contiguous
(lambdafunc[, axis])Return contiguous blocks that satisfy the condition given by lambdafunc
contour
([labels])Contour plot -- kwargs are passed to the matplotlib contour function.
convolve
(axisname, filterwidth[, convfunc, ...])Perform a convolution.
copy
()Return a full copy of this instance.
copy_axes
(other)copy_props
(other)Copy all properties (see
get_prop()
) from another nddata object -- note that these include properties pertaining the the FT status of various dimensions.copyaxes
(other)covar
(*names)give the covariance for the different symbols
covarmat
(*names)cropped_log
([subplot_axes, magnitude])For the purposes of plotting, this generates a copy where I take the log, spanning "magnitude" orders of magnitude This is designed to be called as abs(instance).cropped_log(), so it doesn't make a copy
diff
(thisaxis[, backwards])dot
(arg)Tensor dot of self with arg -- dot all matching dimension labels.
eval
(taxis[, set_what, set_to])calculate the fit function along the axis taxis.
eval_poly
(c, axis[, inplace])Take c output (array of polynomial coefficents in ascending order) from
polyfit()
, and apply it along axis axisextend
(axis, extent[, fill_with, tolerance])Extend the (domain of the) dataset and fill with a pre-set value.
extend_for_shear
(altered_axis, propto_axis, ...)this is propto_axis helper function for .fourier.shear
fit
([set_what, set_to, force_analytical])actually run the fit
fitfunc
(p, x)This is the function that does the actual fitting, and takes a properly ordered list of parameters as well as an np.ndarray for the x axis.
fld
(dict_in[, noscalar])flatten dictionary -- return list
fourier_shear
(altered_axis, propto_axis, ...)the fourier shear method -- see .shear() documentation
fromaxis
(*args, **kwargs)Generate an nddata object from one of the axis labels.
ft
(axes[, tolerance, cosine, verbose, unitary])This performs a Fourier transform along the axes identified by the string or list of strings axes.
ft_clear_startpoints
(axis[, t, f, nearest])Clears memory of where the origins in the time and frequency domain are.
ft_state_to_str
(*axes)Return a string that lists the FT domain for the given axes.
ftshift
(axis, value)FT-based shift.
gen_indices
(this_set, set_to)pass this this_set and this_set_to parameters, and it will return: indices,values,mask indices --> gives the indices that are forced values --> the values they are forced to mask --> p[mask] are actually active in the fit
get_covariance
()this returns the covariance matrix of the data
get_error
(*args)get a copy of the errors either set_error('axisname',error_for_axis) or set_error(error_for_data)
get_ft_prop
(axis[, propname])Gets the FT property given by propname.
get_plot_color
()get_prop
([propname])return arbitrary ND-data properties (typically acquisition parameters etc.) by name (propname)
get_range
(dimname, start, stop)get raw indices that can be used to generate a slice for the start and (non-inclusive) stop
get_units
(*args)getaxis
(axisname)getaxisshape
(axisname)gnuplot_save
(filename)guess
([use_pseudoinverse])old code that I am preserving here -- provide the guess for our parameters; by default, based on pseudoinverse
hdf5_write
(h5path[, directory])Write the nddata to an HDF5 file.
histogram
(**kwargs)human_units
()ift
(axes[, n, tolerance, verbose, unitary])This performs an inverse Fourier transform along the axes identified by the string or list of strings axes.
indices
(axis_name, values)Return a string of indeces that most closely match the axis labels corresponding to values.
inhomog_coords
(direct_dim, indirect_dim[, ...])Apply the "inhomogeneity transform," which rotates the data by \(45^{\circ}\), and then mirrors the portion with \(t_2<0\) in order to transform from a \((t_1,t_2)\) coordinate system to a \((t_{inh},t_{homog})\) coordinate system.
integrate
(thisaxis[, backwards, cumulative])Performs an integration -- which is similar to a sum, except that it takes the axis into account, i.e., it performs: \(\int f(x) dx\) rather than \(\sum_i f(x_i)\)
interp
(axis, axisvalues[, past_bounds, ...])interpolate data values given axis values
invinterp
(axis, values, **kwargs)interpolate axis values given data values
item
()like numpy item -- returns a number when zero-dimensional
labels
(*args)label the dimensions, given in listofstrings with the axis labels given in listofaxes -- listofaxes must be a numpy np.array; you can pass either a dictionary or a axis name (string)/axis label (numpy np.array) pair
latex
()show the latex string for the function, with all the symbols substituted by their values
like
(value)provide "zeros_like" and "ones_like" functionality
linear
(*args, **kwargs)return the linear-form function, either smoothly along the fit function, or on the raw data, depending on whether or not the taxis argument is given can take optional arguments and pass them on to eval
linear_shear
(along_axis, propto_axis, shear_amnt)the linear shear -- see self.shear for documentation
makereal
()matchdims
(other)add any dimensions to self that are not present in other
matrices_3d
([also1d, invert, max_dimsize, ...])returns X,Y,Z,x_axis,y_axis matrices X,Y,Z, are suitable for a variety of mesh plotting, etc, routines x_axis and y_axis are the x and y axes
max
()mayavi_surf
()use the mayavi surf function, assuming that we've already loaded mlab during initialization
mean
(*args, **kwargs)Take the mean and (optionally) set the error to the standard deviation
mean_all_but
(listofdims)take the mean over all dimensions not in the list
mean_nopop
(axis)mean_weighted
(axisname)perform the weighted mean along axisname (use $sigma$ from $sigma = $self.get_error() do generate $1/sigma$ weights) for now, it clears the error of self, though it would be easy to calculate the new error, since everything is linear
meshplot
([stride, alpha, onlycolor, light, ...])takes both rotation and light as elevation, azimuth only use the light kwarg to generate a black and white shading display
min
()mkd
(*arg, **kwargs)make dictionary format
multimin
(minfunc, axisname, filterwidth, ...)name
(*arg)args: .name(newname) --> Name the object (for storage, etc) .name() --> Return the name
nnls
(dimname, newaxis_dict, kernel_func[, l])Perform regularized non-negative least-squares "fit" on self.
normalize
(axis[, first_figure])oldtimey
([alpha, ax, linewidth, ...])output
(*name)give the fit value of a particular symbol, or a dictionary of all values.
parameter_derivatives
(xvals[, set, set_to])return a matrix containing derivatives of the parameters, can set dict set, or keys set, vals set_to
pinv
(*args, **kwargs)plot_labels
(labels[, fmt])this only works for one axis now
polyfit
(axis[, order, force_y_intercept])polynomial fitting routine -- return the coefficients and the fit .. note: previously, this returned the fit data as a second argument called formult-- you very infrequently want it to be in the same size as the data, though; to duplicate the old behavior, just add the line
formult = mydata.eval_poly(c,'axisname')
.popdim
(dimname)random_mask
(axisname[, threshold, inversion])generate a random mask with about 'threshold' of the points thrown out
register_axis
(arg[, nearest])Interpolate the data so that the given axes are in register with a set of specified values.
rename
(previous, new)reorder
(*axes, **kwargs)Reorder the dimensions the first arguments are a list of dimensions
replicate_units
(other)repwlabels
(axis)residual
(p, x, y, sigma)just the residual (error) function
retaxis
(axisname)run
(*args)run a standard numpy function on the nddata:
run_avg
(thisaxisname[, decimation, centered])a simple running average
run_nopop
(func, axis)runcopy
(*args)secsy_transform
(direct_dim, indirect_dim[, ...])Shift the time-domain data backwards by the echo time.
secsy_transform_manual
(direct_dim, indirect_dim)Shift the time-domain data backwards by the echo time.
set_error
(*args)set the errors: either
set_ft_prop
(axis[, propname, value])Sets the FT property given by propname.
set_guess
(dict_of_values)sets parameters to guess/estimated value to compare fit.
set_plot_color
(thiscolor)set_prop
(*args)set a 'property' of the nddata This is where you can put all unstructured information (e.g.
set_to
(otherinst)Set data inside the current instance to that of the other instance.
set_units
(*args)setaxis
(*args)set or alter the value of the coordinate axis
a debugging function, to easily plot the initial guess
shear
(along_axis, propto_axis, shear_amnt[, ...])Shear the data \(s\):
smoosh
(dimstocollapse[, dimname, noaxis])Collapse (smoosh) multiple dimensions into one dimension.
sort
(axisname[, reverse])sort_and_xy
()squeeze
([return_dropped])squeeze singleton dimensions
sum
(axes)sum_nopop
(axes)to_ppm
()Function that converts from Hz to ppm using Bruker parameters
unitify_axis
(axis_name[, is_axis])this just generates an axis label with appropriate units
units_texsafe
(*args)unset_prop
(arg)remove a 'property'
waterfall
([alpha, ax, rotation, color, ...])Attributes
C
shortcut for copy
angle
Return the angle component of the data
A property of the fitdata class which stores a string output of the functional form of the desired fit expression provided in func:functional_form in LaTeX format
A property of the fitdata class which is set by the user, takes as input a sympy expression of the desired fit expression
imag
Return the imag component of the data
real
Return the real component of the data
want_to_prospa_decim_correct


Playing sports may carry benefits for hearing
by HealthDay NewsDec. 9 -- Playing sports may improve the brain's ability to process sounds, a finding that could lead to new therapies for people who struggle with hearing, researchers report.
"No one would argue against the fact that sports lead to better physical fitness, but we don't always think of brain fitness and sports," said study senior author Nina Kraus. She's a professor of communication sciences and neurobiology at Northwestern University, in Evanston, Ill.
"We're saying that playing sports can tune the brain to better understand one's sensory environment," added Kraus, director of the university's Auditory Neuroscience Laboratory.
The study included 495 female and male Northwestern student athletes and a control group of 493 age- and sex-matched non-athletes.
The participants' brain activity was monitored while they wore earbuds that delivered speech sounds. The athletes were more adept than those in the control group to tune out background noise to better process the speech sounds, according to the study published Dec. 9 in the journal Sports Health.
That skill can be useful for athletes when they're trying to hear a teammate or coach calling to them during a game.
Kraus equated it to listening to a DJ on the radio.
"Think of background electrical noise in the brain like static on the radio," Kraus said in a university news release. "There are two ways to hear the DJ better: minimize the static or boost the DJ's voice. We found that athlete brains minimize the background 'static' to hear the 'DJ' better."
She added that "a serious commitment to physical activity seems to track with a quieter nervous system. And perhaps, if you have a healthier nervous system, you may be able to better handle injury or other health problems."
The findings could lead to sports-based therapies for people who struggle with auditory processing.
More information
The American Academy of Audiology has more on auditory processing disorders.
Copyright 2019 HealthDay. All rights reserved.
(0) Leave a comment
upi.com/6965080
Latest Headlines
Health News // 1 hour ago
Majority of U.S. kids traveling overseas don't receive measles vaccine
Dec. 9 (UPI) -- Less than half of all American children traveling internationally are vaccinated against measles prior to departure, even as many countries across the globe are grappling with ongoing outbreaks of the disease.
Health News // 2 hours ago
Timing may be key for SIDS risk, study suggests
Dec. 9 -- New research suggests that a baby's age may offer clues to sudden unexplained infant death, or SUID -- formerly known as SIDS.
Health News // 7 hours ago
Geriatric conditions pose added danger for older heart patients in ICU
Dec. 9 (UPI) -- Common geriatric conditions complicate ICU stays, the American Heart Association says in a new scientific statement, requiring doctors to factor in a mix of treatment needs for older adults.
Health News // 1 day ago
Good workouts might extend a woman's life
If you can tackle a tough workout, that may bode well for your longevity, new research suggests.
Health News // 1 day ago
CBD medicine may help ease another form of seizure
Prescription-grade CBD may help control hard-to-treat seizures caused by a rare genetic disorder, a preliminary study suggests.
Health News // 2 days ago
Clinical trial to test stem cells against type 1 diabetes
Dec. 6 (UPI) -- Researchers believe they may help restore normal immune function in adults with type 1 disease with injections of stem cells, enabling the pancreas to produce insulin.
Health News // 2 days ago
Virtual visits to the doctor good for many with neurological disorders
Dec. 6 -- If you have a neurological disorder, a video chat with your doctor might be as good as an office visit for checking on your condition.
Health News // 2 days ago
BPA levels in humans higher than previously thought, study suggests
Dec. 6 -- Levels of the widely used chemical bisphenol A, or BPA, in people's bodies may be 44 times higher than once thought, according to scientists who say they've created a more accurate way to measure them.
Health News // 2 days ago
FDA testing levels of carcinogens in diabetes drug metformin
Dec. 6 -- Levels of possible cancer-causing chemicals in metformin diabetes medications are under investigation by the U.S. Food and Drug Administration.
Health News // 3 days ago
More than 3,100 new flu cases confirmed by CDC
Dec. 6 (UPI) -- According to the latest FluView report from the Centers for Disease Control and Prevention, released Friday, there were more than 3,100 new cases of the flu confirmed in the U.S. during the week ending Nov. 30.


Co-alignment¶
irisreader.coalignment.find_closest_sji¶
-
irisreader.coalignment.
find_closest_sji
()[source]¶ Finds closest sji steps to raster steps for a given sji and raster object.
- Parameters
raster (irisreader.raster_cube) – raster_cube instance
sji (irisreader.sji_cube) – sji_cube_instance
- Returns
sji_steps – array with closest sji steps
- Return type
numpy.array
irisreader.coalignment.find_closest_raster¶
-
irisreader.coalignment.
find_closest_raster
()[source]¶ Finds closest raster steps to sji steps for a given raster and sji object.
- Parameters
raster (irisreader.raster_cube) – raster_cube instance
sji (irisreader.sji_cube) – sji_cube_instance
- Returns
raster_steps – array with closest raster steps
- Return type
numpy.array
irisreader.coalignment.goes_data¶
-
class
irisreader.coalignment.
goes_data
(start_date, end_date, data_dir, lazy_eval=False)[source]¶ This class represents an interface to GOES X-ray flux data. An instantiated object will download all GOES15 XRS data between the given dates and will store it in the specified data directory. Data that are already present will not be downloaded again. The stored data is made accessible as a pandas data frame which can then be plotted with plot or interpolated to other points in time with interpolate. Optionally, the data are only loaded upon first read access.
- Parameters
start_date (datetime.datetime) – Start date/time of the time window for which GOES data should be downloaded.
end_date (datetime.datetime) – End date/time of the time window for which GOES data should be downloaded.
data_dir (string) – Data directory in which the downloaded data will be stored.
lazy_eval (boolean) – Whether or not data should only be loaded upon first read access.
- Variables
start_date (datetime.datetime) – Start date/time of the GOES X-ray flux data time window
end_date (datetime.datetime) – End date/time of the GOES X-ray flux data time window
data – Pandas data frame with GOES data.
-
get_peak_flux
(flux='B_FLUX')[source]¶ Returns the peak flux measured in the observation time period.
- Parameters
field (str) – ‘B_FLUX’ (default) for the 1-8 Angstrom X-ray flux or ‘A_FLUX’ for the 0.5-1 Angstrom X-ray flux.
- Returns
Peak flux in W/m^2
- Return type
float
-
interpolate
(iris_timestamps, field=['B_FLUX'])[source]¶ This function takes timestamps from iris_data_cube.get_timestamps() (UNIX time - seconds since Thursday, 1 January 1970 00:00:00) and computes interpolated GOES flux data.
- Parameters
iris_timestamps (float) – Array with timestamps from iris_data_cube.get_timestamps() or combined_raster.get_timestamps().
field (string) – ‘B_FLUX’ (default) for the 1-8 Angstrom X-ray flux or ‘A_FLUX’ for the 0.5-1 Angstrom X-ray flux.
- Returns
List with interpolated GOES fluxes in W/m^2
- Return type
float
irisreader.coalignment.hek_data¶
-
class
irisreader.coalignment.
hek_data
(caller, instrument='GOES', lazy_eval=False)[source]¶ This class represents an interface to the Heliophysics Events Knowledge database (HEK). It loads all HEK active regions and flares that were recorded during an IRIS observation and makes them available as a pandas data frame.
- Parameters
caller (iris_data_cube) – observation object that called the hek_data object. This is required to give hek_data the ability to access the observation’s XCENIX/YCENIX positions at different times in a lazy way.
instrument (str) – which instrument to query - defaults to GOES which might be most practical
lazy_eval (boolean) – Whether or not data should only be loaded upon first read access.
- Variables
start_date (datetime.datetime) – Start date/time of the HEK events time window
end_date (datetime.datetime) – End date/time of the HEK events time window
instrument (str) – Queried instrument
data – Pandas data frame with HEK events.
-
get_flares
(classes='', in_FOV=False, FOV_margin=100)[source]¶ Returns a data frame with all flare events in the time window.
- Parameters
classes (str) –
- what flare event classes to return:
”“: all classes, “C”: only C-class, “M”: only M-class, “X”: only X-class, “MX”: both M- and X-class, etc.
in_FOV (bool) – whether to return only flares that occured in the field of view (FOV)
FOV_margin (int) – search margin in arcsec in addition to field of view (flares can have diameters of ~100 arcsec)
-
get_iris_coordinates
(flare_date)[source]¶ Approximates FOV center coordinates of IRIS at the time of a flare.
- Parameters
flare_date (datetime.datetime) – start date and time of the flare
- Returns
iris_xcenix (float) – XCENIX coordinate of IRIS at the time of the flare
iris_ycenix (float) – YCENIX coordinate of IRIS at the time of the flare
-
in_fov
(margin=100)[source]¶ This function returns a list of boolean values for each row in the event data frame, stating for each event whether it occured in the IRIS FOV plus some margin (flares can spread to diameters of up to 100 arcseconds).
- Parameters
margin (float) – number of arcseconds to extend the field of view event search space (defaults to 100)
- Returns
List of boolean values
- Return type
in_fov
-
plot_flares
(classes='', in_FOV=False, FOV_margin=100, show=True, savefile=None)[source]¶ Plots all flare events with respect to the field of view.
- Parameters
classes (str) –
- what flare event classes to return:
”“: all classes, “C”: only C-class, “M”: only M-class, “X”: only X-class, “MX”: both M- and X-class, etc.
in_FOV (bool) – whether to return only flares that occured in the field of view (FOV)
margin (int) – search margin in arcsec in addition to field of view (flares can have diameters of ~100 arcsec)
show (bool) – whether to show plot (for saving only)
savefile (str) – where to save plot if savefile is not None


Object Oriented Concepts I
- Introduction to Object Oriented Concepts
- Procedural vs Object Oriented (OO) Programming
- What is an Object – Object Data and Behavior
- What is a Class – Attributes, Methods and Messages
- Using UML to model a Class Diagram
- Encapsulation and Data Hiding
- Interfaces and Implementations
- Inheritance: Superclasses and Subclasses
- Abstraction and Is-a Relationships
- Polymorphism
- Composition: Abstraction and Has- a Relationships
- How to think in terms of Objects
- Interface vs Implementation
- Abstract thinking when designing Interfaces
and Giving the user minimal Interface possible
- Constructors: Default constructor
- When is a constructor called
- Using multiple constructors
- The design of constructors
- Error handling and The concept of scope
- The Anatomy of a Class – The Name, Comments
- Attributes, Constructors, Accessors of Class
- Public Interface methods
- Private implementation methods
- Class Design Guidelines
- Modeling Real World Systems
- Identifying Public Interfaces
- Designing Robust Constructors
- Designing Error Handling to a Class
- Documenting a Class and Using Comments
- Designing with Reuse
- Extensibility
- Maintainability in Mind
- Using Object Persistence
- Designing with Objects – Proper Analysis
- Statement of Work
- Requirements Collection
- Prototype of User Interface
- Identifying the Classes
- Determining the responsibilities of Each Class
- Class Collaboration
- Class Model to Describe the System
- Mastering Inheritance – Reusing Objects
- Generalization and Specialization
- How Inheritance weakens Encapsulation;
- Frameworks and Reuse
- Frameworks
- Contract: Abstract Classes and Interfaces
- Programming lessons - Introduction to Java
- Java Virtual Machine (JVM)
- Java Runtime (JRE)
- Java Development Kit (JDK)
- Integrated Development Environment (IDE) for Java
- Java installation
- Hello World! Program
- Compiling and running Java program
- Using Java classpath and JVM Architecture
- Java syntax – Package, Import
- Class, Fields, Methods
- Constructors, Primitive data types
- Strings and literal
- Wrapper class
- Nonexistence type: null
- Java features to support practical OOP
- String Operations: String creations and operations
- Immutability property of String
- String comparison and searching
- String buffers and builders
- Java I/O: Streams, Input and Output Stream
- File, Path, Directory and tree
- Exception handling: try and catch
- Checked exception vs unchecked exceptions
- Throw and throws
- Common exception and User defined exception
- Logger and Debugging
- Log levels
- Formatters and Filters
- Logger Handlers and Manager
- Configuration
- Introduction to Debugging and Debugging Workflow


WELCOME TO PIG DICE GAME
HOW TO PLAY..
- Click 'roll dice' button to roll the dice.
- If dice rolls on number 1 you'll get zero points and your opponent is given a chance to play.
- Once any player gets 100 points they win the game.
- Clicking on 'hold' button allows alternate player to play and gives an alert of current player's points.
Player One
First Name:
Second Name:
Player Two
First Name:
Second Name:
Score:
Points:
Score:
Points:


I have an id of "two" on my page container. I'm the second page container in this multi-page template.
Notice that the theme is different for this page because we've added a few data-theme
swatch assigments here to show off how flexible it is. You can add any content or widget to these pages, but we're keeping these simple.
I have an id of "popup" on my page container and only look like a dialog because the link to me had a data-rel="dialog"
attribute which gives me this inset look and a data-transition="pop"
attribute to change the transition to pop. Without this, I'd be styled as a normal page.


Upload File
{% if error %}File Not Uploaded!
Your file could not be uploaded.
Reason: {{error}}
Please correct any errors and try again. If the problem persists, contact Dr. Dos.
Notes On Editing an Existing Upload
Editing an existing upload requires the Edit Token that was given when the file was first uploaded.
If you are only editing metadata and not uploading a replacement zip, you may leave the "File" field blank to continue using the current zip file.
{% endif %} {% if not request.GET.edit %}


--- # This minimal layout presents only the content, # and does not use the compress layout, # e.g. in file-list, where we don't want to lose # line breaks between file names. ---


1. What is nutty?
Nutty is a browser tool using which you can share your local desktop terminal console with a remote user. It does not matter if you or the remote user is behind firewall.
2. What advantages does it provide over tmux/screen?
tmux/screen works well when two users on the same machine want to share terminals. When you want to share the terminal with a remote user nutty will help.
3. What is nutty's License?
Nutty is licened under Apache License Version 2.0
4. In the 3rd step of installation why does it require root access?
curl -s https://raw.github.com/krishnasrinivas/nuttyapp/master/public/install.sh | sudo sh
This is a Chrome limitation.
Bug-237873 had been raised which has been fixed in Chrome-34. So you do not need root permission to install nutty script for Chrome-34+ (Stable Chrome-34 has not been released yet)
5. Is nutty like ajaxterm?
Not at all. Ajaxterm lets you login to a server using a browser. Nutty is a terminal sharing tool
6. How do I share terminal using nutty?
Follow the install steps. After install click the
icon beside the browser bar. It will open a terminal window inside your Chrome browser and also give you a unique URL which you can share with anyone. That person can access your terminal using the URL even if you and him/her are behind firewall.
7. After sharing terminal, does nutty.io server proxy the data between peers?
You can share terminal with peers using either Websocket or WebRTC. If you choose the Websocket option nutty.io server proxies the data between peers. If you choose the WebRTC option the terminal sharing between peers happen with out any proxy, i.e it is entirely peer-to-peer.
8. What is WebRTC
WebRTC enables peer-to-peer real-time communication in the browser. More info
here. Nutty makes use of
peerjs.com WebRTC library.
9. Is the terminal sharing encrypted?
Yes. Websocket data transfer uses https-TLS encryption. WebRTC data traffic is encrypted by the browser by default.
10. If I record terminal in nutty and upload, does it store passwords?
No. Because passwords are not echoed back to the terminal.
11. What browsers are supported?
For now sharing has to be done using Chrome Web Browser. In future Firefox will be supported.
For viewing only, nutty has been tested on Chrome, it is known to work on FF and Safari.
12. How can Chrome access terminal device? Isn't Chrome sandboxed?
Nutty uses
Chrome's Native Messaging API to provide terminal access to the browser. Nutty extension is restricted to the https://nutty.io domain. Hence other websites will not be able to access/misuse it.
Does nutty work on mobile devices?
Yes. A "sharee" can view the shared terminal on mobile devices using mobile browsers. Ability to type commands from mobile devices do not work yet.
14. I would like to run nutty server on a machine inside my private network(or on EC2), is that possible?
Yes. You can download the server code and host your own private nutty server. Please follow these instructions:
https://github.com/krishnasrinivas/nuttyapp/blob/master/README.md


Sales
Our Branches
Opening Hours
Contact Us
Welcome To Salmon Cookies Store ❤
⊰✿ We Are Happy To Serve You All Week From 6 am to 8 pm ✿⊱
Our Branches
Each Salmon Cookies Made with 💗
From Seattle To The World
© 2021 SALMON COOKIES . All rights reserved


--- layout: default title: "404: Page not found" permalink: 404.html ---
This is terrible. Absolutely terrible. I don't know how or why you've ended up here, but please, please, do *not* watch the video above. I still can't seem to figure out how to remove it and it was never intended to be here.
You can go directly back to the homepage, or check out my writing on the archive page. But don't watch the video!


Videos
Here are three English country dances in their entirety. The first is performed by members of the Santa Cruz English Country Dance, and the rest are performed by the Newcastle English Country Dancers, at the Northern California Renaissance Faire. (Just think: You too could dance like this!)
“Uffington Horse”
“Newcastle”


CEU Process
Please read the following information regarding CEU requirements and reporting procedures. Our goal is to maintain the highest standards while providing web-based processes for obtaining, completing and reporting CEUs.
1. Register for ACE continuing education. Select from our list of current offerings. Independent study courses are available in ebook format.
2. Submit CEU completion form. This form includes information about the course, number of CEUs, date of completion and an informal assessment. Once submitted, you will be able to create and print your Certificate of Completion.
3. Check your MyACE dashboard. ACE updates your file so you can view your continuing education status. When 16 CEUs are completed, you can apply for certification renewal.
GUIDELINES FOR CONTINUING EDUCATION
If you have a course you would like to submit for approval, please refer to the guidelines listed below. Then, fill out the CEU Approval Form (Click here).
1. Definition of CEUEach unit of continuing education consists of 1 hour of attendance or application. A program of study worth 4 CEUs should take 4 hours to complete.
2. Determining hoursContinuing education units for personally attended seminars or classes equal their duration. An 8 hour seminar is worth 8 CEUs.
3. Acceptable topicsAll subjects that relate to personal financial management as well as issues surrounding credit and debt are acceptable. Eligibility is not restricted to strictly technical issues, but also includes how counselors deliver their services. This would include communication skills, counseling skills, the business use of computers, as well as topics concerning professional ethics. Ask yourself, “Does this subject assist me in serving my clients?” If the answer to the question is “Yes”, then the topic would be included.
4. Program formatsCEUs can be earned through seminar or class participation or through self-study. Self-study materials can take the form of books, films, audio tapes, CDs, and online learning.
5. Submission requirementsSubmit continuing education by filling out the CEU Approval Form (click here).
6. Time frameUpon receipt of a CEU for approval, ace will either make recommendations or grant approval for CEU credits within 14 days.
Continuing Education Offerings
In order to effectively counsel clients in debt, it is necessary to increase, update and maintain professional skills and knowledge through approved continuing education. Our programs are recognized and approved by the Certified Financial Planner (CFP; #3005), The State of South Carolina (#0618100) and NeighborWorks® America. In addition, our curriculum is taught at universities for college credit i.e. Western Wisconsin College.
This self-study course examines Chapter 7 and Chapter 13 Bankruptcies in light of new legislation and consumer trends. Mandatory pre-bankruptcy counseling and debtor education are also explored. Students can choose to receive a Certificate of Completion or upgrade to Pre-Bankruptcy Specialist designation by taking the 50-item standardized exam. $75
The credit game is easier to play once you know the score. Course content includes a detailed explanation of credit scoring, strategies for maintaining a good score and credit misinformation. Earn CEUs and a Certificate of Completion or opt to take the 50-item standardized test and receive the designation, Credit Scoring Specialist. $75
Top financial goals, generally speaking, are homeownership, pursuing higher education and preparing for retirement. This self-study course considers topics and issues about these important measures of financial success. $75
Find out about one of the nost widely used personality assessment in the world: the Myers-Briggs Personality Type Indicator. Understanding the personalities around can be – to say the least – highly beneficial. $75
Identify your customers! Who are they? They are not only clients but co-workers …and you. Easy reading focuses in on a key discover: providing extraordinary customer service can be exhilarating! $38
This self-study course is designed with the debt negotiator in mind. The nature of conflict and conflict resolution are explored through text and self-assessment. $38