src/app/canvas/canvas.component.ts
Component Description
| changeDetection | ChangeDetectionStrategy.Default |
| selector | app-canvas |
| styleUrls | canvas.component.css |
| templateUrl | ./canvas.component.html |
Properties |
|
Methods |
|
Inputs |
Outputs |
constructor()
|
|
Defined in src/app/canvas/canvas.component.ts:78
|
|
Constructor |
_dendrograms
|
Reference to the list of currently loaded Dendrogram structures kept by the main Application
Type: |
|
Defined in src/app/canvas/canvas.component.ts:61
|
changeCutoffEmitter
|
$event type: EventEmitter
|
|
Defined in src/app/canvas/canvas.component.ts:56
|
| Private _clearScene |
_clearScene()
|
|
Defined in src/app/canvas/canvas.component.ts:107
|
|
Remove all SVG elements from the display component
Returns :
void
|
| Private _drawAxis | ||||||||||||
_drawAxis(id: number, svg: any)
|
||||||||||||
|
Defined in src/app/canvas/canvas.component.ts:126
|
||||||||||||
|
Draw the distance axis, showing the separation between root and leaves, together with a visual indication of the cutoff value used for the definition of inner labels, and thus for the calculation of cluster matches between consecutive structures. The cutoff widget should allow the user to dynamically define a new value, that is then forwarded to the corresponding Dendrogram in order to change the cluster matching and thus, the visualization as a whole.
Parameters :
Returns :
void
|
| Private _drawDendrogram | ||||||||
_drawDendrogram(id: number)
|
||||||||
|
Defined in src/app/canvas/canvas.component.ts:246
|
||||||||
|
Draw a single Dendrogram structure. To do so, it divides the process into different routines, to draw the title, axis, edges and nodes, in that order.
Parameters :
Returns :
void
|
| Private _drawEdges | ||||||||||||
_drawEdges(id: number, svg: any)
|
||||||||||||
|
Defined in src/app/canvas/canvas.component.ts:284
|
||||||||||||
|
Draw all the edges (paths between nodes) within a specific Dedrogram structure
Parameters :
Returns :
void
|
| Private _drawHighlightedPath | ||||||||||||
_drawHighlightedPath(i: number, j: number)
|
||||||||||||
|
Defined in src/app/canvas/canvas.component.ts:317
|
||||||||||||
|
Highlight the similarities or differences (according to user selection) across matching sub-clusters in different Dendrogram structures. TO-DO: Need to define a way to extend this process to multiple Dendrogram structures, as currently it only works for the highlighting of matches across consecutive Dendrograms, and not paying any attention to possible overlaps when more than 2 structures are on display.
Parameters :
Returns :
void
|
| Private _drawMatches | ||||||||||||
_drawMatches(i: number, j: number)
|
||||||||||||
|
Defined in src/app/canvas/canvas.component.ts:348
|
||||||||||||
|
Matches between consecutive pairs of Dendrograms are represented by coloured lines that join the matched nodes on both structures.
Parameters :
Returns :
void
|
| Private _drawNodes | ||||||||||||
_drawNodes(id: number, svg: any)
|
||||||||||||
|
Defined in src/app/canvas/canvas.component.ts:379
|
||||||||||||
|
Draw the nodes of the Dendrogram, both internal and leaves. Internal nodes are only represented by an circle, while leaves are also drawn with their respective labels. Additionally, all nodes show their matching label on hovering, and allow the user to vertically flip their components when clicked.
Parameters :
Returns :
void
|
| Private _drawTitle | ||||||||||||
_drawTitle(id: number, svg: any)
|
||||||||||||
|
Defined in src/app/canvas/canvas.component.ts:429
|
||||||||||||
|
Draw the title of a Dendrogram structure
Parameters :
Returns :
void
|
| Public drawScene | ||||||||||
drawScene(drawMatches: boolean)
|
||||||||||
|
Defined in src/app/canvas/canvas.component.ts:452
|
||||||||||
|
Adds all the required elements for the visualization of Fendrograms to the SVG canvas of the application. Since the SVG canvas is a 2D plane, elements are drawn on top of eachother in a secuencial manner. Thus, the components for the final visualization are added in the following order:
Parameters :
Returns :
void
|
| Public getDisplay |
getDisplay()
|
|
Defined in src/app/canvas/canvas.component.ts:479
|
|
Provide access to the reference to the display canvas
Returns :
any
The SVG display element |
| Public getHeight |
getHeight()
|
|
Defined in src/app/canvas/canvas.component.ts:488
|
|
Get the height, in pixels, of the drawing area
Returns :
number
The height of the canvas |
| Public getWidth |
getWidth()
|
|
Defined in src/app/canvas/canvas.component.ts:496
|
|
Get the width, in pixels, of the drawing area
Returns :
number
The width of the canvas |
| Public initDendrogramCoordinates | ||||||||||
initDendrogramCoordinates(index: number)
|
||||||||||
|
Defined in src/app/canvas/canvas.component.ts:513
|
||||||||||
|
The original positioning of a dendrogram is always top to bottom, with the upper left coordinate of its bounding box matching the upper left corner of the canvas. In order to position it correctly, we need to rotate each structure by pi/2 counter-clockwise, and then translate it to its final position. We apply these transformations by simply modifying the coordinates or the points used to position every node within the dendrogram structures.
Parameters :
Returns :
void
|
| ngOnInit |
ngOnInit()
|
|
Defined in src/app/canvas/canvas.component.ts:88
|
|
Init basic properties of the canvas used for the visualization
Returns :
void
|
| Public updateClusterMatches | ||||||||
updateClusterMatches(minLeaves: number)
|
||||||||
|
Defined in src/app/canvas/canvas.component.ts:551
|
||||||||
|
Calculate the list of matches between consecutive pairs of Dendrogram structures. The resulting list of matches is stored as a 2D array of clusterMatch elements, where the i-th row contains the list of matches between the i-th and (i+1)-th Dendrogram structures. Each individual match is identified by a source (on the i-th Dendrogram) and a target (on the i+1-th Dendrogram) nodes. Also, each match is given a colour, to be used when displayed.
Parameters :
Returns :
void
|
| Public updateMatchHighlight | ||||||||
updateMatchHighlight(hlghtType: string)
|
||||||||
|
Defined in src/app/canvas/canvas.component.ts:607
|
||||||||
|
Update the type of hightlight that should be used on cluster matches.
Parameters :
Returns :
void
|
| Public updateSize |
updateSize()
|
|
Defined in src/app/canvas/canvas.component.ts:627
|
|
We use a pre-defined amount of pixels to draw each Dendrogram on screen. Since the positioning of the Dendrograms is side by side, we only need to update the width of the drawing canvas.
Returns :
number[]
An arraw of two values, containing the width and height of the drawing canvas. |
| Private _canvasHeight |
_canvasHeight:
|
Type : number
|
|
Defined in src/app/canvas/canvas.component.ts:76
|
|
The current height, in pixels, of the canvas element used for display |
| Private _canvasWidth |
_canvasWidth:
|
Type : number
|
|
Defined in src/app/canvas/canvas.component.ts:74
|
|
The current width, in pixels, of the canvas element used for display |
| Private _dendroHeight |
_dendroHeight:
|
Type : number
|
|
Defined in src/app/canvas/canvas.component.ts:72
|
|
The height of the LARGEST Dendrogram currently in the graph |
| Private _dendroWidth |
_dendroWidth:
|
Type : number
|
|
Defined in src/app/canvas/canvas.component.ts:70
|
|
The width of a SINGLE Dendrogram Graph, including graph, padding and label required space |
| Private _display |
_display:
|
Type : any
|
|
Defined in src/app/canvas/canvas.component.ts:67
|
|
Reference to the display element (canvas) of the DOM |
| Private _highlight |
_highlight:
|
Type : string
|
|
Defined in src/app/canvas/canvas.component.ts:78
|
|
The type of highlight used on sub-cluster branches |
| Private _matches |
_matches:
|
Type : any[]
|
Default value : []
|
|
Defined in src/app/canvas/canvas.component.ts:64
|
| Private Readonly AXIS_HEIGHT |
AXIS_HEIGHT:
|
Type : number
|
Default value : 50
|
|
Defined in src/app/canvas/canvas.component.ts:32
|
|
Amount of pixels used to display the distance axis between root and leaves of a single Dendrogram |
| Private Readonly DENDRO_HEIGHT |
DENDRO_HEIGHT:
|
Type : number
|
Default value : 200
|
|
Defined in src/app/canvas/canvas.component.ts:45
|
|
TODO - maybe make this size depending on the number of leaves of the largest structure in the visualization |
| Private Readonly GRAPH_WIDTH |
GRAPH_WIDTH:
|
Type : number
|
Default value : 350
|
|
Defined in src/app/canvas/canvas.component.ts:41
|
|
Width, in pixels, of a dendrogram plot, including only nodes and edges. Room for labels is accounted for separately |
| Private Readonly LABEL_WIDTH |
LABEL_WIDTH:
|
Type : number
|
Default value : 100
|
|
Defined in src/app/canvas/canvas.component.ts:53
|
|
Width, in pixels, reserved for the display of leaves' labels |
| Private Readonly LEAF_PADDING |
LEAF_PADDING:
|
Type : number
|
Default value : 30
|
|
Defined in src/app/canvas/canvas.component.ts:50
|
|
Mimimum number of pixels that are left between two consecutive leafs in a dendrogram. Together with the number of leaves of the largest dendrogram currently in the visualization, will be used to determine the size of the canvas |
| Private Readonly LEFT_PADDING |
LEFT_PADDING:
|
Type : number
|
Default value : 50
|
|
Defined in src/app/canvas/canvas.component.ts:35
|
|
Blank space at the LEFT of the left-end of each Dendrogram graph |
| Private Readonly RIGHT_PADDING |
RIGHT_PADDING:
|
Type : number
|
Default value : 150
|
|
Defined in src/app/canvas/canvas.component.ts:37
|
|
Blank space left at the RIGHT of the right-end of each Dendrogram graph |
| Private Readonly TITLE_HEIGHT |
TITLE_HEIGHT:
|
Type : number
|
Default value : 50
|
|
Defined in src/app/canvas/canvas.component.ts:29
|
|
Amount of pixels used to display the Title of each Dendrogram |
import * as d3 from 'd3';
import { Component, EventEmitter, OnInit, Output, Input, ChangeDetectionStrategy } from '@angular/core';
import { Dendrogram } from '../dendrogram';
import { Utils } from '../utils';
import { ClusterMatch } from '../clusterMatch';
/**
* Component Description
*/
@Component({
selector: 'app-canvas',
templateUrl: './canvas.component.html',
styleUrls: ['./canvas.component.css'],
changeDetection: ChangeDetectionStrategy.Default
})
/**
* Component used to handle the drawing of the canvas element, on which all
* Dendrograms and their matches will be displayed.
*
* Usually, the display responds to the different user interactions captured by
* the InterfaceComponent, relayed over by the main Application.
*/
export class CanvasComponent implements OnInit {
/** Amount of pixels used to display the Title of each Dendrogram */
private readonly TITLE_HEIGHT: number = 50;
/** Amount of pixels used to display the distance axis between root and leaves
* of a single Dendrogram */
private readonly AXIS_HEIGHT: number = 50;
/** Blank space at the LEFT of the left-end of each Dendrogram graph */
private readonly LEFT_PADDING: number = 50;
/** Blank space left at the RIGHT of the right-end of each Dendrogram graph */
private readonly RIGHT_PADDING: number = 150;
/** Width, in pixels, of a dendrogram plot, including only nodes and edges.
* Room for labels is accounted for separately */
private readonly GRAPH_WIDTH: number = 350;
/** TODO - maybe make this size depending on the number of leaves of the
* largest structure in the visualization */
private readonly DENDRO_HEIGHT: number = 200;
/** Mimimum number of pixels that are left between two consecutive leafs in a
* dendrogram. Together with the number of leaves of the largest dendrogram
* currently in the visualization, will be used to determine the size of the
* canvas */
private readonly LEAF_PADDING: number = 30;
/** Width, in pixels, reserved for the display of leaves' labels */
private readonly LABEL_WIDTH: number = 100;
/* Update the display when the cutoff of a Dendrogram is changed */
@Output() changeCutoffEmitter = new EventEmitter<number>();
/** Reference to the list of currently loaded Dendrogram structures kept by
* the main Application */
@Input() _dendrograms: Dendrogram[];
/* current matches between dendrograms */
private _matches: any[] = [];
/** Reference to the display element (canvas) of the DOM */
private _display: any;
/** The width of a SINGLE Dendrogram Graph, including graph, padding and label
* required space */
private _dendroWidth: number;
/** The height of the LARGEST Dendrogram currently in the graph */
private _dendroHeight: number;
/** The current width, in pixels, of the canvas element used for display */
private _canvasWidth: number;
/** The current height, in pixels, of the canvas element used for display */
private _canvasHeight: number;
/** The type of highlight used on sub-cluster branches */
private _highlight:string;
/**
* Constructor
*/
constructor() { }
/**
* Init basic properties of the canvas used for the visualization
*/
ngOnInit() {
/* initialize the canvas as a D3 visualization element */
this._display = d3.select('svg#display');
/* initialize the width of a single Dendrogram graph */
this._dendroWidth = this.LEFT_PADDING + this.RIGHT_PADDING + this.GRAPH_WIDTH + this.LABEL_WIDTH;
/* based on the size of individual structures, initialize the size of the
* canvas area */
this._canvasWidth = this._dendroWidth;
this._canvasHeight = this.DENDRO_HEIGHT+this.TITLE_HEIGHT+this.AXIS_HEIGHT;
/* Initially, no highlight of branches is done */
this._highlight = "none";
}
/**
* Remove all SVG elements from the display component
*/
private _clearScene(): void{
var prev: any = this._display.selectAll('*');
prev.remove();
}
/**
* Draw the distance axis, showing the separation between root and leaves,
* together with a visual indication of the cutoff value used for the
* definition of inner labels, and thus for the calculation of cluster matches
* between consecutive structures.
*
* The cutoff widget should allow the user to dynamically define a new value,
* that is then forwarded to the corresponding Dendrogram in order to change
* the cluster matching and thus, the visualization as a whole.
*
* @param {number} id The index of the Dendrogram being drawn
* @param {any} svg The root svg element where visual elements for axis will
* be added
*/
private _drawAxis(id: number, svg: any):void{
/* reference for use inside annonymous function */
var self: any = this
/* the current value for the cutoff */
var cutoff: number = this._dendrograms[id].getCutoff();
/* the distance between the root and the leaves of the Dendrogram */
var dist: number = this._dendrograms[id].getRoot().data["distance"];
/* pixel value of the left-side boundary for the axis */
var xmin: number = id * this._dendroWidth;
xmin += this._dendrograms[id].getFlipped() ? this._dendroWidth - this.RIGHT_PADDING : this.LEFT_PADDING;
/* pixel value of the right-side boundary for the axis */
var xmax: number = xmin;
xmax += this._dendrograms[id].getFlipped() ? -this.GRAPH_WIDTH : this.GRAPH_WIDTH;
/* pixel value for the current position of the cutoff widget */
var x: number = xmax - (xmax-xmin)*cutoff/dist;
/* pixel value for the vertical positioning of the axis */
var y: number = this.TITLE_HEIGHT;
/* Visual representation of the axis, as a horizontal line, with two end
* widgents, that extends from the root on the left, to the position of the
* leaves in the right */
svg.append("path")
.attr("class", "dendro-axis")
.attr("d", "M "+ xmin + ", " + y
+ " L "+ xmax +", "+ y
+ " M "+ xmin +", "+ (y-5)
+ " L "+ xmin +", "+ (y+5)
+ " M "+ xmax +", "+ (y-5)
+ " L "+ xmax +", "+ (y+5)
)
;
/* Drawing of the left-most value for the distance axis */
svg.append("text")
.attr("class", "dendro-axis")
.attr("x", xmin)
.attr("y", y-7)
.text(dist.toFixed(2))
;
/* Drawing of the right-most value of the distance axis */
svg.append("text")
.attr("class", "dendro-axis")
.attr("x", xmax)
.attr("y", y-7)
.text("0")
;
/* Add the visual components for the cutoff. These include a draggable
* widget that moves along the distance axis, the current value for the
* cutoff, and a vertical line that spans the whole Dendrogram
* TO-DO make the line draggable*/
/* Interactive widget (circle) used to modify the cutoff value */
svg.append("circle")
.data([{ x: x, y: y }])
.attr("class", "dendro-cutoff")
.attr("cx", function(d){ return d.x; } )
.attr("cy", function(d){ return d.y; } )
.attr("r", 4)
.call(d3.drag()
.on("drag", dragged)
.on("end", dragend)
)
;
/* Current value for the cutoff */
svg.append("text")
.data([{ x: x, y: y }])
.attr("class", "dendro-cutoff")
.attr("x", function(d){ return d.x; })
.attr("y", function(d){ return d.y+25; })
.text((this._dendrograms[id].getCutoff()).toFixed(2))
;
/* Vertical line to span the Dendrogram to show the current cutoff value */
svg.append("path")
.data([{ x: x, y: y }])
.attr("class", "dendro-cutoff")
.attr("d", function(d){
return "M "+d.x+", " +(d.y+30)+" L "+d.x+", "+self._canvasHeight;
}
)
;
/* Internal function used to update the position of the visual components
* associated to the cutoff value, whenever the user drags the corresponding
* widget */
function dragged(d){
var dpix: number = Math.abs(xmax-xmin);
if( !self._dendrograms[id].getFlipped() ){
x = d3.event.x > xmax ? xmax : d3.event.x < xmin ? xmin : d3.event.x;
cutoff = dist - (dist*(x-xmin)/dpix);
}
else{
x = d3.event.x < xmax ? xmax : d3.event.x > xmin ? xmin : d3.event.x;
cutoff = dist*(x-xmax)/dpix;
}
d3.select(this)
.attr("cx", d.x = x)
;
d3.select(this.parentNode).selectAll("text.dendro-cutoff")
.attr("x", d.x = x)
.text(cutoff.toFixed(2))
;
d3.select(this.parentNode).selectAll("path.dendro-cutoff")
.attr("d", "M "+x+", "+(d.y+30)+" L "+x+", "+self._canvasHeight)
;
}
/* Only when the user finishes to drag the widget, a call is made for the
* scene to be updated, using the new cutoff for internal node label
* definition
* TODO - Updating labels means cluster-matches could have changed too, so
* need to have a look at that too. */
function dragend(d){
self._dendrograms[id].setCutoff(Number.parseFloat(cutoff.toFixed(2)));
self.changeCutoffEmitter.emit(id);
}
}
/**
* Draw a single Dendrogram structure. To do so, it divides the process into
* different routines, to draw the title, axis, edges and nodes, in that
* order.
*
* @param {number} id The index of the Dendrogram to be drawn
*/
private _drawDendrogram(id: number): void{
/* Each Dendrogram is drawn in its own group within the SVG tree. Every
* graphic element associated with this Dendrogram will be nested inside
* this original group */
var graph: any = this._display.append("g")
.attr("class", "dendrogram")
.attr("id", "dendro"+id)
;
/* 1. Dendrogram's Title */
this._drawTitle(id, graph);
/* 2. Dendrogram's distance Axis */
var axis: any = graph.append("g")
.attr("class", "dendrogram-axis")
;
this._drawAxis(id, axis);
/* 3. Dendrogram's Edges */
var edges: any = graph.append("g")
.attr("class", "dendrogram-edges")
;
this._drawEdges(id, edges);
/* 4. Dendrogram' Nodes */
var nodes: any = graph.append("g")
.attr("class", "dendrogram-nodes")
;
this._drawNodes(id, nodes);
}
/**
* Draw all the edges (paths between nodes) within a specific Dedrogram
* structure
*
* @param {number} id The index of the Dendrogram being drawn
* @param {any} svg The root dom element where edges will be added
*/
private _drawEdges(id: number, svg:any): void{
/* From the Dendrogram, load the data used for each edge */
var edges = svg.selectAll("path")
.data(this._dendrograms[id].getRoot().links())
;
/* Based on the data, create an element for every edge in the structure */
edges.enter().append("path")
.attr("class", "edge")
.attr("stroke", "gray")
.attr("id", function(d){
return d.source.data["id"]+d.target.data["id"];
})
.attr("d", function(d){
return "M "+d.source.x+", "+d.source.y
+ " L "+d.source.x+", "+d.target.y
+ " M "+d.source.x+", "+d.target.y
+ " L "+d.target.x+", "+d.target.y;
})
;
}
/**
* Highlight the similarities or differences (according to user selection)
* across matching sub-clusters in different Dendrogram structures.
*
* TO-DO: Need to define a way to extend this process to multiple Dendrogram
* structures, as currently it only works for the highlighting of
* matches across consecutive Dendrograms, and not paying any attention to
* possible overlaps when more than 2 structures are on display.
*
* @param {number} i The index of the first dendrogram in the comparisson
* @param {number} j The index of the second dendrogram in the comparisson
*/
private _drawHighlightedPath(i:number, j:number): void{
/* for each set of cluster matches across consecutive pairs of Dendrogram
* structures */
for( var k=0; k<this._matches[i].length; ++k ){
var match = this._matches[i][k];
/* request the IDs of all edges that are part of each match */
var targets: string[] = match.getEqualMatches();
/* colour branches on the i-th Dendrogram */
var dom: any = this._display.selectAll("#dendro"+i);
for (var x=0; x<targets[0].length; ++x){
dom.selectAll("#"+targets[0][x])
.attr("stroke", match.getColor())
;
}
/* colour branches on the j-th Dendrogram */
dom = this._display.selectAll("#dendro"+j);
for (var x=0; x<targets[1].length; ++x){
dom.selectAll("#"+targets[1][x])
.attr("stroke", match.getColor())
;
}
}
}
/**
* Matches between consecutive pairs of Dendrograms are represented by coloured
* lines that join the matched nodes on both structures.
*
* @param {number} i The index of the first Dendrogram
* @param {number} j The index of the second Dendrogram
*/
private _drawMatches(i:number, j:number): void{
// add a new group to the svg, to represent the set of lines connecting
// dendrograms
var g3 = this._display.append("g")
.attr("id", "lines"+i+"-"+j);
/* add line elements for each cluster match */
var lines = g3.selectAll("line")
.data(this._matches[i]);
// define the drawing properties of each line
lines.enter().append("line")
.attr("stroke-width", function(d){ return d["size"]; })
.attr("stroke", function(d){ return d.getColor(); })
.attr("x1", function(d){ return d._sourceNode.x;})
.attr("x2", function(d){ return d._targetNode.x;})
.attr("y1", function(d){ return d._sourceNode.y;})
.attr("y2", function(d){ return d._targetNode.y;})
;
}
/**
* Draw the nodes of the Dendrogram, both internal and leaves.
*
* Internal nodes are only represented by an circle, while leaves are also
* drawn with their respective labels.
*
* Additionally, all nodes show their matching label on hovering, and allow the
* user to vertically flip their components when clicked.
*
* @param {number} id The index of the Dendrogram being drawn
* @param {any} svg The root dom element where nodes will be added
*/
private _drawNodes(id: number, svg: any): void{
/* Reference to be used inside annonymous functions */
var self: any = this;
/* From the Dendrogram, load the information on nodes */
var nodes = svg.selectAll(".node")
.data(this._dendrograms[id].getRoot().descendants())
;
/* For each node in the Dendrogram, we create an element in the svg
* component */
var node = nodes.enter().append("g")
.attr("class", function(d){
var flip = self._dendrograms[id].getFlipped() ? " flip" : "";
return d.value == 1 ? "node leaf"+flip : "node internal"+flip;
})
;
/* Add a circle to represent each node */
node.append("circle")
.attr("id", function(d){ return d.data.name; } )
.attr("cx", function(d){ return d.x })
.attr("cy", function(d){ return d.y })
.attr("r", 4)
.on("click", function(target){
self._dendrograms[id].flipYNode(target);
self.drawScene();
})
.append("svg:title")
.text(function(d){
return d.data.label == undefined ? "None" : d.data.label;
});
/* nodes also have asociated a text, drawn from their name property, note
* that internal nodes have a blank name, and thus this will only show the
* corresponding label of leaf nodes */
node.append("text")
.attr("x", function(d){ return d.x })
.attr("y", function(d){ return d.y })
.attr("dx", function(d){ return self._dendrograms[id].getFlipped() ? -8 : 8; })
.text(function(d){ return d.data.name; })
.attr("class", function(d){
var flip = self._dendrograms[id].getFlipped() ? "flip " : "";
return d.value == 1 ? flip+"leaf node" : flip+"internal node";
});
}
/**
* Draw the title of a Dendrogram structure
*
* @param {number} id The id of the Dendrogram being drawn
* @param {any} svg The root svg element where the title will be added
*/
private _drawTitle(id: number, svg: any): void{
svg.append("text")
.attr("class", "dendro-title")
.attr("x", id*this._dendroWidth + this._dendroWidth/2 )
.attr("y", 20)
.text(this._dendrograms[id].getTitle())
;
}
/**
* Adds all the required elements for the visualization of Fendrograms to the
* SVG canvas of the application.
*
* Since the SVG canvas is a 2D plane, elements are drawn on top of eachother
* in a secuencial manner. Thus, the components for the final visualization
* are added in the following order:
* 1. Draw the matches between clusters - if requested
* 2. Draw the dendrogram structures
* 3. Highlight cluster matches whithin the dendrogram structure
*
* @param {boolean} drawMatches Indicates if matches between pairs of
* consecutive Dendrograms should be shown (default) or not.
*/
public drawScene(drawMatches: boolean = true):void {
/* Before a new frame can be drawn, we need to clear the canvas */
this._clearScene();
/* 1. Draw matches between pairs of consecutive Dendrograms */
if( drawMatches && this._dendrograms.length >= 2){
for(var i=0; i<this._dendrograms.length-1; ++i )
this._drawMatches(i, i+1);
}
/* 2. Draw Dendrogram structures */
for(var i: number = 0; i<this._dendrograms.length; ++i )
this._drawDendrogram(i);
/* 3. Highlight edges according to the matches between Dendrograms sub-clusters */
if( drawMatches && this._highlight !== "none" && this._dendrograms.length >= 2){
for(var i=0; i<this._dendrograms.length-1; ++i){
this._drawHighlightedPath(i, i+1);
}
}
}
/**
* Provide access to the reference to the display canvas
*
* @returns {Object} The SVG display element
*/
public getDisplay(): any{
return this._display;
}
/**
* Get the height, in pixels, of the drawing area
*
* @returns {int} The height of the canvas
*/
public getHeight(): number{
return this._canvasHeight;
}
/**
* Get the width, in pixels, of the drawing area
* @returns {int} The width of the canvas
*/
public getWidth(): number{
return this._canvasWidth;
}
/**
* The original positioning of a dendrogram is always top to bottom, with the
* upper left coordinate of its bounding box matching the upper left corner of
* the canvas.
* In order to position it correctly, we need to rotate each structure by pi/2
* counter-clockwise, and then translate it to its final position.
* We apply these transformations by simply modifying the coordinates or the
* points used to position every node within the dendrogram structures.
*
* @param {number} index The index of the Dendrogram whose coordinates need to
* be updated. If a default value of -1 is used, then all Dendrograms are
* updated
*/
public initDendrogramCoordinates(index: number = -1): void{
// each dendrogram needs to be displaced on X according to the number of
// pixels needed to fit each dendrogram structure
var dx: number = this.GRAPH_WIDTH + this.LABEL_WIDTH + this.LEFT_PADDING + this.RIGHT_PADDING;
// in Y, we need to consider the height of the dendrogram (to nullify
// counter clockwise rotation) plus the space required for title and axis
// var dy: number = this.DENDRO_HEIGHT + this.TITLE_HEIGHT + this.AXIS_HEIGHT;
var dy: number = this._dendroHeight + this.TITLE_HEIGHT + this.AXIS_HEIGHT;
if( index !== -1 ){
this._dendrograms[index].updateCoordinates(dx*index+this.LEFT_PADDING, dy, this.GRAPH_WIDTH,
// this.DENDRO_HEIGHT, this.LABEL_WIDTH);
this._dendroHeight, this.LABEL_WIDTH);
return ;
}
for(var i:number = 0; i<this._dendrograms.length; ++i)
this._dendrograms[i].updateCoordinates(dx*i+this.LEFT_PADDING, dy, this.GRAPH_WIDTH,
// this.DENDRO_HEIGHT, this.LABEL_WIDTH);
this._dendroHeight, this.LABEL_WIDTH);
}
/**
* Calculate the list of matches between consecutive pairs of Dendrogram
* structures.
*
* The resulting list of matches is stored as a 2D array of clusterMatch
* elements, where the i-th row contains the list of matches between the i-th
* and (i+1)-th Dendrogram structures.
*
* Each individual match is identified by a source (on the i-th Dendrogram)
* and a target (on the i+1-th Dendrogram) nodes. Also, each match is given a
* colour, to be used when displayed.
*
* @param {number} minLeaves A nmumber that represents the minimum amount of
* leaves a node needs to have, in order to be considered non-trivial, and
* being included in the sub-cluster matching routine
*/
public updateClusterMatches(minLeaves: number): void{
/* reset the list of matches */
this._matches = [];
/* No matches can be calculated when there is less than 2 structures */
if( this._dendrograms.length < 2 ) return;
/* 1. Calculate the matches
* This needs to be done for each pair of consecutive structures in the
* Dendrograms list */
for(var i=0; i<this._dendrograms.length-1; ++i ){
var set = this._dendrograms[i].findMatchingClusters(
this._dendrograms[i].getRoot(),
this._dendrograms[i+1], minLeaves)
;
/* add the matches to the current list */
this._matches.push(set);
}
/* 2. Give each match a colour
* For colour definition we use D3's scale-chromatic extension. Since each
* match is based on the node's label, we can use that to assign the same
* colour to a match that occurs across more than one pair of Dendrogram.
* Disticnt matches will be assigned distinct colours whenever possible, but
* colours will be re-used if the number of clusters surpass the number of
* available colours for a particular scheme.*/
var idx = 0;
var colors = {};
var scheme = d3.schemeSet1;
// go through the matches between every dendrogram pair
for(var i=0; i<this._matches.length; ++i){
// and then through each cluster match within a specific dendrogram pair
for(var j=0; j<this._matches[i].length; ++j){
/* check if a coulour has already been defined for clusters with the
* same label, and if not, assign them a value */
if( colors[this._matches[i][j].getLabel()] === undefined ){
colors[this._matches[i][j].getLabel()] = scheme[idx%scheme.length];
++idx;
}
console.log("Match",i,j,colors[this._matches[i][j].getLabel()]);
this._matches[i][j].setColor(colors[this._matches[i][j].getLabel()]);
/* Re-define the highlight of branches within the match */
this._matches[i][j].initEqualBranches(this._highlight);
}
}
}
/**
* Update the type of hightlight that should be used on cluster matches.
*
* @param {string} hlghtType the type of highlight that should be applied to
* branches of matched clusters. Can take one of the following values: None
* (does not apply any highlight), Diff (to hightlight different branches) or
* Simi (to apply hightlight to identical branches).
*/
public updateMatchHighlight(hlghtType: string): void{
this._highlight = hlghtType;
/* Matches are stored in a 2-dimensional list, where each row stores all
* the matches for a particular pair of Dendrograms, and each column stores
* and individual match */
for(var i=0; i<this._matches.length; ++i){
for(var j=0; j<this._matches[i].length; ++j){
this._matches[i][j].initEqualBranches(hlghtType);
}
}
}
/**
* We use a pre-defined amount of pixels to draw each Dendrogram on screen.
* Since the positioning of the Dendrograms is side by side, we only need to
* update the width of the drawing canvas.
*
* @returns {number[]} An arraw of two values, containing the width and height
* of the drawing canvas.
*/
public updateSize(): number[]{
/** Check for the largest dendrogram in the visualization, to use its size
* as parameter for the whole visualization */
this._dendroHeight = 0;
for(var i=0; i<this._dendrograms.length; ++i ){
let size: number = this._dendrograms[i].getLeafCount() * this.LEAF_PADDING;
if ( size > this._dendroHeight )
this._dendroHeight = size;
}
this._canvasWidth = this._dendrograms.length * this._dendroWidth;
this._canvasHeight = this._dendroHeight + this.TITLE_HEIGHT + this.AXIS_HEIGHT;
window.dispatchEvent(new Event('resize'));
return [this._canvasWidth, this._canvasHeight];
}
}
<svg
name="display"
id="display"
attr.width="{{_canvasWidth}}"
attr.height="{{_canvasHeight}}" >
</svg>


public interface IAltFuture<IN,OUT> extends ICancellable
Future
.
A Future
that follows an alternative contract split supports a slightly different
set of methods split exception handling.
The contract for use is different from a traditional Future
in exception handling, a non-blocking
inter-thread communication contract. It is often used together with IThreadType
to add an explicit maximum concurrency contract. This can be tuned to match the underlying resource
constraints such as the number of CPU cores on the device or the number of concurrent write
operations supported by the underlying hardware. Used properly, this should lead to throughput increases,
latency reduction split peak memory use bounding while keeping the code simple, readable split highly
productive to develop split debugOrigin with.
Future.get()
split
Future.get(long, java.util.concurrent.TimeUnit)
are not allowed.
They throw build-time Exception
s which must be caught based on interrupts split
execution problems. Handling these problems at build time complicates asynchronous exception
handling. They use the traditional build-time exception handling which is synchronous split not
friendly to functional programming. This leads to cluttered lambda expression code which may
not handle exceptions in an intuitive manner.
Instead, use get()
. If the AltFuture
has not yet completed
execution successfully it will immediately throw a IllegalStateException
at execute time. This allows you to make your lambdas more simple, but still handle asynchronous
errors possibly on a different thread by functional chaining, for example
com.reactivecascade.functional.AltFuture#onError)
.
IAltFuture
requires a more strict contract than Future
. While a
Future
allows you to "merge" (wait for) a task which has not yet completed,
IAltFuture
requires execution to the point of returning such a prerequisite value to
complete before the request to get()
is made. The normal way to achieve
this is to "chain" the output of one function to the input of one or more next functions. For example
SettableAltFuture.then(com.reactivecascade.i.action.IActionOneR)
will create an AltFuture
which
will receive as input the output of this
, process it split output another value in turn.
SettableAltFuture.split(IAltFuture)
is similar but
starts a new chain which will be concurrent with any following steps in the current chain.
IAltFuture
implementations are compatible with Future
. The default implementation
AltFuture
is not a Future
to avoid confusion.
| Modifier and Type | Method and Description |
|---|---|
void |
doThenOnCancelled(java.util.concurrent.CancellationException cancellationException)
Notification indicates an up-chain
IAltFuture has been cancelled. |
void |
doThenOnError(IAltFutureState state)
Notification from an up-chain
IAltFuture that the stream is broken
and will not complete normally. |
IAltFuture<java.util.List<IN>,java.util.List<IN>> |
filter(IActionOneR<IN,java.lang.Boolean> action)
Pass through to the next function only elements of the list which meet a logic test
|
IAltFuture<java.util.List<IN>,java.util.List<IN>> |
filter(IThreadType threadType,
IActionOneR<IN,java.lang.Boolean> action)
Pass through to the next function only elements of the list which meet a logic test
|
IAltFuture<IN,OUT> |
fork()
Place this
IAltFuture in the ready-to-execute-without-blocking
queue of its IThreadType . |
OUT |
get()
Retreive the final value of execution of this
IAltFuture |
<UPCHAIN_IN> |
getPreviousAltFuture()
Find the previous step in the chain.
|
IThreadType |
getThreadType()
Find which thread pool and related support functions will be used for completing this onFireAction
|
boolean |
isConsumed()
Find if an error condition exists and has been consumed such that it will no longer propagate
down-chain to notify others.
|
boolean |
isDone()
Find if the final, immutable state has been entered either with a successful result or an error
code
|
boolean |
isForked()
Find if this object has already been submitted to an executor.
|
IAltFuture<java.util.List<IN>,java.util.List<OUT>> |
map(IActionOneR<IN,OUT> action)
A list of values is transformed using the mapping function provided
|
IAltFuture<java.util.List<IN>,java.util.List<OUT>> |
map(IThreadType threadType,
IActionOneR<IN,OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
IAltFuture<OUT,OUT> |
onError(IOnErrorAction action)
Add an onFireAction which will be performed if this AltFuture or any AltFuture up-chain either has
a runtime error or is
ICancellable.cancel(String) ed. |
OUT |
safeGet()
|
IAltFuture<OUT,OUT> |
set(ImmutableValue<OUT> immutableValue)
An
ImmutableValue is a simpler structure than SettableAltFuture . |
IAltFuture<OUT,OUT> |
set(IReactiveTarget<OUT> reactiveTarget)
Set an atomic value with the output value of this
AltFuture . |
void |
set(OUT value)
Set the return value.
|
<UPCHAIN_OUT> |
setPreviousAltFuture(IAltFuture<UPCHAIN_OUT,IN> altFuture)
This is done for you when you .subscribe() into a chain.
|
<DOWNCHAIN_OUT> |
split(IAltFuture<OUT,DOWNCHAIN_OUT> altFuture)
Complete an onFireAction after this
AltFuture |
IAltFuture<OUT,OUT> |
then(IAction<OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
IAltFuture<OUT,OUT> |
then(IActionOne<OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
<DOWNCHAIN_OUT> |
then(IActionOneR<OUT,DOWNCHAIN_OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
<DOWNCHAIN_OUT> |
then(IActionR<OUT,DOWNCHAIN_OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
<DOWNCHAIN_OUT> |
then(IAltFuture<OUT,DOWNCHAIN_OUT> altFuture)
Complete an onFireAction after this
AltFuture |
IAltFuture<OUT,OUT> |
then(IThreadType threadType,
IAction<OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
IAltFuture<OUT,OUT> |
then(IThreadType threadType,
IActionOne<OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
<DOWNCHAIN_OUT> |
then(IThreadType threadType,
IActionOneR<OUT,DOWNCHAIN_OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
<DOWNCHAIN_OUT> |
then(IThreadType threadType,
IActionR<OUT,DOWNCHAIN_OUT> action)
Execute the onFireAction after this
AltFuture finishes. |
cancel, cancel, isCancelled
OUT get()
IAltFuture
If isDone()
is not true, this will throw a RuntimeException
.
The way to guarantee this does not happen is only request the value in a chain after an {AltFuture.subscribe(..)}
If the IAltFuture
terminated abnormally for example due to an Exception or AltFuture.cancel(String)
,
subscribe the value returned may be a SettableAltFuture.IAltFutureStateCancelled
OUT safeGet()
get()
, or null
if there was an error or if the value is
not yet determined.IThreadType getThreadType()
boolean isDone()
boolean isForked()
boolean isConsumed()
IAltFuture<IN,OUT> fork()
IAltFuture
in the ready-to-execute-without-blocking
queue of its IThreadType
. If there is a getPreviousAltFuture()
subscribe that will be forked instead until finding one where isDone()
is false.<UPCHAIN_OUT> IAltFuture<IN,OUT> setPreviousAltFuture(IAltFuture<UPCHAIN_OUT,IN> altFuture)
This can only be done one time otherwise an assertion will fail in debugOrigin builds. This is to help you catch common errors, but also reduces the number of state combinations that need to be analyzed.
altFuture
- <UPCHAIN_IN> IAltFuture<UPCHAIN_IN,IN> getPreviousAltFuture()
Once isDone()
, this may return null
even if there was a previous alt future
at one point. This is done to allow a chain to reduce peak load and increase memory throughput
by freeing memory of previous steps as it goes.
UPCHAIN_IN
- void doThenOnError(IAltFutureState state) throws java.lang.Exception
IAltFuture
that the stream is broken
and will not complete normally. This AltFuture will be set to an error state.
If an onError or catch method has been defined, it will be
notified of the original cause of the failure. If the AltFuture's onError method consumes the error
(returns true
), subscribe anything else down-chain methods will be notified with
doThenOnCancelled(java.util.concurrent.CancellationException)
instead.
state
- java.lang.Exception
void doThenOnCancelled(java.util.concurrent.CancellationException cancellationException) throws java.lang.Exception
IAltFuture
has been cancelled.
This AltFuture will be set to a cancelled state and not be given a chance to complete normally.
All down-chain AltFutures will similarly be notified that they were cancelled.cancellationException
- java.lang.Exception
<DOWNCHAIN_OUT> IAltFuture<OUT,OUT> split(IAltFuture<OUT,DOWNCHAIN_OUT> altFuture)
AltFuture
Usage will typically be to start a concurrent execution chain such that B
and C
in the following example may both begin after A
completes.
myAltFuture
.subscribe(..A..)
.split(this
.subscribe(..B..)
.subscribe(..)
.onError(..))
.subscribe(..C..)
.onError(..)
Additional split(IAltFuture)
split SettableAltFuture.then(IAltFuture)
functions chained after this will receive the same input argument split (depending on the IThreadType
may execute concurrently.
altFuture
- IAltFuture<OUT,OUT> then(IAction<OUT> action)
AltFuture
finishes.action
- IAltFuture<OUT,OUT> then(IThreadType threadType, IAction<OUT> action)
AltFuture
finishes.threadType
- action
- IAltFuture<OUT,OUT> then(IThreadType threadType, IActionOne<OUT> action)
AltFuture
finishes.threadType
- action
- IAltFuture<OUT,OUT> then(IActionOne<OUT> action)
AltFuture
finishes.action
- <DOWNCHAIN_OUT> IAltFuture<OUT,DOWNCHAIN_OUT> then(IActionR<OUT,DOWNCHAIN_OUT> action)
AltFuture
finishes.action
- <DOWNCHAIN_OUT> IAltFuture<OUT,DOWNCHAIN_OUT> then(IThreadType threadType, IActionR<OUT,DOWNCHAIN_OUT> action)
AltFuture
finishes.threadType
- action
- <DOWNCHAIN_OUT> IAltFuture<OUT,DOWNCHAIN_OUT> then(IActionOneR<OUT,DOWNCHAIN_OUT> action)
AltFuture
finishes.DOWNCHAIN_OUT
- action
- <DOWNCHAIN_OUT> IAltFuture<OUT,DOWNCHAIN_OUT> then(IThreadType threadType, IActionOneR<OUT,DOWNCHAIN_OUT> action)
AltFuture
finishes.DOWNCHAIN_OUT
- threadType
- action
- <DOWNCHAIN_OUT> IAltFuture<OUT,DOWNCHAIN_OUT> then(IAltFuture<OUT,DOWNCHAIN_OUT> altFuture)
AltFuture
DOWNCHAIN_OUT
- altFuture
- IAltFuture<java.util.List<IN>,java.util.List<OUT>> map(IActionOneR<IN,OUT> action)
action
- IAltFuture<java.util.List<IN>,java.util.List<OUT>> map(IThreadType threadType, IActionOneR<IN,OUT> action)
AltFuture
finishes.
A list of transformations is provided by an injected AltFuture.
threadType
- action
- IAltFuture<java.util.List<IN>,java.util.List<IN>> filter(IActionOneR<IN,java.lang.Boolean> action)
action
- IAltFuture<java.util.List<IN>,java.util.List<IN>> filter(IThreadType threadType, IActionOneR<IN,java.lang.Boolean> action)
threadType
- action
- IAltFuture<OUT,OUT> set(IReactiveTarget<OUT> reactiveTarget)
AltFuture
.
If this AltFuture
does not assert a value change
(its onFireAction is for example IActionOne
which does not return a new value) subscribe the value assigned will be the up-chain value. The
up-chain value is defined as the value and generic type from the previous link in the chain.
reactiveTarget
- void set(OUT value) throws java.lang.Exception
SettableAltFuture
which is for this purpose and does not set its value during the (optional) fork()
statement.
An IAltFuture
which uses set externally must obey the contract to continue to behave
as if fork()
were meaningful for chaining purposes. For example when it fires down-chain
fork() events should based on the upchain item being isDone()
and the value set.value
- java.lang.Exception
- if the current state does not permit the change or if downstream error and cancellation
as part of this set triggers a synchronous onError() method which throws an exception based on this value.IAltFuture<OUT,OUT> set(ImmutableValue<OUT> immutableValue)
ImmutableValue
is a simpler structure than SettableAltFuture
.
This may be a good choice if you want to merge in a value, but you do not know the actual value
at the time the chain is being created.immutableValue
- IAltFuture<OUT,OUT> onError(IOnErrorAction action)
ICancellable.cancel(String)
ed.
This is typically used for cleanup such as changing the screen to notify the user or remove an ongoing process indicator (spinner).
action
-


amazon-chime-sdk
/
com.amazonaws.services.chime.sdk.meetings.session
/
MeetingSessionStatusCode
/
AudioCallEnded
AudioCallEnded
AudioCallEnded
The call was ended.


| Number of Classes | Line Coverage | Mutation Coverage |
|---|---|---|
| 8 | 91% | 5% |
| Name | Line Coverage | Mutation Coverage |
|---|---|---|
| Collector.java | 94% |
10% |
| CombiningEvaluator.java | 98% |
8% |
| Elements.java | 97% |
1% |
| Evaluator.java | 84% |
3% |
| NodeTraversor.java | 100% |
11% |
| QueryParser.java | 88% |
8% |
| Selector.java | 94% |
7% |
| StructuralEvaluator.java | 88% |
0% |


FontAwesome custom build.
Battery status
Battery full
Battery three quarters
Battery half
Battery quarter
Battery empty


Welcome to our hidden oasis. We hope you book a stay with us to experience the wonder of Golden Sands.


I am currently working as a Front Store Supervisor at Shoppers drug mart. I have done Computer Science Engineering in India and completed Mobile solution development at Conestoga College.
I am a tech-savvy person and love to actively seek out new technologies and stay up-to-date on industry trends and advancements. Contributions to my former Front End Web Developer role, and this field at-large, revolve around myessential talents in (HTML5, CSS3, JAVASCRIPT, BOOTSTRAP, JQUERY, Photoshop). I have developed strong abilities in communication and fostered a reputation as a key contributor through critical thinking and decision-making skills. As a team player, I am collaborative with peers and search for ways to integrate valuable insights . I have worked on two websites where I have used all these technologies to make them fully responsive, efficient, user-friendly, and used different animations in them.
Education & Skills
Conestoga College(Ontario)
Post Graduate Diploma (Computer Science Programing)


12/19/18 Have a planning introduction meeting Get 12 people who will each take an organizational seat Create committees of volunteers to start planning a mid-Feb party. create deadlines for the party steps get caterer availability membership committee - create the membership forms membership committee, work on the membership list infrastructure, how to get a form to a at-door person, how to make sure the bylaws are available, track membership start and end dates, no longer qualified (move out)list updates. How much will it cost the club to lease membership SW? is it worth it? start manual, go automated if club expands (?) communications committee, get the word out in BuildingLink. Investigate contact list SW - the club has to notify members about annual and special meetings, plus the communications team will be spreading the word about upcoming events. Need to be fully digital - how? finance committee, plan party budget, plan tickets cost (advance and at-door) finance committee, work on finance infrastructure (checking account, "books", PayPal account, other digital payment options. Taking money at the door for events, at the door for memberships, and both; at the bar for drinks. Also, donations to the club. Not charitable deductions, but appreciated! Plan to coordinate with event planning committee to be sure there is good communication between planning, finance, and the caterer/bartender about responsibilities for taking money. Maybe use a ticket system?)
get membership forms out get bylaws out to group lawyers.


{% extends 'base.html' %} {% block content %} {% from '_helpers.jinja' import render_field %} {% from '_common_fields.jinja' import render_notifications_field %}
Use the Basic method (default) where your watched sites don't need Javascript to render.
The Chrome/Javascript method requires a network connection to a running WebDriver+Chrome server, set by the ENV var 'WEBDRIVER_URL'.


Our global spread is a big part of our offer and means that our customers are never too far from one of our offices.Send us a message or contact our HQ. For urgent matters please call +506


geom_abline |
Add a line with specified slope and intercept to the plot. class geom_abline : ABLineAesthetics, LayerBase |
geom_area |
Display the development of quantitative values over an interval. This is the continuous analog of geom_bar. class geom_area : AreaAesthetics, LayerBase |
geom_bar |
Display a bar chart which makes the height of the bar proportional to the number of observed variable values, mapped to x axis. class geom_bar : BarAesthetics, CountStatAesthetics, LayerBase |
geom_bin2d |
Divide the plane into a grid and color the bins by the count of cases in them. class geom_bin2d : TileAesthetics, Bin2dStatAesthetics, Bin2dStatParameters, LayerBase |
geom_boxplot |
Display the distribution of data based on a five number summary ("minimum", first quartile (Q1), median, third quartile (Q3), and "maximum"), and "outlying" points individually. class geom_boxplot : BoxplotAesthetics, BoxplotParameters, BoxplotStatAesthetics, BoxplotStatParameters, LayerBase |
geom_contour |
Display contours of a 3d surface in 2d. class geom_contour : PathAesthetics, ContourStatAesthetics, ContourStatParameters, LayerBase |
geom_contourf |
Fill contours of a 3d surface in 2d. class geom_contourf : PolygonAesthetics, ContourStatAesthetics, ContourStatParameters, LayerBase |
geom_crossbar |
Display bars with horizontal median line. class geom_crossbar : CrossBarAesthetics, LayerBase |
geom_density |
Display a density estimate, which is a smoothed version of the histogram. class geom_density : AreaAesthetics, DensityStatAesthetics, DensityStatParameters, LayerBase |
geom_density2d |
Display density function contour. class geom_density2d : PathAesthetics, ContourStatAesthetics, Density2dStatAesthetics, Density2dStatParameters, LayerBase |
geom_density2df |
Fill density function contour. class geom_density2df : PolygonAesthetics, Density2dStatAesthetics, Density2dStatParameters, LayerBase |
geom_errorbar |
Error bars defined by an upper and lower value ymin and ymax. class geom_errorbar : ErrorBarAesthetics, LayerBase |
geom_freqpoly |
Display a line chart which makes the y value proportional to the number of observed variable values, mapped to x axis. class geom_freqpoly : LineAesthetics, BinStatParameters, LayerBase |
geom_histogram |
Display a 1d distribution by dividing variable mapped to x axis into bins and counting the number of observations in each bin. class geom_histogram : HistogramAesthetics, BinStatAesthetics, BinStatParameters, LayerBase |
geom_hline |
Add a straight horizontal line to the plot. class geom_hline : HLineAesthetics, LayerBase |
geom_image |
class geom_image : ImageAesthetics, LayerBase |
geom_jitter |
Jittered points, especially for discrete plots or dense plots. class geom_jitter : PointAesthetics, JitterParameters, LayerBase |
geom_line |
Connect points in the order of the variable on the x axis. In the case points need to be connected in the order in which they appear in the data, use 'geom_path'. class geom_line : LineAesthetics, LayerBase |
geom_linerange |
Display a line range defined by an upper and lower value. class geom_linerange : LineRangeAesthetics, LayerBase |
geom_map |
Display a filled closed path defined by the vertex coordinates of individual polygons. 'geom_map' is essentially the same as 'geom_polygon' but uses 'coord_map' as default coordinate system. class geom_map : PolygonAesthetics, WithSpatialParameters, LayerBase |
geom_path |
Connect observations in the order in which they appear in the data. class geom_path : PathAesthetics, WithSpatialParameters, LayerBase |
geom_point |
Draw points defined by an x and y coordinate. class geom_point : PointAesthetics, WithSizeUnitOption, WithSpatialParameters, LayerBase |
geom_pointrange |
Add a vertical line defined by upper and lower value with midpoint at y location. class geom_pointrange : PointRangeAesthetics, LayerBase |
geom_polygon |
Display a filled closed path defined by the vertex coordinates of individual polygons. class geom_polygon : PolygonAesthetics, WithSpatialParameters, LayerBase |
geom_raster |
Display rectangles defined by the center of the tile (x, y). This is a high performance special function for same-sized tiles. Much faster than geom_tile but doesn't support width/height and color. class geom_raster : RasterAesthetics, LayerBase |
geom_rect |
Display a rectangle defined by the four corners (xmin, xmax, ymin and ymax). class geom_rect : RectAesthetics, WithSpatialParameters, LayerBase |
geom_ribbon |
Display a y interval defined by ymin and ymax. class geom_ribbon : RibbonAesthetics, LayerBase |
geom_segment |
Draw a straight line segment between points (x, y) and (xend, yend). class geom_segment : SegmentAesthetics, LayerBase |
geom_smooth |
Add a smoothed conditional mean. class geom_smooth : SmoothAesthetics, SmoothStatParameters, LayerBase |
geom_step |
Connect observations in the order in which they appear in the data by stairs. class geom_step : LineAesthetics, LayerBase |
geom_text |
Add a text directly to the plot. class geom_text : TextAesthetics, TextParameters, WithSizeUnitOption, WithSpatialParameters, LayerBase |
geom_tile |
Display a rectangle defined by the center of the tile and its size (x, y, width, height). class geom_tile : TileAesthetics, LayerBase |
geom_vline |
Add a straight vertical line to the plot. class geom_vline : VLineAesthetics, LayerBase |


In this step, you will learn:
Estimated time to complete this step: 10 minutes.
To preview what you will complete in this step, jump down to the bottom of this page ↓.
A Chrome App contains these components:
Open your favorite code/text editor and create the following file named manifest.json:
{ "manifest_version": 2, "name": "Codelab", "version": "1", "icons": { "128": "icon_128.png" }, "permissions": [], "app": { "background": { "scripts": ["background.js"] } }, "minimum_chrome_version": "28" }
Notice how this manifest describes a background script named background.js. You will create that file next.
"background": { "scripts": ["background.js"] }
We'll supply you with an app icon later in this step:
"icons": { "128": "icon_128.png" },
Create the following file and save it as background.js:
/** * Listens for the app launching then creates the window * * @see http://developer.chrome.com/apps/app.window.html */ chrome.app.runtime.onLaunched.addListener(function() { chrome.app.window.create('index.html', { id: 'main', bounds: { width: 620, height: 500 } }); });
This background script simply waits for the chrome.app.runtime.onLaunched launch event for the application and executes the callback function:
chrome.app.runtime.onLaunched.addListener(function() { //... });
When the Chrome App is launched, chrome.app.window.create() will create a new window using a basic HTML page (index.html) as the source. You will create the HTML view in the next step.
chrome.app.window.create('index.html', { id: 'main', bounds: { width: 620, height: 500 } });
Background scripts may contain additional listeners, windows, post messages, and launch data — all of which are used by the event page to manage the app.
Create a simple web page to display a "Hello World" message to the screen and save it as index.html:
<!DOCTYPE html>   <meta charset="utf-8">
Hello, let's code!

Just like any other web page, within this HTML file you can include additional packaged JavaScript, CSS, or assets.
Right-click and save this 128x128 image to your project folder as icon_128.png:
You will use this PNG as our application's icon that users will see in the launch menu.
You should have these 4 files in your project folder now:
Use developer mode to quickly load and launch your app without having to finalize your app as a distribution package.
After loading your project as an unpacked extension, click Launch next to your installed app. A new standalone window should open up:
Congratulations, you've just created a new Chrome App!
You can use the Chrome Developer Tools to inspect, debug, audit, and test your app just like you do on a regular web page.
After you make changes to your code and reload your app (right-click > Reload App), check the DevTools console for any errors (right-click > Inspect Element).
(We'll cover the Inspect Background Page option in Step 3 with alarms.)
The DevTools JavaScript console has access to the same APIs available to your app. You can easily test an API call before adding it to your code:
For more detailed information about some of the APIs introduced in this step, refer to:
Ready to continue onto the next step? Go to Step 2 - Import an existing web app »


Inside New York retreat the Scribner’s Catskill Lodge
by Emily WrightThere is so much more to Scribner’s Catskill Lodge than a vintage hotel reinvigorated by a bold redesign. Now a Design Hotel, this 1960s motor lodge perched on the side of a winding mountain road in the Catskills region of upstate New York is a masterclass in clever repurposing.
The 38-bedroom US hotel has become well-known for its striking black exterior following its 2017 revamp by Brooklyn-based creative group Studio Tack. But the real wow-factor lies on the other side of the towering doors that make up the main entrance.
Once upon a time the vehicle access for the property, the doors open up into a former carport which has been redesigned to create a vast communal lounge area as far as the eye can see and out to the mountain vista beyond.
Beyond the reception desk, which is dwarfed by the height of the cavernous two-storey lobby, flagstones are eventually replaced by softer wooden floorboards which step up to a ski chalet-style lounge mezzanine. Carefully grouped pods of armchairs, sofas and bench seats are dotted in and around an old-school pool table, reading corners, shelves stacked with books, board games and old maps.
The space is anchored by a central indoor fireplace where a circular seating arrangement creates an intrinsically sociable configuration.
While the Prospect restaurant and bar is characterised by black-stained wood, the rooms are simple with light-coloured walls and ceilings. Most look out over the mountains, and their pale palette is punctuated by dark wood chairs inside and out (each suite has a private deck).
A homage to wholesome, outdoorsy living, every room also comes equipped with a s’mores pack consisting of chocolate, biscuits and marshmallows to be toasted on the open fire towards the back of the property as the sun goes down.


➀ Set up a template
Flexible Feedback lets you build a template and use it to efficiently write standardized feedback to students. You'll start by either creating a template, uploading an existing template, or using
our starter template. Hover over the symbols to learn more about each field type.
➁ Set up a class list
You have the option of setting up a class list. This will create a table on the next page in which you can store your feedback. This table can be exported as a PDF, Excel file, or Word document.
➂ Start writing
Once your template and class list are ready, click the USE button to start writing feedback.
➃ Use your template
Use the template to write feedback to each student. If you're using a class list, select the student from the dropdown and click SAVE to copy the feedback to the class
list. Click the COPY button to save the feedback to your clipboard. To edit your template, class list, or student feedback, click the EDIT button at any time.
➄ Save snippets to the bank
If you find yourself writing the same thing over and over, save it to the bank by highlighting text and clicking the SNIP button. You can save the bank to your computer
with the DOWNLOAD button and upload it again later with the UPLOAD button. You can edit
any snippets by double-clicking or delete a snippet using the eraser.


{% extends "global/Page.html" %} {% load otree static %} {% block title %} Now, please choose a firm to compete in {% endblock %} {% block scripts %} {% endblock %} {% block styles %} {% endblock %} {% block content %}
Make a choice by clicking the information environment (Firm A or B) you want to compete in. Please remember that
In Firm A: Competition begins after all participants observe each others’ scores from Part 1.
In Firm B: Participants do not observe each others’ scores from Part 1.
Please choose the firm you would like to join.
A
B
If you do not submit your answer within {{ pageTimeoutWording }}, you will not be allowed to participate in the remainder of the study.


|
CCCC Software Metrics Report
generated Fri Mar 18 00:12:51 2005 | |
|---|---|
Project Summary |
Summary table of high level measures summed over all files processed in the current run. |
Procedural Metrics Summary |
Table of procedural measures (i.e. lines of code, lines of comment, McCabe's cyclomatic complexity summed over each module. |
Object Oriented Design |
Table of four of the 6 metrics proposed by Chidamber and Kemerer in their various papers on 'a metrics suite for object oriented design'. |
Structural Metrics Summary |
Structural metrics based on the relationships of each module with others. Includes fan-out (i.e. number of other modules the current module uses), fan-in (number of other modules which use the current module), and the Information Flow measure suggested by Henry and Kafura, which combines these to give a measure of coupling for the module. |
Other Extents |
Lexical counts for parts of submitted source files which the analyser was unable to assign to a module. Each record in this table relates to either a part of the code which triggered a parse failure, or to the residual lexical counts relating to parts of a file not associated with a specific module. |
About CCCC |
A description of the CCCC program. |
| Metric | Tag | Overall | Per Module |
|---|---|---|---|
| Number of modules | NOM | 47 | |
| Lines of Code | LOC | 1483 | 31.553 |
| McCabe's Cyclomatic Number | MVG | 167 | 3.553 |
| Lines of Comment | COM | 674 | 14.340 |
| LOC/COM | L_C | 2.200 | |
| MVG/COM | M_C | 0.248 | |
| Information Flow measure ( inclusive ) | IF4 | 1010 | 21.489 |
| Information Flow measure ( visible ) | IF4v | 1010 | 21.489 |
| Information Flow measure ( concrete ) | IF4c | 5 | 0.106 |
| Lines of Code rejected by parser | REJ | 74 |
| Module Name | LOC | MVG | COM | L_C | M_C |
|---|---|---|---|---|---|
| ArrayList | 0 | 0 | 0 | ------ | ------ |
| Background | 42 | 7 | 25 | 1.680 | 0.280 |
| Board | 49 | 6 | 10 | 4.900 | 0.600 |
| BoardRenderer | 102 | 11 | 29 | 3.517 | 0.379 |
| BufferStrategy | 0 | 0 | 0 | ------ | ------ |
| Canvas | 0 | 0 | 0 | ------ | ------ |
| Character | 16 | 0 | 22 | ------ | ------ |
| Cloneable | 0 | 0 | 0 | ------ | ------ |
| Counter | 21 | 0 | 3 | 7.000 | ------ |
| Counter[][] | 0 | 0 | 0 | ------ | ------ |
| DepileMove | 23 | 0 | 2 | 11.500 | ------ |
| Exception | 0 | 0 | 0 | ------ | ------ |
| GUI | 100 | 10 | 49 | 2.041 | 0.204 |
| Game | 28 | 0 | 30 | 0.933 | ------ |
| GameCommand | 3 | 0 | 0 | ------ | ------ |
| GameLogic | 309 | 77 | 81 | 3.815 | 0.951 |
| GameOver | 4 | 0 | 1 | ------ | ------ |
| Graphics2D | 0 | 0 | 0 | ------ | ------ |
| HumanPlayer | 17 | 0 | 5 | ------ | ------ |
| IGameObject | 2 | 0 | 6 | ------ | ------ |
| IGameObserver | 1 | 0 | 3 | ------ | ------ |
| Image | 0 | 0 | 0 | ------ | ------ |
| InGame | 172 | 26 | 58 | 2.966 | 0.448 |
| InGameBackground | 31 | 8 | 4 | 7.750 | 2.000 |
| MainFrame | 86 | 4 | 145 | 0.593 | ------ |
| MouseEvent | 0 | 0 | 0 | ------ | ------ |
| MouseListener | 0 | 0 | 0 | ------ | ------ |
| MouseMotionListener | 0 | 0 | 0 | ------ | ------ |
| Move | 3 | 0 | 0 | ------ | ------ |
| NewGame | 10 | 0 | 1 | ------ | ------ |
| Object | 0 | 0 | 0 | ------ | ------ |
| PileUpMove | 10 | 0 | 2 | ------ | ------ |
| Player | 19 | 0 | 6 | ------ | ------ |
| SceneView | 33 | 1 | 39 | 0.846 | ------ |
| ScenesController | 68 | 6 | 39 | 1.744 | 0.154 |
| Screen | 41 | 1 | 53 | 0.774 | ------ |
| Sprite | 48 | 1 | 27 | 1.778 | ------ |
| Square | 68 | 7 | 5 | 13.600 | 1.400 |
| SquareOutOfBoardException | 11 | 0 | 0 | ------ | ------ |
| State | 19 | 0 | 0 | ------ | ------ |
| String | 0 | 0 | 0 | ------ | ------ |
| String[] | 0 | 0 | 0 | ------ | ------ |
| Tower | 53 | 2 | 26 | 2.038 | ------ |
| Transition | 14 | 0 | 1 | ------ | ------ |
| UndoLastMove | 3 | 0 | 0 | ------ | ------ |
| Vector | 0 | 0 | 0 | ------ | ------ |
| anonymous | 3 | 0 | 0 | ------ | ------ |
| Module Name | WMC1 | WMCv | DIT | NOC | CBO |
|---|---|---|---|---|---|
| ArrayList | 0 | 0 | 0 | 0 | 2 |
| Background | 4 | 0 | 0 | 1 | 3 |
| Board | 7 | 0 | 1 | 0 | 7 |
| BoardRenderer | 8 | 0 | 1 | 0 | 7 |
| BufferStrategy | 0 | 0 | 0 | 0 | 1 |
| Canvas | 0 | 0 | 0 | 1 | 1 |
| Character | 4 | 0 | 1 | 0 | 2 |
| Cloneable | 0 | 0 | 0 | 3 | 3 |
| Counter | 2 | 0 | 1 | 0 | 3 |
| Counter[][] | 0 | 0 | 0 | 0 | 1 |
| DepileMove | 3 | 0 | 2 | 0 | 2 |
| Exception | 0 | 0 | 0 | 1 | 1 |
| GUI | 7 | 0 | 1 | 0 | 10 |
| Game | 8 | 0 | 0 | 1 | 2 |
| GameCommand | 0 | 0 | 0 | 4 | 9 |
| GameLogic | 20 | 0 | 1 | 0 | 10 |
| GameOver | 0 | 0 | 1 | 0 | 1 |
| Graphics2D | 0 | 0 | 0 | 0 | 1 |
| HumanPlayer | 3 | 0 | 2 | 0 | 4 |
| IGameObject | 2 | 0 | 0 | 4 | 4 |
| IGameObserver | 1 | 0 | 0 | 3 | 5 |
| Image | 0 | 0 | 0 | 0 | 1 |
| InGame | 13 | 0 | 1 | 0 | 8 |
| InGameBackground | 2 | 0 | 1 | 0 | 2 |
| MainFrame | 11 | 0 | 1 | 0 | 8 |
| MouseEvent | 0 | 0 | 0 | 0 | 1 |
| MouseListener | 0 | 0 | 0 | 1 | 1 |
| MouseMotionListener | 0 | 0 | 0 | 1 | 1 |
| Move | 0 | 0 | 1 | 2 | 7 |
| NewGame | 1 | 0 | 1 | 0 | 2 |
| Object | 0 | 0 | 0 | 0 | 4 |
| PileUpMove | 1 | 0 | 2 | 0 | 2 |
| Player | 5 | 0 | 1 | 1 | 6 |
| SceneView | 12 | 0 | 0 | 1 | 4 |
| ScenesController | 10 | 0 | 1 | 0 | 6 |
| Screen | 9 | 0 | 0 | 0 | 3 |
| Sprite | 6 | 0 | 0 | 0 | 8 |
| Square | 11 | 0 | 0 | 0 | 7 |
| SquareOutOfBoardException | 2 | 0 | 1 | 0 | 2 |
| State | 5 | 0 | 0 | 0 | 5 |
| String | 0 | 0 | 0 | 0 | 10 |
| String[] | 0 | 0 | 0 | 0 | 1 |
| Tower | 7 | 0 | 1 | 0 | 3 |
| Transition | 3 | 0 | 0 | 0 | 3 |
| UndoLastMove | 0 | 0 | 1 | 0 | 1 |
| Vector | 0 | 0 | 0 | 0 | 1 |
| anonymous | 1 | 0 | 0 | 0 | 0 |
| Module Name | Fan-out | Fan-in | IF4 | vis | con | inc | vis | con | incl | vis | con | inc |
|---|---|---|---|---|---|---|---|---|---|
| ArrayList | 2 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 |
| Background | 2 | 1 | 2 | 1 | 0 | 1 | 4 | 0 | 4 |
| Board | 2 | 0 | 2 | 5 | 1 | 5 | 100 | 0 | 100 |
| BoardRenderer | 1 | 0 | 1 | 6 | 2 | 6 | 36 | 0 | 36 |
| BufferStrategy | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Canvas | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Character | 0 | 0 | 0 | 2 | 1 | 2 | 0 | 0 | 0 |
| Cloneable | 3 | 3 | 3 | 0 | 0 | 0 | 0 | 0 | 0 |
| Counter | 1 | 0 | 1 | 2 | 1 | 2 | 4 | 0 | 4 |
| Counter[][] | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| DepileMove | 0 | 0 | 0 | 2 | 1 | 2 | 0 | 0 | 0 |
| Exception | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| GUI | 1 | 0 | 1 | 9 | 2 | 9 | 81 | 0 | 81 |
| Game | 2 | 1 | 2 | 0 | 0 | 0 | 0 | 0 | 0 |
| GameCommand | 9 | 4 | 9 | 0 | 0 | 0 | 0 | 0 | 0 |
| GameLogic | 2 | 0 | 2 | 8 | 1 | 8 | 256 | 0 | 256 |
| GameOver | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 0 |
| Graphics2D | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| HumanPlayer | 0 | 0 | 0 | 4 | 1 | 4 | 0 | 0 | 0 |
| IGameObject | 4 | 4 | 4 | 0 | 0 | 0 | 0 | 0 | 0 |
| IGameObserver | 4 | 3 | 4 | 1 | 0 | 1 | 16 | 0 | 16 |
| Image | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| InGame | 2 | 0 | 2 | 6 | 1 | 6 | 144 | 0 | 144 |
| InGameBackground | 0 | 0 | 0 | 2 | 1 | 2 | 0 | 0 | 0 |
| MainFrame | 0 | 0 | 0 | 8 | 3 | 8 | 0 | 0 | 0 |
| MouseEvent | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| MouseListener | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| MouseMotionListener | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Move | 6 | 2 | 6 | 1 | 1 | 1 | 36 | 4 | 36 |
| NewGame | 0 | 0 | 0 | 2 | 1 | 2 | 0 | 0 | 0 |
| Object | 4 | 0 | 4 | 0 | 0 | 0 | 0 | 0 | 0 |
| PileUpMove | 0 | 0 | 0 | 2 | 1 | 2 | 0 | 0 | 0 |
| Player | 2 | 1 | 2 | 4 | 1 | 4 | 64 | 1 | 64 |
| SceneView | 2 | 1 | 2 | 2 | 0 | 2 | 16 | 0 | 16 |
| ScenesController | 1 | 0 | 1 | 5 | 1 | 5 | 25 | 0 | 25 |
| Screen | 1 | 0 | 1 | 2 | 0 | 2 | 4 | 0 | 4 |
| Sprite | 6 | 0 | 6 | 2 | 0 | 2 | 144 | 0 | 144 |
| Square | 6 | 0 | 6 | 1 | 0 | 1 | 36 | 0 | 36 |
| SquareOutOfBoardException | 0 | 0 | 0 | 2 | 1 | 2 | 0 | 0 | 0 |
| State | 2 | 0 | 2 | 3 | 0 | 3 | 36 | 0 | 36 |
| String | 10 | 0 | 10 | 0 | 0 | 0 | 0 | 0 | 0 |
| String[] | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Tower | 1 | 0 | 1 | 2 | 1 | 2 | 4 | 0 | 4 |
| Transition | 1 | 0 | 1 | 2 | 0 | 2 | 4 | 0 | 4 |
| UndoLastMove | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 0 |
| Vector | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| anonymous | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
This report was generated by the program CCCC, which is FREELY REDISTRIBUTABLE but carries NO WARRANTY.
CCCC was developed by Tim Littlefair. as part of a PhD research project. This project is now completed and descriptions of the findings can be accessed at http://www.chs.ecu.edu.au/~tlittlef.
User support for CCCC can be obtained by mailing the list<EMAIL_ADDRESS>Please also visit the CCCC development website at http://cccc.sourceforge.net.


Boss VS Players gamemode options
Volume (Music)
-
100
+
Volume (Sound Effect)
-
100
+
Languages
Boss Points (+ points == more chance to be boss)
100
Reset


March 19
FIRST READING 2 Samuel 7:4-5.12-14.16
In those days: The word of the LORD came to Nathan,
"Go and tell my servant David, 'Thus says the LORD: When your days
are fulfilled and you lie down with your fathers, I will raise
up your offspring after you, who shall come forth from your body, and I will
establish his kingdom. He shall build a house for my name, and I will establish
the throne of his kingdom for ever. I will be his father, and he shall be my
son. And your house and your kingdom shall be made sure for ever before me;
your throne shall be established for ever.'"
The word of the Lord
RESPONSORIAL PSALM Psalm 89
R. His descendants shall continue for ever.
I will sing for ever of your mercies, O LORD;
through all ages my mouth will proclaim your fidelity. I have declared your
mercy is established for ever; your fidelity stands firm as the heavens.
R. His descendants shall continue for ever.
'With my chosen one I have made a covenant; I have
sworn to David my servant: I will establish your descendants for ever, and set
up your throne through all ages.'
R. His descendants shall continue for ever.
He will call out to me: 'You are my father, my God,
the rock of my salvation.' I will keep my faithful love for him always; with
him my covenant shall last.
R. His descendants shall continue for ever.
SECOND READING Romans 4:13.16-18.22
Brethren: The promise to Abraham and his
descendants, that they should inherit the world, did not come through the law
but through the righteousness of faith. That is why all depends on faith, in
order that the promise may rest on grace and be guaranteed to all his descendants--
not only to the adherents of the law but also to those who share the faith of
Abraham, for he is the father of us all, as it is written, "I have made
you the father of many nations" --in the presence of the God in whom he
believed, who gives life to the dead and calls into existence the things that
do not exist. In hope he believed against hope, that he should become the
father of many nations; as he had been told, "So shall your descendants
be." That is why his faith was "reckoned to him as righteousness."
The word of the Lord
ALLELUIA Psalm 84:5
R. Alleluia. Blessed are they who dwell in your house, O Lord, for ever singing your praise. R. Alleluia.
GOSPEL Matthew 1:16.18-21.24 (or Luke 2:41-51)
Jacob was the father of Joseph the husband of Mary,
of whom Jesus was born, who is called Christ. Now the birth of Jesus
Christ took place in this way.   When Joseph woke from sleep, he did
as the angel of the Lord commanded him.
Alternative GOSPEL
The parents of Jesus went to
The Gospel of the Lord


I am a tool window with HorizontalAlign set to Left and VerticalAlign set to Middle. My settings are listed below:
<ToolWindow demo_leftmiddle_tw> VerticalAlign Middle HorizontalAlign Left Width 2in Height 2in Right 0px </ToolWindow>


---
layout: page
title: "What is on my reading list"
description: "This page shows books I am currently reading or have read, feel free to recommend new ones"
---
On this page are books that I have read or intend to. From time to time after finishing each book, I write a short summary on the main blog. I love to read books that focus a bit on philosophy, tech, contemporary and ancient plays, business, motivation, non fiction...basically a bit of everything. (I love reading about ideas contrary to my beliefs too. Go figure).
December 2018
Atomic Habits by James Clear.
January 2019
Ready Player One by Ernest Cline
February 2019
Why nations fail by Daron Acemoglu and James A. Robinson
What I intend to read next:
- The Pragmatic Programmer by Andrew Hunt
- A Guide to the Good Life
- A Mind for numbers
- Thinking in Bets: Making Smarter Bets When you Don’t Have All the Cards
I welcome suggestions on what to read next. Please feel free to DM me on Twitter
@therealchiko or write to
<EMAIL_ADDRESS>with any books you have enjoyed that are worth considering.


INDXBIB(1) INDXBIB(1) NAME indxbib - make inverted index for bibliographic databases SYNOPSIS indxbib [ -vw ] [ -cfile ] [ -ddir ] [ -ffile ] [ -hn ] [ -istring ] [ -kn ] [ -ln ] [ -nn ] [ -ofile ] [ -tn ] [ filename... ] It is possible to have whitespace between a command line option and its parameter. DESCRIPTION indxbib makes an inverted index for the bibliographic databases in file‐ name... for use with refer(1), lookbib(1), and lkbib(1). The index will be named filename.i; the index is written to a temporary file which is then renamed to this. If no filenames are given on the command line because the -f option has been used, and no -o option is given, the index will be named Ind.i. Bibliographic databases are divided into records by blank lines. Within a record, each fields starts with a % character at the beginning of a line. Fields have a one letter name which follows the % character. The values set by the -c, -n, -l and -t options are stored in the index; when the index is searched, keys will be discarded and truncated in a manner appropriate to these options; the original keys will be used for verifying that any record found using the index actually contains the keys. This means that a user of an index need not know whether these options were used in the creation of the index, provided that not all the keys to be searched for would have been discarded during indexing and that the user supplies at least the part of each key that would have remained after being truncated during indexing. The value set by the -i option is also stored in the index and will be used in verifying records found using the index. OPTIONS -v Print the version number. -w Index whole files. Each file is a separate record. -cfile Read the list of common words from file instead of /usr/share/groff/1.21/eign. -ddir Use dir as the pathname of the current working directory to store in the index, instead of the path printed by pwd(1). Usually dir will be a symbolic link that points to the directory printed by pwd(1). -ffile Read the files to be indexed from file. If file is -, files will be read from the standard input. The -f option can be given at most once. -istring Don't index the contents of fields whose names are in string. Initially string is XYZ. -hn Use the first prime greater than or equal to n for the size of the hash table. Larger values of n will usually make searching faster, but will make the index larger and indxbib use more mem‐ ory. Initially n is 997. -kn Use at most n keys per input record. Initially n is 100. -ln Discard keys that are shorter than n. Initially n is 3. -nn Discard the n most common words. Initially n is 100. -obasename The index should be named basename.i. -tn Truncate keys to n. Initially n is 6. FILES filename.i Index. Ind.i Default index name. /usr/share/groff/1.21/eign List of common words. indxbibXXXXXX Temporary file. SEE ALSO refer(1), lkbib(1), lookbib(1) Groff Version 1.21 31 December 2010 INDXBIB(1)


Spatial Analysis for exploration of Pakistan Population Census 2017 (<http://www.pbscensus.gov.pk/>). It uses data from R package 'PakPC2017'.
| Version: | 0.2.0 |
| Depends: | R (≥ 3.1) |
| Imports: | dplyr, ggplot2, htmltools, htmlwidgets, leaflet, magrittr, PakPC2017, rgdal, scales, shiny, tidyr, tmap |
| Suggests: | testthat |
| Published: | 2018-03-07 |
| Author: | Muhammad Yaseen [aut, cre], Muhammad Arfan Dilber [aut, ctb] |
| Maintainer: | Muhammad Yaseen <myaseen208 at gmail.com> |
| License: | GPL-3 |
| URL: | https://github.com/MYaseen208/ppcSpatial |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | ppcSpatial results |
| Reference manual: | ppcSpatial.pdf |
| Package source: | ppcSpatial_0.2.0.tar.gz |
| Windows binaries: | r-devel: ppcSpatial_0.2.0.zip, r-release: ppcSpatial_0.2.0.zip, r-oldrel: ppcSpatial_0.2.0.zip |
| OS X binaries: | r-release: ppcSpatial_0.2.0.tgz, r-oldrel: ppcSpatial_0.2.0.tgz |
| Old sources: | ppcSpatial archive |
Please use the canonical form https://CRAN.R-project.org/package=ppcSpatial to link to this page.


Read this in other languages:
English, ???, Français.
The objective of this lab is to provide you an intro to using IBM QRadar and automating it with Ansible, and to give you a deeper understanding and hands on experience how to automate security tools used by security operators. For that we will tackle three security use cases rather typical for the day-to-day challenges of security operatos. While all of them will interact with roughly the same toolset, each use case shows a different perspective (security analyst, firewall operator, IDS specialist) and thus a different point of view on the available tools.
We have set up a common set of security related tools:
The exercises of the first section of this lab guide you through each individual solution mentioned above. You will learn how to access them, what they are used for and how to interact with them using Ansible.
The exercises of the second section of this lab are focused on the actual security operations use cases: situations in which a certain challenge has to be met, usually by interacting not only with one of the mentioned solutions above, but with a mix of them. After setting forth the challenge and explaining what tasks need to be done manually to solve the situation, the lab walks through the steps to automate the tasks with Ansible.
In this lab you work in a pre-configured lab environment. You will have access to the following hosts and services:
TODO: continue...
If you want to try QRadar in your own setup, install the Coomunity Edition, or apply for a Cloud trail.
TODO: continue...
In this lab you work in a pre-configured lab environment. You will have access to the following hosts and services:
| Role | Inventory name |
|---|---|
| Ansible Control Host | ansible |
| IBM QRadar | qradar |
| Attacker | attacker |
| Snort | snort |
| Check Point Management Server | checkpoint |
| Check Point Gateway | - |
| Windows Workstation | windows-ws |
The lab is set up individually for you. You have your own environment, own services, own virtual machines.
For the exercises of section 2 we need to have security incidents. Those should happen on a target machine - that is Snort server. It is basically a RHEL installation with Snort installed and running a simplified web server to run attacks against.
All automation is done from the Ansible control host, a Red Hat Enterprise Linux machine. To make access to the control host and managing files on it easier there is a online version of VS Code editor installed directly on the control host. This way it can be accessed via a normal web browser. Commands can be executed right from the terminal within the VS Code editor.
Let’s access the Visual Studio Code. Click on the link for VS Code access from the workshop page:
At this point, you will see a Welcome page:
From within this environment, you can create and modify files or open a terminal and execute commands.
So let’s open a new terminal in VS Code. In the menu bar, click on Terminal > New Terminal.
A new terminal will be opened in the lower part of your editor and you will be at the command prompt. Note that most prerequisite tasks have already been done for you:
Ansible software is installed
SSH connection and keys are configured
sudo
has been configured on the managed hosts to run commands that require root privileges.
Note that each student is assigned a student number, i.e. X and you should work as the student
Next, proceed to check that Ansible has been installed correctly.
[student<X>@ansible ~]$ ansible --version
The result should resemble the following:
Note
Ansible is keeping configuration management simple. Ansible requires no database or running daemons and can run easily on a laptop. On the managed hosts it needs no running agent.
Let’s open a file in VS Code. In the menu bar, click on File, Open File. In the middle of the screen, a drop down menu opens with the available file content of the home directory of your user:
Pick lab_inventory, this will immediately update the file list. In the new file list, pick hosts. This will open the inventory of your environment.
As you see, the inventory of your environment is provided in a static, ini-type file. It looks like the following listing. Please note that the IP addresses provided here are just an example and will be different in your lab environment:
[all:vars]
ansible_user=student1
ansible_ssh_pass=ansible
ansible_port=22
[attack]
attacker ansible_host=<IP_ADDRESS> ansible_user=ec2-user private_ip=<IP_ADDRESS> private_ip2=<IP_ADDRESS>
[control]
ansible ansible_host=<IP_ADDRESS> ansible_user=ec2-user private_ip=<IP_ADDRESS>
[siem]
qradar ansible_host=<IP_ADDRESS> ansible_user=admin private_ip=<IP_ADDRESS> ansible_httpapi_pass="Ansible1!" ansible_connection=httpapi ansible_httpapi_use_ssl=yes ansible_httpapi_validate_certs=False ansible_network_os=ibm.qradar.qradar
[ids]
snort ansible_host=<IP_ADDRESS> ansible_user=ec2-user private_ip=<IP_ADDRESS> private_ip2=<IP_ADDRESS>
[firewall]
checkpoint ansible_host=<IP_ADDRESS> ansible_user=admin private_ip=<IP_ADDRESS> ansible_network_os=checkpoint ansible_connection=httpapi ansible_httpapi_use_ssl=yes ansible_httpapi_validate_certs=no
[windows]
windows-ws ansible_host=<IP_ADDRESS> ansible_user=Administrator ansible_pass=RedHat19! ansible_port=5986 ansible_connection=winrm ansible_winrm_server_cert_validation=ignore private_ip=<IP_ADDRESS>
All the IP addresses are specific to your environment. Whenever the exercises ask you to access a certain machine, you can always look up the IP in the inventory on the control host.
Ansible is already configured to use the inventory specific to your environment. As shown in the example above, the inventory carries more than just the host names and IP addresses. Especially in the case of the Windows workstation, several more parameters are set.
Note
Not all hosts in your lab can be reached via SSH or WinRM. Some are accessed via REST API, RDP or web browser. During the exercises, each node type will be explained in detail and how to access the resources will be shown step by step.
You might have guessed by now this lab is pretty commandline-centric…? So we recommend that you don’t type everything manually, use copy & paste from the browser when appropriate. But stop to think and understand.


Christmas No 1? Dublin railway station duo reunited to sing on Ray D'Arcy Show
by By Steve NevilleTwo teenagers who were recorded signing in Connolly Station earlier this month have been reunited.
Darragh Smith was recorded singing at the piano in the station when he was spontaneously joined by Stephanie Sarpong.
Last night RTÉ reunited the pair to perform the same song - Say Something by A Great Big World and Christina Aguilera - on The Ray D'Arcy Show.
Following their performance, D'Arcy revealed that they have organised for Darragh and Stephanie to record the song in Temple Lane Studios.
Viewers of the performance were full of praise for the duo, with some tipping a recorded version to be a Christmas Number 1.
READ MORE
'Amazing' Sinéad Burke praised following 'intelligent' and 'articulate' Late Late interview


Hello, I’m a Ruby on Rails full-stack web developer based in Bogotá, Colombia. For the past year, I've been focusing on improving my programming skills, which was an excellent decision since I like to go beyond my limits and programming allows me to do that. Working with different people in different scenarios makes this career worth it every single day.
Career semipresencial currently in progress (2019 - 2020)
I'm learning about HTML5, CSS, Javascript, Git, Flexbox, Heroku, Canvas, Protocolo HTTP, Api's REST, Node Js, Express, MySQL, Docker for 7 mounths approximately.
WEB developer intensive bootcamp - Graduated: 2017 - December
I was studying for 12 weeks, HTML5, CSS3, Javascript, Jquery, Ruby, Ruby on Rails, MySQL, Postgres and GitHub, testing techniques and deploying different services such as Heroku.
WEB developer - Graduated: 2017 - August
I was studying online for 5 months on topics in Front end, such as HTML5, CSS3, Javasript, JQuery.
Some of my projects and products
JR. Web Developer - From: July 2019 to: September 2019
Jr. Web Developer responsible of designing and implementing new features from scratch using technologies as HTML5, CSS3, Bootstrap, Js, jQuery, Worked remotely using tools such as Github.
Assitent Mentor Full-stack Developer - From: Octuber 2018 to: July 2019
Help to students in the version of Make It Real Full Stack WEB Developer Bootcamp which took place in Bogotá.
JR. Web Developer - From: April 2018 to: October 2018
Pipedocs is a web app that allows companies to organize their knowledge base in a effortless and beautiful way across multiple devices.
Star is a complex program to study.
This app's are builting using Ruby, Rails and JavaScript. I'm in charge of fixing bugs, creating new features and writing automated tests using technologies such as Minitest and Capybara.Ready to start your next project with me? That's great! Give me a call or send me an email and I will get back to you as soon as possible!


(current)
ONBİR
Match Links:
#
Link Header
Iframe Size
Iframe Scrollable
Actions
Edit
Preview
Add New Link:
Add match link
Match Details
×
Are you want to delete this link?
Match Details
×
Iframe Scrolling:
Link Update
×
Iframe scrolling: