This section comes together with the previous section Differential Expression. The basic strategy singleCellTK (SCTK) uses to find biomarkers is to iteratively identify the significantly up-regulated features of each group of cells against all the other cells. This means, the function we have (runFindMarker()
) is a wrapper of functions that do differential expression (DE) analysis, which would be invoked in a loop. For the detail of the DE functions and DE computation methods, please refer to the Differential Expression documentation.
To view detailed instructions on how to use these methods, please select ‘Interactive Analysis’ for shiny application or ‘Console Analysis’ for using these methods on R console from the tabs below:
Entry of The Panel
From anywhere of the UI, the panel for marker finding can be accessed from the top navigation panel at the circled tab shown below.
The UI is constructed in a sidebar pattern. The sidebar on the left is mainly for the parameters essential for running the marker finding algorithm. The main panel on the right is for demonstrating the results, including the marker table and the heatmap visualization.
Main Panel - Result Table
The table is shown in the figure above. In this tab, there will be a table for all the markers detected and passed the filters. It is constructed with 5 columns, including “Gene” - the default feature identifiers (not necessarily a gene ID or symbol, depending on the background SCE object); “Log2_FC”, “Pvalue” and “FDR” - the statistics that supports the detection; and the fifth one that labels which cluster the marker is for, and the column name is exactly the “cluster annotation” selected in the sidebar. Users can also download the table in comma-separated value (CSV) format, by clicking “Download Result Table” button.
Main Panel - Heatmap
A heatmap will be automatically generated after running the marker detection process. Users can tweak the options for plotting by clicking on the blue clog button on the top-left.
N
markers, as N
is the input numeric value in the numeric input below the checkbox, for each cluster will be plotted. The ranking is based on Log2FC value. When less than N
markers are detected for one cluster, all of them will be plotted.Parameters
As per SCTK’s strategy, the primary input is limited to an SingleCellExperiment (SCE) object, which has been through preprocessing steps with cluster labels annotated. While the iteration is a fixed pattern, the parameters needed are rather simple:
sce <- runFindMarker(inSCE = sce, useAssay = "logcounts", cluster = "cluster", covariates = NULL, log2fcThreshold = 0.25, fdrThreshold = 0.05)
Here all arguments execpt the input SCE object (inSCE
) are set by default. method
can only be chosen from the table above. cluster
and covariates
should be given a single string which is present in names(colData(inSCE))
. cluster
is required for grouping cells, while covariates
is optional for DE detection. log2fcThreshold
and fdrThreshold
are numeric and has to be set in plausible range. log2fcThrshold
has to be positive and fdrThreshold
has to be greater than zero and less than one.
The returned SCE object will contain the updated information of the markers identified in its metadata
slot.
Preprocessing
The preprocessing for obtaining cluster assignment was done using the exactly same workflow presented in the A La Carte Workflow Tutorial.
library(singleCellTK)
sce <- importExampleData("pbmc3k")
sce <- runPerCellQC(sce, mitoRef = "human", mitoIDType = "symbol", mitoGeneLocation = "rownames")
sce <- subsetSCECols(sce, colData = c('total > 600', 'detected > 300', 'mito_percent < 5'))
sce <- scaterlogNormCounts(sce, useAssay = "counts", assayName = "logcounts")
sce <- runModelGeneVar(sce, useAssay = "logcounts")
sce <- setTopHVG(sce, method = "modelGeneVar")
sce <- scaterPCA(inSCE = sce, useAssay = "logcounts", useFeatureSubset = "HVG_modelGeneVar2000",
reducedDimName = "PCA", seed = 12345)
sce <- runScranSNN(sce, useReducedDim = "PCA", nComp = 10, k = 14,
weightType = "jaccard", clusterName = "cluster", seed = 12345)
sce <- runUMAP(sce, useReducedDim = "PCA", initialDims = 10, reducedDimName = "UMAP", seed = 12345)
And we can visualize the cell populations on the UMAP with cluster labeled.
plotSCEDimReduceColData(sce, colorBy = "cluster", reducedDimName = "UMAP")
Get Markers
Then we call runFindMarker()
on the clustered data, with the cluster annotation just obtained, "cluster"
.
sce <- runFindMarker(inSCE = sce, useAssay = "logcounts", cluster = "cluster")
Results
After successfully running runFindMarker()
, the result marker table would be stored in metadata(sce)
. This table can be fetched by getFindMarkerTopTable()
. Argument topN
controls how many top markers, that pass filters, to include for each clsuter.
getFindMarkerTopTable(sce, log2fcThreshold = 0, minClustExprPerc = 0.5, topN = 1)
## Gene Log2_FC Pvalue FDR cluster clusterExprPerc
## 8764 IL7R 0.8117772 9.627633e-63 5.253157e-59 1 0.7500000
## 309761 NOSIP 0.5887454 1.941718e-38 6.553399e-36 2 0.6821561
## 1956 S100A9 4.3853548 2.397248e-207 3.924055e-203 3 0.9977064
## 30657 CD79A 2.2532545 1.452148e-151 1.188511e-147 4 0.9257143
## 26825 CCL5 3.0924934 1.691729e-148 5.538382e-144 5 0.9712644
## 106091 LST1 2.8683989 1.038405e-98 1.133177e-94 6 1.0000000
## 310761 NKG7 4.2398710 3.256027e-82 1.065958e-77 7 1.0000000
## 288182 CST3 3.2975861 2.221917e-16 1.039159e-12 8 1.0000000
## 7697 PPBP 5.9620589 9.423341e-07 2.504757e-03 9 1.0000000
## ControlExprPerc clusterAveExpr
## 8764 0.31156265 1.266208
## 309761 0.36716132 1.069871
## 1956 0.23094477 4.733569
## 30657 0.04172156 2.296094
## 26825 0.21676174 3.470436
## 106091 0.30477759 3.454109
## 310761 0.25687702 4.781861
## 288182 0.39113680 4.371755
## 7697 0.02406417 5.989445
Similarly to the Differential Expression section, we also provide a automated and organized heatmap plotting for the markers:
plotFindMarkerHeatmap(sce, log2fcThreshold = 0, minClustExprPerc = 0.5, maxCtrlExprPerc = 0.5, rowLabel = TRUE)
Note that when plotting the heatmap, the genes that are identified as up-regulated in multiple clusters will be considered only for the one cluster with the highest fold-change, while all of them are still kept in the table in metadata
.


If you use and like this project push it higher with a donation :D
Donate with Paypal
favorite
Note: Donations help this project to grow up with new features and keep motivation on top! Remember that StravistiX is done on free time while you are running or cycling :) Doing the best with passion !! Waiting for your help ;)


World
This is an example component.
- Alice is Cool
- Bob is Neat
Call arbitrary JS, but be careful! Change the scope to make `name` be Eve!
Hello, my friend, World. Custom content goes here: Use components that encapsulate some code
Also, you can inject contents into components here:


| Input | Output |
|---|---|
| 2 C E 5 C E 4 C E 3 D D D X | EMPTY NOT EMPTY FULL FULL 4 5 EMPTY |
| 1 E 10 D E 4 D D E 4 E 5 C D D X | 10 4 EMPTY FULL FULL 4 EMPTY |
| 10 E 1 E 2 E 3 E 4 E 5 E 6 D D C E 7 E 8 E 9 E 0 E 5 C E 6 C D D D D D D D D E 4 E 5 D D D D C X | 6 5 NOT EMPTY NOT EMPTY FULL 6 5 0 9 8 7 4 3 5 4 2 1 EMPTY |
| 5 E 10 E 20 E 30 E 40 E 50 E 60 E 70 E 80 E 90 E 100 D D D C D D D D C D D D C X | FULL FULL FULL FULL FULL 50 40 30 NOT EMPTY 20 10 EMPTY EMPTY EMPTY EMPTY EMPTY EMPTY EMPTY |
| 12 E 1 E 2 E 3 E 4 D D D D X | 4 3 2 1 |
| 3 E 1 C E 2 C E 3 C E 4 C D D D D X | NOT EMPTY NOT EMPTY FULL FULL FULL 3 2 1 EMPTY |
| Input | Output |
|---|---|
| 7 a < < b c > d | a ba bca bcad |
| 8 a < > > b c < d | a ab abc abdc |
| 4 a b c d | a ab abc abcd |
| 7 p < q < r < s | p qp rqp srqp |
| 8 a < t < c < > d | a ta cta cdta |
| 10 r s t < > < < > < 5 | r rs rst r5st |
| Input | Output |
|---|---|
| 3 4 1 1 1 1 1 1 0 1 1 0 1 0 | 2 (1,1) |
| 4 5 1 1 1 1 1 1 0 0 0 1 0 1 0 0 0 0 0 1 1 0 | 3 (1,0) |
| 6 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 | 1 (3,4) |
| 8 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 | 0 (-1,-1) |
| 8 5 0 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 1 | 4 (2,1) |
| 6 6 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 | 6 (0,0) |
| Input | Output |
|---|---|
| 2 C E 5 C E 4 C E 3 D D D X | EMPTY NOT EMPTY FULL FULL 5 4 EMPTY |
| 1 E 10 D E 4 D D E 4 E 5 C D D X | 10 4 EMPTY FULL FULL 4 EMPTY |
| 10 E 1 E 2 E 3 E 4 E 5 E 6 D D C E 7 E 8 E 9 E 0 E 5 C E 6 C D D D D D D D D E 4 E 5 D D D D C X | 1 2 NOT EMPTY NOT EMPTY FULL 3 4 5 6 7 8 9 0 5 6 4 5 EMPTY |
| 5 E 10 E 20 E 30 E 40 E 50 E 60 E 70 E 80 E 90 E 100 D D D C D D D D C D D D C X | FULL FULL FULL FULL FULL 10 20 30 NOT EMPTY 40 50 EMPTY EMPTY EMPTY EMPTY EMPTY EMPTY EMPTY |
| 12 E 1 E 2 E 3 E 4 D D D D X | 1 2 3 4 |
| 3 E 1 C E 2 C E 3 C E 4 C D D D D X | NOT EMPTY NOT EMPTY FULL FULL FULL 1 2 3 EMPTY |
| Input | Output |
|---|---|
| ABCD ) ( < ( # | ABCD ABC AC |
| ABC < < < < ( ) ) # | ABC BC C |
| Hello ESC101 < < ) > > > ( ( ( # | Hello ESC11 Hello ESC1 Hello ESC Hello ES |
| Hi Mr C ) ( ( ( ( < < < ) # | Hi Mr C Hi Mr Hi Mr Hi M Hi i |
| 123456890 < < < > > < ) ) ) ) ) < < < ( ( ) # | 12345680 1234568 1234568 1234568 1234568<PHONE_NUMBER>8 1268 |
| 12345 < < < < < ) ) ) # | 2345 345 45 |
| Input | Output |
|---|---|
| 3 4 1 1 1 1 1 1 0 1 1 0 1 0 | 9 0 9 |
| 4 5 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 | 10 0 10 |
| 5 6 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 | 5 1 5 |
| 10 2 1 0 1 0 1 0 1 0 1 0 1 1 1 1 1 1 1 1 1 1 | 15 0 14 |
| 6 3 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0 1 | 8 0 8 |
| 6 3 1 0 1 0 1 0 1 0 1 0 0 0 1 0 0 0 0 1 | 7 1 6 |
| Input | Output |
|---|---|
| 5 1 0 2 0 3 0 4 0 1 2 1 3 1 4 2 4 -1 -1 | 1 NODES SENT NO MESSAGES 1 NODES RECEIVED NO MESSAGES MAX 4 MESSAGES SENT BY NODE 1 MAX 4 MESSAGES RECEIVED BY NODE 0 |
| 4 1 3 1 0 1 2 -1 -1 | 3 NODES SENT NO MESSAGES 1 NODES RECEIVED NO MESSAGES MAX 3 MESSAGES SENT BY NODE 1 MAX 1 MESSAGES RECEIVED BY NODE 0 |
| 10 2 8 5 1 2 9 1 7 1 4 3 8 1 7 2 8 1 4 2 6 -1 -1 | 6 NODES SENT NO MESSAGES 4 NODES RECEIVED NO MESSAGES MAX 4 MESSAGES SENT BY NODE 1 MAX 3 MESSAGES RECEIVED BY NODE 8 |
| 10 -1 -1 | 10 NODES SENT NO MESSAGES 10 NODES RECEIVED NO MESSAGES MAX 0 MESSAGES SENT BY NODE 0 MAX 0 MESSAGES RECEIVED BY NODE 0 |
| 10 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 -1 -1 | 9 NODES SENT NO MESSAGES 9 NODES RECEIVED NO MESSAGES MAX 8 MESSAGES SENT BY NODE 4 MAX 8 MESSAGES RECEIVED BY NODE 4 |
| 15 14 13 13 12 12 11 11 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 0 0 14 -1 -1 | 0 NODES SENT NO MESSAGES 0 NODES RECEIVED NO MESSAGES MAX 1 MESSAGES SENT BY NODE 0 MAX 1 MESSAGES RECEIVED BY NODE 0 |
| Input | Output |
|---|---|
| 2 3 + 7 * # | 2 2 3 5 5 7 35 35 |
| 1 5 + 3 # | 1 1 5 6 6 3 ERROR |
| 1 2 3 4 5 + + + + # | 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 1 2 3 9 1 2 12 1 14 15 15 |
| 6 5 4 3 2 1 * * * * * # | 6 6 5 6 5 4 6 5 4 3 6 5 4 3 2 6 5 4 3 2 1 6 5 4 3 2 6 5 4 6 6 5 24 6 120 720 720 |
| 2 3 7 * + # | 2 2 3 2 3 7 2 21 23 23 |
| 5 5 + 1 2 3 + + 2 3 2 5 2 * + * * * * 1 + 0 * # | 5 5 5 10 10 1 10 1 2 10 1 2 3 10 1 5 10 6 10 6 2 10 6 2 3 10 6 2 3 2 10 6 2 3 2 5 10 6 2 3 2 5 2 10 6 2 3 2 10 10 6 2 3 12 10 6 2 36 10 6 72 10 432 4320 4320 1 4321 4321 0 0 0 |
| Input | Output |
|---|---|
| 2 4 1 2 1 0 1 1 1 0 1 0 1 0 | POSITIVE MATCH AT (0, 0) NEGATIVE MATCH AT (0, 1) POSITIVE MATCH AT (1, 0) NEGATIVE MATCH AT (1, 1) POSITIVE MATCH AT (1, 2) |
| 5 5 2 3 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 0 1 0 1 1 0 0 0 0 0 1 0 1 1 1 1 | POSITIVE MATCH AT (1, 1) NEGATIVE MATCH AT (3, 0) |
| 5 6 2 4 1 0 1 0 1 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 1 1 1 1 0 0 0 0 1 1 | POSITIVE MATCH AT (1, 0) NEGATIVE MATCH AT (1, 2) NEGATIVE MATCH AT (2, 0) POSITIVE MATCH AT (2, 2) POSITIVE MATCH AT (3, 0) |
| 5 7 2 2 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 | POSITIVE MATCH AT (0, 5) NEGATIVE MATCH AT (1, 0) POSITIVE MATCH AT (2, 0) NEGATIVE MATCH AT (2, 5) NEGATIVE MATCH AT (3, 0) POSITIVE MATCH AT (3, 5) |
| 5 7 2 2 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 | POSITIVE MATCH AT (0, 5) NEGATIVE MATCH AT (2, 5) NEGATIVE MATCH AT (3, 0) POSITIVE MATCH AT (3, 5) |
| 7 7 3 3 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 | POSITIVE MATCH AT (0, 0) POSITIVE MATCH AT (1, 1) POSITIVE MATCH AT (2, 2) POSITIVE MATCH AT (3, 3) POSITIVE MATCH AT (4, 4) |
| Input | Output |
|---|---|
| 5 X M 3 M 2 X M 1 F 4 X X X X X F 2 F 1 X # | NO MORE INSTRUCTIONS 2 BYTES LEFT 0 BYTES LEFT NOT ENOUGH MEMORY 4 BYTES LEFT NO MORE INSTRUCTIONS NO MORE INSTRUCTIONS SEGFAULT |
| 5 M 3 X M 1 X M 2 X M1 X F 5 X # | 2 BYTES LEFT 1 BYTES LEFT NOT ENOUGH MEMORY 0 BYTES LEFT 5 BYTES LEFT |
| 5 M 3 X M 1 X M 2 X F 5 X F 1 X X # | 2 BYTES LEFT 1 BYTES LEFT NOT ENOUGH MEMORY SEGFAULT 2 BYTES LEFT NO MORE INSTRUCTIONS |
| 14 M 10 M 2 F 4 F 10 X X X X F 8 M 3 X X # | 4 BYTES LEFT 2 BYTES LEFT 6 BYTES LEFT SEGFAULT 14 BYTES LEFT 11 BYTES LEFT |
| 8 M 9 M 8 F 8 M 5 M 7 M 1 X X X X X X # | NOT ENOUGH MEMORY 0 BYTES LEFT 8 BYTES LEFT 3 BYTES LEFT NOT ENOUGH MEMORY 2 BYTES LEFT |
| 3 M 1 M 1 M 1 F 2 F 1 X X X X X # | 2 BYTES LEFT 1 BYTES LEFT 0 BYTES LEFT 2 BYTES LEFT 3 BYTES LEFT |
| Input | Output |
|---|---|
| 3 3 ab vbr abq cbd | FOUND AT (1, 0) DIAG UP FOUND AT (1, 0) FLAT FOUND AT (1, 0) DIAG DOWN |
| 3 3 abc vbr abq cbd | NOT FOUND |
| 3 3 aa aaa aaa aaa | FOUND AT (0, 0) FLAT FOUND AT (0, 0) DIAG DOWN FOUND AT (0, 1) FLAT FOUND AT (0, 1) DIAG DOWN FOUND AT (1, 0) DIAG UP FOUND AT (1, 0) FLAT FOUND AT (1, 0) DIAG DOWN FOUND AT (1, 1) DIAG UP FOUND AT (1, 1) FLAT FOUND AT (1, 1) DIAG DOWN FOUND AT (2, 0) DIAG UP FOUND AT (2, 0) FLAT FOUND AT (2, 1) DIAG UP FOUND AT (2, 1) FLAT |
| 5 5 hiesc hdefe diefe deefe defse defec | FOUND AT (0, 0) DIAG DOWN |
| 5 4 flat raft frat slit frat east | FOUND AT (1, 0) DIAG DOWN FOUND AT (3, 0) DIAG UP |
| 6 6 raft master arootf bsafea craftd drestt breade | FOUND AT (1, 1) DIAG DOWN FOUND AT (3, 1) FLAT FOUND AT (4, 1) DIAG UP |
| Input | Output |
|---|---|
| 2 31 43 31 43 | 1 0 |
| 10 223 15 22 175 179 92 5 30 185 249 323 215 322 275 379 392 105 230 485 349 | 3 100 200 300 |
| 5 1 2 3 4 5 5 4 3 2 1 | 5 4 2 0 -2 -4 |
| 15 181 65 122 124 7 231 67 130 128 201 214 90 119 135 128 114 153 215 39 19 32 155 47 219 221 17 130 218 220 148 | 15 -67 88 93 -85 12 -199 88 -83 91 20 -197 40 99 85 20 |
| 10 223 15 22 175 179 92 5 30 185 249 323 215 322 275 379 392 105 130 485 349 | 9 100 200 300 100 200 300 100 100 300 |
| 12 223 15 22 175 179 92 5 30 185 249 645 770 523 215 322 275 379 392 305 230 485<PHONE_NUMBER> | 6 300 200 300 100 200 300 |


Introduction
Monet is a header-only vector graphics library written in C++11. The aim of Monet is to provide some simple way to produce 2D graphics; it does not aim to implement complex patterns like gradients, transparencies, and so on.
Monet does not have any dependencies other than the standard C library. It has been tested using GCC under Linux, but it should compile with any compiler supporting C11 under any operating system, as it does not implements a GUI: image files are directly written to disk.
At the moment, Monet supports the production of SVG files; other formats, like EPS and PDF, are planned.
You can proceed with the Tutorial, or you can directly download the library and start coding:
curl https://raw.githubusercontent.com/ziotom78/monet/master/include/monet.h > monet.h
Tutorial
The first image
The first program we are going to write will use Monet to create a SVG image containing a rectangle and a diagonal line.
Create an empty directory somewhere with name tut01
, and install the
Monet header file in it with the following command:
curl https://raw.githubusercontent.com/ziotom78/monet/master/include/monet.h > monet.h
(Of course, you can use wget
or any other downloader.) Now use your
favourite editor to create the following C++ file, and name it
tut01.cpp
:
#include "monet.h"
using namespace monet;
int main() {
SVGCanvas canvas{"tut01.svg", 500, 300};
canvas.setfillcolor(yellow);
canvas.rectangle(Point{0, 0}, Point{500, 300}, Action::Fill);
canvas.setstrokecolor(black);
canvas.line(Point{100, 100}, Point{400, 200});
}
Compile the program and run it:
gcc -o tut01 tut01.cpp && ./tut01
The result is a new tut01.svg
file, which you can open your
favourite web browser; e.g., if you are using Firefox, open it with
the command firefox tut01.svg
. You will see the following image
appear within the browser:
Let’s analyze the code line by line. First of all, every class and
function in the library lives within the monet
namespace. In this
documentation, we always put put the following statement at the
beginning of the code:
using namespace monet;
The first statement in main
instantiates a canvas, i.e., a 2D
surface that accepts graphical commands:
SVGCanvas canvas{"tut01.svg", 500, 300};
The constructor we are using, SVGCanvas
saves the plotting commands in
a SVG file. SVG files can be viewed using any Internet browser (e.g.,
Firefox, Chrome, Safari) and edited using vector graphics programs like
Inkscape, Adobe Illustrator, and Corel Draw!.
The second line sets the fill color for any filling operation that
will follow. We are using one of the predefined colors in Monet,
yellow
(see Standard colors for more color names):
canvas.setfillcolor(yellow);
The next line asks Monet to draw a rectangle on the canvas:
canvas.rectangle(Point(0, 0), Point(500, 300), Action::Fill);
The rectangle is specified using two opposite corners along one of the diagonals. The order is irrelevant, but for convention we usually specify the bottom-left corner first. The third argument specifies how the rectangle should be drawn:
-
Action::Fill
(this case) asks Monet to fill the rectangle with the fill color we have specified; -
Action::Stroke
draws the outline of the rectangle. In this case, the stroke color (set using the methodcanvas.setstrokecolor
, see below) would be used instead of fill color. -
Action::FillAndStroke
fills the rectangle using the fill color and then draws the outline using the stroke color.
Finally, the last two commands set the stroke color to black and draw a line:
canvas.setstrokecolor(black);
canvas.line(Point(100, 100), Point(400, 200));
Once the variable canvas
goes out of scope (i.e., the program ends),
the file tut01.svg
is flushed to disk and closed.
Coordinate system
Monet can create rectangular images, where each point in the image is
located using a Cartesian coordinate system. The bottom-left corner of
the image has always coordinates (0, 0). The coordinates of the
upper-right corner depend on the size of the image, that must be passed
to the constructor. This is what we did in tut01
:
SVGCanvas canvas{"tut01.svg", 500, 500};
This instruction tells Monet that the image will be 500×500 wide, i.e., a square.
In the following example, we use SVGCanvas.text
and SVGCanvas.circle
to show the coordinates of a few points in a canvas.
#include "monet.h"
#include <cstdio>
#include <vector>
using namespace monet;
int main() {
SVGCanvas canvas{"tut02.svg", 500, 500};
std::vector<Point> points{
Point{100, 100}, Point{400, 100}, Point{100, 400},
Point{400, 400}, Point{250, 250},
};
// Draw a border
canvas.setstrokecolor(black);
canvas.rectangle(Point{0, 0}, Point{500, 500}, Action::Stroke);
// Draw a point and some text for every element in "points"
canvas.setfillcolor(black);
for (auto pt : points) {
canvas.circle(pt, 5, Action::Fill);
char text[64];
sprintf(text, "(%d, %d)", static_cast<int>(pt.x), static_cast<int>(pt.y));
canvas.text(pt + Point{0, canvas.getfontsize()}, text,
HorizontalAlignment::Center, VerticalAlignment::Top);
}
}
Compile the code as usual; the output will be the following:
You can see that the x and y coordinates increase from left to right, and from bottom to top, like in the Cartesian plane.
Many new concepts are used in this new program:
-
We have used a C `for` loop to iterate the creation of many graphical elements; of course, as Monet is used in C programs, we can use any construct we want to place graphical elements on the canvas.
-
We have used text functions.
-
We have used mathematical operations with the
Point
structure.
The call to canvas.text
passes pt + Point(0, canvas.getfontsize())
as the coordinate where to put the text. Point
is a structure that can
be used with a few mathematical operators. In our example, we used the
addition (operator+
) in order to shift the text a bit above the
circle. See the Reference for more information.
The amount of vertical shift is given by the result of a call to
canvas.getfontsize()
, which returns the height of a character of text.
Had we avoided this fix, like here:
canvas.text(pt, text, HorizontalAlignment::Center, VerticalAlignment::Top);
the result would have been uglier:
Fun with colors
There are several ways to specify colors in Monet:
-
Use one of the predefined constants, like
black
,yellow
,darkred
,lightgreen
, etc.; -
Specify a color using its RGB (red-green-blue) components;
-
Specify a shade of gray;
-
Specify a color using its HSL (hue-saturation-lightness) components.
Here is an example:
Color color1{black};
Color color2{rgb(0.5, 1.0, 0.5)};
Color color3{gray(0.7)};
Color color4{hsl(0.3, 0.5, 0.75)};
RGB and HSL use three floating-point numbers in the range [0, 1] to
specify colors. In the example above, color2
is a color made 50% of
red, 100% of green and 50% of blue: a light green. We will not spend
much time about RGB colors, as they are widely used and plenty of
explanations can be found on the web (by the way, it is the standard way
to encode colors in HTML). Gray shades can be specified using the gray
function, wich accepts a number in the range [0, 1] representing the
luminosity of the shade (0 is black, 1 is white).
Color color4
is specified using its hue, saturation, and luminosity
components. This is a somewhat more physical way of identifiying a
color, but it is user far less than RGB, so we will spend some more time
on it. The three numbers used to define color4
have the following
meaning:
-
The hue is at one third of the distance between red (0) and blue
-
in the electromagnetic spectrum (it is a measure of the wavelength of monocromatic light);
-
The saturation is halfway (50%) between gray and the fully bright hue;
-
The luminosity is 75% between black (0%) and white (100%).
Playing with luminosity helps in making the images lighter or darker. Note that if luminosity is 0, the color is black regardless of hue and saturation; similarly, the color is always white if luminosity is 1.
Here is an example of the shades you can get by playing with the hue and the saturation:
#include "monet.h"
#include <cstdio>
using namespace monet;
int main() {
const double width{500};
const double height{150};
SVGCanvas canvas{"tut03.svg", width, height};
canvas.setfontsize(10);
// Width of the colored rectangle bar on the right
const double leftside{width * 0.8};
const double rightside{width - leftside};
const int hue_nsteps{10};
const double square_height{height / 3};
// Use a fixed saturation for all the squares
const double saturation{1.0};
// Draw three rows of squares
const std::vector<double> lightness_levels{0.33, 0.50, 0.67};
for (size_t row_num{}; row_num < lightness_levels.size(); ++row_num) {
double lightness = lightness_levels[row_num];
// Inner loop: draw one row
for (double hue_step{}; hue_step < hue_nsteps; ++hue_step) {
double hue = (hue_step + 0.5) / hue_nsteps;
canvas.setfillcolor(hsl(hue, saturation, lightness));
// Plot the colored rectangle
Point p1{hue_step * leftside / hue_nsteps, row_num * square_height};
Point p2{(hue_step + 1) * leftside / hue_nsteps,
(row_num + 1) * square_height};
canvas.rectangle(p1, p2, Action::FillAndStroke);
// Print the hue level over the rectangle
char text[64];
std::sprintf(text, "%.0f%%", hue * 100);
Point textcenter{(p1 + p2) / 2};
canvas.setfillcolor(black);
canvas.text(textcenter, text, HorizontalAlignment::Center,
VerticalAlignment::Center);
// Print the lightness level on the right side of the plot
std::sprintf(text, "L: %.0f%%", lightness * 100);
canvas.text(Point{width - rightside / 2, textcenter.y}, text,
HorizontalAlignment::Center, VerticalAlignment::Center);
}
}
}
And here is the result:
Note that we are using 100% saturation (colors are bright). Let’s see what happens if we set the saturation to zero:
// Use a fixed saturation for all the squares
const double saturation = 0.0;
Here is the result:
All the colors have turned into gray!
The comparison with the previous image reveals that the HSL color space
is not entirely physical, as there are some hues that are significantly
darker than others at the same luminosity (e.g., the blue square in the
L: 33%
row is significantly darker than the green square in the same
row), but in the image below all the gray rectangles on the same row
have the same shade. Better color spaces exist (e.g.,
luma), but Monet does not
implement them at the moment.
Paths
Apart from circles and text, Monet is able to draw more complex shapes.
Paths are an important concept: they are built using consecutive calls
to moveto
, lineto
, and similar functions. Each command builds up a
path without drawing anything; in order to show the path, you must call
either strokepath
, fillpath
, or fillandstrokepath
. Consider this
example:
#include "monet.h"
#include <cstdio>
#include <vector>
using namespace monet;
int main() {
SVGCanvas canvas{"tut04.svg", 500, 200};
std::vector<Point> points{Point{100, 50}, Point{250, 140}, Point{350, 175},
Point{350, 50}};
// Draw the path
for (size_t i{}; i < points.size(); ++i) {
if (i == 0)
canvas.moveto(points[i]);
else
canvas.lineto(points[i]);
}
canvas.strokepath();
// Draw circles and some text on the points along the path
int pointidx{1};
for (const Point &point : points) {
canvas.setfillcolor(lightred);
canvas.setstrokecolor(black);
canvas.circle(point, 5, Action::FillAndStroke);
char buf[8];
std::sprintf(buf, "#%d", pointidx++);
canvas.setfillcolor(black);
canvas.text(point + Point{canvas.getfontsize(), 0}, buf,
HorizontalAlignment::Right, VerticalAlignment::Center);
}
}
The code iterates over the point
vector, starting with a moveto
instruction (the if (i == 0)
branch) and then calling lineto
repeatedly. Finally, the canvas.strokepath()
call draws all the lines
together as a single path. In order to make clear how the path was
constructed, the code uses a second for
loop to place red dots over
each point and numbers beside them.
Here is the result:
Let’s investigate what would have happened if we used fillpath
instead
of strokepath
in the code above:
canvas.setfillcolor(gray(0.7));
canvas.fillpath();
To “fill” an area, the area should be closed. That’s the reason why
Monet connects the last point (#4
) to the first one (#1
) before
filling the area:
Using fillandstrokepath
would draw the contour and fill it. Note that
in this case the path is not closed:
To make the stroke closed as well, just call closepath
before call
fillandstrokepath
:
canvas.closepath();
canvas.setfillcolor(gray(0.7));
canvas.fillandstrokepath();
Monet provides a handy function to quickly draw paths made by several
points: the drawpath
function. Instead of the following code:
std::vector<Point> points{Point(100, 50), Point(250, 140), Point(350, 175),
Point(350, 50)};
// Draw the path
for (size_t i = 0; i < points.size(); ++i) {
if (i == 0)
canvas.moveto(points[i]);
else
canvas.lineto(points[i]);
}
you can pass points
to canvas.drawpath
:
std::vector<Point> points{Point(100, 50), Point(250, 140), Point(350, 175),
Point(350, 50)};
// Draw the path
canvas.drawpath(points);
Of course, a call to canvas.drawpath
must be followed by a call to
canvas.strokepath
or canvas.fillpath
to have an effect.
Curved paths
Paths can be curved too. The first type of curved path is a quadratic
curve, to be specified using the quadraticto
method. In this case,
you must provide two points: the target'' point and the
end'' point:
#include "monet.h"
#include <cstdio>
#include <vector>
using namespace monet;
int main() {
SVGCanvas canvas{"tut05.svg", 400, 100};
std::vector<Point> points{Point{10, 10}, Point{200, 70}, Point{300, 10}};
// Quartic curve, shown using a thick black line
canvas.setstrokewidth(3);
canvas.setstrokecolor(black);
canvas.moveto(points[0]);
canvas.quadraticto(points[1], points[2]);
canvas.strokepath();
// Clear the current path and start a new one
canvas.clearpath();
// Draw a light red line that crosses the three points
canvas.setstrokewidth(1);
canvas.setstrokecolor(lightred);
canvas.moveto(points[0]);
canvas.lineto(points[1]);
canvas.lineto(points[2]);
canvas.strokepath();
// Plot circles where each point stands
canvas.setfillcolor(black);
for (Point pt : points) {
canvas.circle(pt, 5, Action::Fill);
}
// Finally, add some text
canvas.setfontsize(10);
canvas.text(points[1] + Point{0, 10}, "Target point",
HorizontalAlignment::Center);
canvas.text(points[2] + Point{10, 0}, "End point", HorizontalAlignment::Right,
VerticalAlignment::Center);
}
A more versatile curve is the cubic curve, which requires to specify two control points together with the end point:
std::vector<Point> points{Point{10, 10}, Point{10, 70}, Point{250, 50},
Point{300, 10}};
// Cubic curve, shown using a thick black line
canvas.setstrokewidth(3);
canvas.setstrokecolor(black);
canvas.moveto(points[0]);
canvas.cubicto(points[1], points[2], points[3]);
canvas.strokepath();
Transparencies
It is possible to make graphical elements partially transparent, using
the settransparency
function.
#include "monet.h"
using namespace monet;
int main() {
SVGCanvas canvas{"tut07.svg", 500, 150};
Point pt1{0, 0};
Point pt2{280, 50};
for (double tr{}; tr < 1.0; tr += 0.2) {
canvas.settransparency(tr);
canvas.setfillcolor(hsl(tr, 1.0, 0.5));
canvas.rectangle(pt1, pt2, Action::Fill);
canvas.settransparency(0.0);
canvas.setfillcolor(black);
canvas.rectangle(pt1, pt2, Action::Stroke);
pt1 += Point{50, 20};
pt2 += Point{50, 20};
}
}
The code above produces a set of rectangles, starting from a fully opaque red color to a 80% transparent violet hue. Note that the border of the rectangles has no transparency.
Transformations
Besides basic graphical commands like circles and rectangles, Monet implements a transformation pipeline that allows to apply a number of operations to graphical commands. Currently, the following operations are supported:
-
Rotations (
BasicCanvas::rotate
) -
Translation (
BasicCanvas::translate
) -
Scale transformations (
BasicCanvas::scale
,BasicCanvas::scalex
,BasicCanvas::scaley
)
You can apply a sequence of transformations to groups, which are
sequences of graphical commands enclosed within a call to
BasicCanvas::begingroup
and BasicCanvas::endgroup
.
The following example shows how to apply rotations to some text:
SVGCanvas canvas{"tut08.svg", 500, 150};
Point pivot{250, 75};
for (double angle{}; angle < 360; angle += 30) {
// First rotate, then translate
canvas.begingroup(rotate(angle) | translate(pivot));
canvas.setfillcolor(hsl(angle / 360, 1.0, 0.4));
// Note that the position of the text is (0, 0)
canvas.text(Point{}, "Hello, world!");
canvas.endgroup();
}
// Paint the pivot point as a black circle
canvas.setfillcolor(black);
canvas.circle(pivot, 5, Action::Fill);
The example builds 12 groups, each containing a text object with content
Hello, world!
. In the call to begingroup
(which must always be
matched by a call to endgroup
), we specify a composite transformation
using the operator |
: the operation rotate(angle) | translate(pivot)
means that for each graphical element drawn within the calls to
canvas.begingroup
and canvas.endgroup
(in our case, the call to
canvas.text
) must be first rotated by an angle angle
(in degrees),
and then translated by pivot.x
along the x axis and pivot.y
along
the y axis.
Transformations are instances of the monet::Transform
type, but you
should never instantiate it directly; instead, use one of the following
functions:
-
rotate(angle, pivot)
-
rotate(angle)
(assume thatpivot = Point(0, 0)
) -
translate(point)
-
scale(factor)
,scalex(factor)
,scaley(factor
,scale(factor_x, factor_y)
The operator |
applies the sequence of transformations in sequence and
automatically builds a TransformSequence
type (ordered list of
transformations). As begingroup
expects a TransformSequence
instead
of a Transform
, if you want to apply one operation instead of a
sequence, you should initialize a TransformSequence
object using the
following syntax:
canvas.begingroup(TransformSequence{scale(2)});
This will shrink every graphical command in the group twice their size.
Clipping
Monet has the ability to ``clip'' graphical commands, i.e., to disable drawing outside some boundaries. This can be useful in complex drawings, e.g., plots. To perform a clipping operation, you must follow these steps:
-
Call
BaseCanvas::defineclip()
(no arguments); -
Call whatever graphical operation you want, like
rectangle
andcircle
, in order to identify the clipping region. Any graphical operation drawing objects that fall outside the shapes drawn here will be rejected. -
When the path is completed, call
BaseCanvas::endclip()
(no arguments). -
You can activate and deactivate clipping by calling
BaseCanvas::useclip()
andBaseCanvas::removeclip()
.
The following example shows how to implement a clipping region made by a complex path:
const double width{500};
const double height{150};
SVGCanvas canvas{"tut09.svg", width, height};
{
canvas.defineclip();
std::vector<Point> points{Point{100, 30}, Point{250, 110}, Point{330, 135},
Point{260, 30}};
canvas.drawpath(points);
canvas.strokepath(); // canvas.fillpath() would have been ok as well
canvas.endclip();
}
canvas.useclip();
// Etc.
If we copy-and-paste the code from Section Fun with colors after
the call to canvas.useclip()
, we get the following result:
Reference
Color
A Color
structure represents a color to be used for painting the
canvas. It contains the following fields:
| Field | Type | Meaning |
|---|---|---|
|
|
Red level, in the range [0, 1] (inclusive) |
|
|
Green level, in the range [0, 1] (inclusive) |
|
|
Blue level, in the range [0, 1] (inclusive) |
The preferred way to create a color is via one of the following functions (remember, they are not constructors):
-
rgb(r, g, b)
is equivalent toColor{r, g, b}
, but it is clearer in stating the color space; -
hsl(h, s, l)
initializes the color using the hue, saturation, and luminosity values. In this case too, all the parameters must be in the range [0, 1] (yes, even the hue). See Fun with colors for an explanation of the meaning of each parameter. -
gray(l)
initializes the color with a gray shade. It is equivalent tohue(0, 0, l)
.
The only method provided by the class Color
is toHTML
, which returns
a string containing the HTML representation of the color. A Color
object can be printed to a stream using the <<
operator, as shown in
the following example:
Here is an example showing these operators:
#include "monet.h"
#include <iostream>
using namespace monet;
int main() {
Color col1{rgb(1.0, 0.0, 0.5)};
Color col2{hsl(0.6, 0.4, 0.7)};
std::cout << "col1 = " << col1 << '\n';
std::cout << "The HTML representation of col1 is '" << col1.toHTML() << "'\n";
std::cout << "col2 = " << col2 << '\n';
std::cout << "The HTML representation of col2 is '" << col2.toHTML() << "'\n";
}
And here is the output:
col1 = rgb[1, 0, 0.5] The HTML representation of col1 is '#ff007f' col2 = rgb[0.58, 0.676, 0.82] The HTML representation of col2 is '#93acd1'
Standard colors
The library provides a number of predefined colors:
Fonts
Fonts are specified through the FontFamily
enumeration:
| Name | Examples |
|---|---|
|
Garamond, Times New Roman |
|
Arial, Helvetica |
|
Courier |
Point
A Point
structure represents a 2D point on the canvas. It contains the
following fields:
| Field | Type | Meaning |
|---|---|---|
|
|
First coordinate |
|
|
Second coordinate |
To initialize a point, you can use one of the following constructs:
-
Point p
initializesp
to the coordinates(0, 0)
; -
Point p(1, 2)
initializesp
to the coordinates(1, 2)
;
The Point
structure implements a number of operators:
| Operator | Meaning |
|---|---|
|
Sum two points together |
|
Subtract one point from amother |
|
Scale a point by a number (both |
|
Divide the coordinates of a point by a number |
|
Increment a point using another point |
|
Subtract one point from another |
|
Scale a point by a number in-place |
|
Divide the coordinates of a point by a number in-place |
|
Print the coordinates of the point to a |
Here is an example showing these operators:
#include "monet.h"
#include <iostream>
using namespace monet;
int main() {
Point pt1{300, 400};
std::cout << "pt1 is " << pt1 << '\n';
pt1 /= 10;
std::cout << "pt1 is now " << pt1 << '\n';
std::cout << "pt1 scaled by 5 is " << pt1 / 5 << '\n';
Point pt2{100, 200};
std::cout << "The sum of pt1 and pt2 is " << pt1 + pt2 << '\n';
std::cout << "The X component of pt1 + pt2 is " << (pt1 + pt2).x << '\n';
}
And here is the output:
pt1 is (300, 400)
pt1 is now (30, 40)
pt1 scaled by 5 is (6, 8)
The sum of pt1 and pt2 is (130, 240)
The X component of pt1 + pt2 is 130
Primitives
In Monet’s slang, a primitive is a graphics operation provided by the
canvas. Monet has several primitives, provided by methods of the
BaseCanvas
class:
| Method | Shape |
|---|---|
|
A circle |
|
A straight line |
|
A rectangle with its sides aligned with the X and Y axes |
Paths
The BaseCanvas
class provides the following methods to
create/modify/draw paths:
| Method | Meaning |
|---|---|
|
Move to a point without drawing anything |
|
Connect the current point to a new point using a straight line |
|
Repeatedly call |
|
As |
|
As |
|
Connect the current point with the first point in the path |
|
Draw the path on the canvas using the color set with
|
|
Close the path if needed, and then fill it with the color
set with |
|
Combination of |
|
Cancel the current path and start a new ones |
A presentation of the commands used to create paths is provided in Section Paths.
Once you have finished with a path, you must call clearpath
before
drawing a new one!
Groups
A group is a collection of graphical objects. Its main purpose is to apply a sequence of transformations (see Transformations) to each object in the collection.
| Method | Meaning |
|---|---|
|
Start a new group, applying the sequence of
transformations in |
|
Complete the definition of a group started with
|
Any call to begingroup
should be followed by a call to endgroup
;
however, the library is smart enough to close all the groups that have
been left open when the canvas is going to be destroyed.
Transformations
A transformation can be applied only to groups, and it is implemented
via the type Transform
, which is a
union type
(unfortunately, C++11 lacks the support for
algebraic types, and
a class hierarchy would have been too complex and cumbersome to use
here).
The following functions create a Transform
object:
| Function | Meaning |
|---|---|
|
Translate by |
|
Rotate by |
|
Rotate by |
|
Scale by a factor |
|
Scale by a factor |
|
Scale by a factor |
|
Scale by a factor |
|
Scale by a factor |
Transformations can be concatenated using the |
operator. If you think
of two transformations tr1
and tr2
as two functions f and g, the
C++ expression tr1 | tr2
is equivalent to the mathematical operation
g∘f (function composition; note that the two operators are
reversed). Thus, tr1 | tr2
means: `first apply `tr1
(f), then
apply tr2
(g)''.
Transformations can be passed to begingroup
: every object within the
call to begingroup
and endgroup
will be implicitly transformed by
the sequence of transformations.
Since begingroup
expects a TransformSequence
, you cannot pass just
one Transform
object to it:
// This won't work
canvas.begingroup(rotate(30));
Instead, you must explicitly initialize a TransformSequence
:
// This is ok
canvas.begingroup(TransformSequence{rotate(30)});
Clipping
Check out section Clipping in the tutorial.


Below are some of my own and shared projects
My master thesis is about creating a world generator for a platform game.
The generator creates a rhythm simulating how a player would press keys or buttons when playing
a level, where every button press represents the use of one of the character’s abilities.
Then obstacles are placed to match the abilities and a level is formed that can be cleared
using the same abilities and timing as in the generated rhythm.
An example can be that the rhythm includes running for five seconds and also pressing the jump button two times,
shown as the boxes on the timeline below. The first jump press is smaller than the second one so the two jumps have different
durations. The character’s movement can be seen below, together with an example level with a little step that makes
the player do a small jump and then a gap that makes the player do a longer jump, matching the rhythm.
This method was created by Gillian Smith, Mike Treanor, Jim Whitehead and Michael Mateas and was used to create levels that went from left to right with some height differences but never going backwards. I wanted to build a world where the path could go in any direction and therefore had to alter the original method to fill a room. The generation can be controlled through a set of parameters and new obstacles and abilties can be added. An example room can look like this:
Light gray tiles mean air, dark gray mean ground, green elevator and red spikes. Black tiles are empty tiles.
Together with a classmate I developed an interactive VR game which gives a social experiance in VR for two people. Here is an example image from the game.
The game is developed for HTC Vive. To integrate the social aspect into the game, one player wears the headset and holds one hand controller while the other player holds the second controller. The player without headset can control where it looks inside the game world by turning it's hand controller. The view is then shown on a separate screen, like a TV or a computer screen. In the story of the game, the player with the headset is a human who can interact with objects in the world. The other player is a spirit who can see things which the human can't see but cannot interact with any objects. The spirit can see the human's headset and controller while the human can see the spirits controller in the form of a pink cloud, as seen in the images below.
The human and spirit must work together to solve puzzles that will take them further into the game. It is possible to involve more people who can watch the spirit's screen and give suggestions on what to do. While developing this game, user tests were made every other week which gave new insights in how to design the different puzzels. Much of the game's fundamental mechanics have changed after gaining more knowledge about how the users play. For example, the two players started with one shared view. Having control over one view each gives the players the possibility to explore more on their own and follow their curiosity. This is an innovative and creative usage of a VR system where we have created a unique opportunity to collaborate in an entertaining environment. We think that this is a first step to make VR experiences much more social.
A game system that gives a gaming console feeling. Phones are used as controls to play games together on a shared screen. The code is found on Github.
C Awards 2015 - Varsom Games from Visualiseringscenter C on Vimeo. The video is in Swedish but hopefully it gives some understanding about the project.
A ray tracer for lambertian reflectors and area light sources. The code is found on Github.
A room that is closed on all sides except the one with the camera and contains three implicit surfaces (spheres) and two area light sources. The walls and spheres are Lambertian reflectors. The image is 400x400 pixels large and was rendered with four rays per pixel.
The simulation uses the method described in Simulating Ocean Water by Jerry Tessendorf which sums the influence on points on a plane, of a set number of sinusiods. The sum is calculated with Fourier transform. The images below show the result and I have marked a single wave’s position as it moves through the water surface as time passes.
A simulation of how light is refracted through water to form caustics. Made by me alone in OpenGL. The code is found on Github and uses shaders to render different passes to different textures that are used to make the final image. The method I followed is from a paper with the name Realistic Real-time Underwater Caustics and Godrays by C. Papadopoulos and G. Papaioannou.
The blue is the water surface, the green is a plane below the water and the yellow dots are the positions where the photons emitted from the light source landed. The light source is straight above the water and the camera is in front of the scene looking down at the plane.
Created together with two classmates in C++, using OpenGL, glfw, glm and glew. The simulation respresents the cloth as multiple small points of mass that are connected through springs which hold the cloth together when forces push at it.
Me and my friend participated in DICE programming competition 2016 and our result is a 2D platformer game with 3D graphics as in the image below. The code can be found on Github.
The player is the small cube on the left. It can jump and duck to get through the floor. The floor tiles and obstacles are randomly generated.


Archive
close
A grid of JLPT N5 kanji based on the pre-2010 exams using WebVR with Three.js. The interesting thing here is the use of two renderers for CSS3D and WebGL.
An exceedingly simple Android Java app to calculate dilutions based on the standard formula C1V1 = C2V2
This is my most advanced Android Java project to date: a JPLT N5 Kanji & Kanji Story multiple-choice quiz app, available on Google Play.
This project has not been uploaded yet.
This project has not been uploaded yet.
This project has not been uploaded yet.
This project has not been uploaded yet.
This project has not been uploaded yet.
This project has not been uploaded yet.
This project has not been uploaded yet.
This project has not been uploaded yet.
This project has not been uploaded yet.
×
home
home link
archive
archive link


In this two-day mixed 4v4 tournament, we schedule play pool games on Saturday and elimination rounds on Sunday. Generally, games are to 13 with one timeout per half, win by two, but point-capped at 15. Soft cap at 60 min after actual start time. Hard cap at 75 minutes after scheduled start time. Lunch is provided on Saturday accompanied by a layout competition! More details will be provided as the tournament approaches.
OLOB is a 4v4 beach tournament. We follow BULA 4v4 rules. Here's a quick refresher of the rules you might need clarified:
- Fields are 8/34/8 yards long x 30 yards wide.
- Pulls must be inverted (at least 1 degree from vertical when landing).
- After an out-of-bounds pull, the pivot must be established either (1) where the disc went out-of-bounds or (2) at the brick mark.
- The brick mark is 8 yards in front of the goal line (the same distance as the depth of the end zone).
- Six second stall count. Generally, a stall cannot come in at higher than 5. On a contested call, the stall cannot come in higher than 4.
- One timeout per team per half. Timeouts last 60 seconds.
- Endzone to endzone is two points; pivot foot must be in goal or on goal line.
- Sidelines and back end zone line are out of bounds. Front end zone line is not a goal.
- Two guys and two girls on the field at all times.
- NO foot blocks. Any attempted footblock is a foul, regardless of whether it affected the throw.


This visualisation is intended to give users a brief overview of the current status of the project and give them a better understanding of how it is faring in terms of finance at a glance
There are two axes where the horizontal axis depicts months of a year and the vertical axis depicts value in terms of money. There are four different aspects in this visualisation. With three of them being line chart, and one line chart with an area shown below it. The first line shows the budget of a project throughout the current year. The second line indicates the forecast for each month of that project. Then the line “Current Contract” shows the amount of contracts created for the project during that month. Where as the “Commitments” line shows the amount spent for that project during that month. There is also a vertical line indicating current month


THENOMAD
MEMBER | LOGIN
45.5206 N 122.6774 W
MARCH10 2019
WORKSPACES
MEMBERSHIP
CULTURE
EVENTS
CONTACT


If you want to display multiple lines of code, you can use the code element.
If the code as a string can be legally inserted to a Meteor template,
you can use the TECodeLocal
element to insert code.
The template that insert code looks like below:
{{> TECodeRemote filename="code-local-instance.txt" lang="handlebars"}}The TECodeLocal
takes the following arguments:
id
: The id of the code block.class
: The class of the code block.content
: The content string of the code block. It is
usually a field passed from javascript helper function.
noHighlight
: If set to true
, do not highlight the code block. Details see below. lang
: The language of the code block. Used to highlight the code. An example content
field is as follows:
By default, the code checks whether the hightlight.js
is installed. If so, it uses the hightlight.js to highlight the fetched block. You can
specify the highlight language in the lang
argument. When
noHighlight
is true
, the code is not highlighted.
Due to the nature of Meteor, some code you want to display may
be illegal to be inserted to a template. For example, it is illegal
to display a template
as code in another template.
To include such code, you save the code you want to display on the server
as a plain text file. Then you can use TECodeRemote
element
to fetches the code you want to display from the server as an ajax request after the
template is already rendered. It uses the mechanism described in this post:
Display source code in meteor applications.
Below is an example of the code.
{{> TECodeRemote id="remote-code" filename="code-remote.txt" lang="handlebars"}}You can use the following to insert the code in the parent template.
{{> TECodeRemote filename="code-remote-instance.txt" lang="handlebars"}}The TECodeRemote
takes the following arguments:
id
: The id of the code block.class
: The class of the code block.filename
: The filename in the server the code should fetch.
If not provided, but an id is provided, it uses the name: "id".txt. dir
: The directory name in the server the code should fetch.
If not provided, the default directory is /code/
. You need to
put the files to the public/<dir>
in the Meteor project.
noHighlight
: If set to true
, do not highlight the code block. Details see below. lang
: The language of the code block. Used to highlight the code. By default, the code checks whether the hightlight.js
is installed. If so, it uses the hightlight.js to highlight the fetched block. You can
specify the highlight language in the lang
argument. When
noHighlight
is true
, the code is not highlighted.


EAST IS EAST A film review by Steve Rhodes Copyright 2000 Steve Rhodes RATING (0 TO ****): ** 1/2
When the father of two would-be brides compliments George Khan (Om Puri from MY SON THE FANATIC) on his having six beautiful sons, George immediately sets the record straight. He has only five sons, now since one is dead. Actually, the supposedly dead son is very much alive; it is just that his father has written him off and removed all traces of him from their home after the boy walked out during his arranged wedding. The young man was offered a beautiful bride but one that he neither loved nor knew before the wedding day.
In a comedic drama of clashing cultures, EAST IS EAST tells the story of a Pakistani man, his English wife and their 7 kids, who live in a working-class neighborhood in England. The family owns a small fish-and-chips shop called George's English Chippy, in which everyone in the family pitches in to keep it going.
Trying to run his family with Muslim strictness, George is a good-natured blowhard. His wife, Ella (Linda Bassett), whom he loves dearly, generally ignores his attempts to rule their family with an iron glove.  Their marriage is basically a good one, full of playfulness and love. But, when pressed, he reverts to his own upbringing and lays down the law in his household, in which he thinks that the father should be lord and master.
Most of the movie is a sugary confection of little episodes typified by the one about the circumcision of the youngest son, Meenah (Jordan Routledge), a boy about 12 years old. In a completely unbelievable incident, the mother realizes that Meenah, whom she had undoubtedly diapered a thousand times, was never circumcised as she had assumed. Meenah is seen urinating -- an activity that occurs with bizarre frequency in the film -- by a Muslim cleric, and the cleric is shocked that the boy is not circumcised. The father quickly arranges for an operation ("It's only a little operation. It won't hurt."), which puts an understandable amount of fear in the lad. His older sister torments him after the operation by drawing a picture of a penis, which she tears in two, taunting him by saying "Ouch!" This produces the show's only substantial laugh.
When the father tries to marry off two more of his sons, the would-be brides turn out to be some of the ugliest women around. This sets up the story's overly long and bittersweet concluding segment, in which the good-spirited picture turns mean and the father loses our respect but not his wife's.
Director Damien O'Donnell, working from a script by Ayub Khan-Din, continually pulls his punches, never quite making either a truly funny film or a biting social satire. The result is a movie that's kind of cute and kind of poignant, which all adds up to being only kind of nice.
EAST IS EAST runs 1:36. It is rated R for violence, sexuality and language and would be acceptable for most teenagers.
Email<EMAIL_ADDRESS>Web: http://www.InternetReviews.com
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


console.log("JS file is connected to HTML! Woo!")
// all the cards you have on the screen
document.addEventListener('DOMContentLoaded', function() {
var cards = ['king', 'king', 'queen', 'queen'];
// shuffle function
// This is the "fisher-yates shuffle".
// You can read more about it here: https://bost.ocks.org/mike/shuffle/
function shuffle(array) {
var currentIndex = array.length;
// we don't want to assign these yet; we will later on these yet
var temporaryValue = null;
var randomIndex = null;
// While there remain elements to shuffle...
while (0 !== currentIndex) {
// Pick a remaining element...
randomIndex = Math.floor(Math.random() * currentIndex);
currentIndex -= 1;
// And swap it with the current element.
temporaryValue = array[currentIndex];
array[currentIndex] = array[randomIndex];
array[randomIndex] = temporaryValue;
}
return array;
}
/*
For each card in the shuffled array,
- create a new div with class card,
- give it the innerText of the card
- and append it to the div of class board.
When two cards are clicked on,
- compare the innerText of the cards
- and alert "You are a winner!" if they match.
You'll need to keep track of the card that has been clicked on, and
whether or not it's the first or second card. What you might do is
create two variables, firstCard and secondCard, and at first assign them
to `null`. Then, when the card is clicked, if there's nothing stored in
firstCard, that one gets the value of the card that has been clicked.
Otherwise, secondCard gets the value of the card that has been clicked.
If both firstCard and secondCard have values -- that is, if two cards have
been clicked, we will need to compare them, and cause the alert.
**BONUS**: Keep track of what the card is _without_ using `innerHTML`.
Maybe you can use a class, or something. This way, you can make the player
match them without seeing the text.
*/
var shuffledCards = shuffle(cards);
var firstCard = null;
var secondCard = null;
// put everything before this
})


Create Announcement
Go to the attendance, sign in, scroll down and click on "Google Token" at the bottom of the page. Copy the google token. The token can be used more than once, but expires after 15 minutes
Committee must be either general, app, web, ai, robotics, or game
Title:
Text:
Committee:
Also post on slackYour google token:


CQRS & EventSourcing discovery
Workshop
Florent @florentpellet
Clément @clem_bouillier
Jean @jeanhelou
Emilien @ouarzy
Who are we ?
- 4 passionate guys initiated this workshop in 2015
- Feel free to give some feedbacks on GitHub
-
Clément
@clem_bouillier
-
Emilien
@ouarzy
-
Florent
@florentpellet
-
Jean
@jeanhelou
CQRS Concept
Ref. "Conceptual CQRS" - Alberto Brandolini
Event Sourcing Concept
NB: DecisionProjection is also called State
Ref. Jérémie Chassaing
The new unicorn
We’ll revolutionize the web!
We’ll create a product like Twitter but better ...
A revolution!
Mixter
Instead tweet...
we'll quack!
Test Driven Workshop
- Working in pairs
- Execute "run" script and read instructions
- Red Test => Green Test
-
3 steps (+2 Bonus)
- Command DeleteMessage
- Query Timeline Message
- Events in aggregate
Focus on Core Domain
-
Do not change
- Tests code
- Infrastructure code
- You can see Identity context implementation as example
GIT Repository
git clone https://github.com/DevLyon/mixter.git
./run
Slide : http://devlyon.fr/mixter/
1. Delete Command
What we will learn :
- publish events from aggregate,
- use projection for decision inside aggregate (contains only "state" for future decision, DO NOT keep all state like in an entity)
- Implement "business rules" that insure aggregate consistency (based on decision projection and command=method parameters)
In brief : the C of CQRS
2. Timeline messages Projection
What we will learn :
- Create another model for Query (Projection, TimelineMessageProjection)
- Transform events in a projection model through an EventHandler
- A projection repository (in-memory) with its interface is given
In brief : Q of CQRS
3. Subscription Aggregate
What we will learn :
- Create a new aggregate (Subscription)
- Raise events from it : UserFollowed and UserUnfollowed
- Create a decision projection for it
- Implement replay of events (event sourced aggregate)
In brief : C of CQRS + Event Sourcing
4. Aggregates interaction
What we will learn :
- Coordinate several aggregates to limit coupling
- Concept of " Eventual consistency"
5. Command Handler
What we will learn :
- Integrate previous code from Message & Identity contexts in a command
- Write some web infrastructure code executing the command
=> Request Rest to execute delete Message command, with session validity verification
NB : no tests for this step for now…
CQRS & EventSourcing discovery
Thanks!
Florent @florentpellet
Clément @clem_bouillier
Jean @jeanhelou
Emilien @ouarzy


§198D-5 Identification of proposed, potential, and needed trails and accesses. (a) In addition to the inventories under section 198D-3, the department shall identify and maintain a listing of:
(1) Proposed trails and accesses which may be opened to the public;
(2) Potential expansions of trails and accesses;
(3) Potential or desirable connectors between existing trail systems;
(4) Public beach, shore, park, trail, and other recreational areas to which access is unavailable or inadequate; and
(5) Trails and accesses to public hunting areas.
(b) The listing may be published in the inventories required under section 198D-3. [L 1988, c 236, pt of §2; am L 1990, c 53, §1(3)]


Now in 2020, she wants to leave on the first flight back to Egypt as soon as her diploma touches her fingertips.
“I feel like here, I am nothing.”—Habiba Abdelaal
“I feel like here, I am nothing,” Abdelaal said.
For Abdelaal, a $990 health insurance bill, paid in four installments throughout the semester — along with school fees, rent and utility bills — was starting to add up. Then, she received an email from the university in August of 2019, stating the unbelievable: Health insurance costs were rising to $1,410 a semester.
 Abdelaal said.
When she applied for her visa, Abdelaal had to provide bank statements, so the U.S. knew she could afford to live in Athens. Ohio University, however, wasn’t like the U.S. government.
“We didn’t sign up for this,” Abdelaal said.
In 2016, the cost of health insurance provided by UnitedHealthcare was approximately $990 per semester after subsidies, according to a previous Post report. The cost has since increased over 29%, making the payments $1,410 in 2020. The university also requires every international student, like Abdelaal, to have Emergency Medical Evacuation & Repatriation, which costs an extra $90 for an academic year.
“The current insurance options available to students through Ohio University were recommended by the Student Health Insurance Policy Advisory Committee, which includes students and administrators,” OU media relations manager Jim Sabin said in an email. “The committee met last year to review options in an effort to maintain premiums as close as possible to last year's. Premiums are determined based on claims utilization, plan design and payable benefits.”
Abdelaal knew the UnitedHealthcare plan was set in stone but hoped there could be alternative health care plans for her to choose from. What she and other students found, however, was a list of criteria that needs to be filled for the university to accept another health care plan.
“Students who do not wish to purchase the student health insurance have the option to waive the student health insurance by submitting their alternate health insurance information,” Sabin said in an email. “This applies to both international and domestic students.”
Options for students who are not on their parents’ health care plan include the state marketplace or through a private broker, Sabin said. Sabin said many students qualify for Medicaid or a government subsidy for a marketplace plan based on their income.
Health care can’t change in a day, weeks or months, Abdelaal said. It takes countless hours of meetings with board members and meetings with health care officials — negotiating prices, premiums, stipends, what gets covered and what doesn’t.
When health care literacy understanding is a setback for a majority of Americans, according to a survey from Policygenius, the barrier for international students is an even greater setback.
“Some domestic students don’t understand it,” Abdelaal said. “Imagine we’re coming from different countries from different languages, and you’re giving us 40 pages to read and to understand those medical terms and subsidies … that we don’t understand, honestly.”
Abdelaal’s frustrations don’t end at the costs. She has reservations about how the insurance plan is fanned out throughout the school year and into the summer. The UnitedHealthcare insurance plan is included throughout summer, where Abdelaal and many other students are not at the university. Either on a vacation or visiting home, they are still on the university’s health insurance plan.
“I have to pay health insurance in the United States when I’m not in the United States,” Abdelaal said. “That could save us about $500 per semester.”
Abdelaal knew her bills weren’t going to go away.  As a master’s student, Abdelaal works in an apprenticeship through the Voinovich School of Leadership and Public Affairs, where she makes approximately $1,400 a month. But she is only allowed to work 20 hours a week, due to federal law, according to a previous Post report.
Throughout all the confusion and anxiety Abdelaal was enduring, she found a way to change her situation — joining Graduate Student Senate. That would allow her to be a part of her university and community. She could talk with university officials, other graduate student senators and everyday students who walk the streets of Athens. Now, she is the mental health affairs commissioner for the academic year of 2020-2021.
She also became a part of the Health Insurance Committee, where graduate student senators would try to find ways of lowering the price or changing the health insurance system at OU.
“I joined the GSS just to advocate for the health insurance,” Abdelaal said.
Graduate student executive members like President Kaelyn Ferris and Vice President Amal Shimir have been working on solutions to help either spread out the health insurance payment plan or reduce health insurance fees, according to a previous Post report. The Office of the Bursar has declined some of their plans.
On March 4, the Health Insurance Committee found that the national inflation rate is “not as high as (the university’s) increase” in health insurance pricing. The US Health Care Inflation Rate was at 4.48%, compared to 4.57% last month and 1.90% last year. That was lower than the long term average of 5.28%. As of October, the inflation rate is at 4.20%.
One of the committee's demands was a problem Abdelaal also had with her health insurance plan: summer payments.
“Allow us to have the option of paying for summer health insurance or waive it because that will save us $470 per semester and Save us $117.50 dollars per month” was a demand made in a GSS meeting agenda obtained by The Post.
Ferris and other GSS members found that OU subsidizes only 10% of the total health insurance cost, with the rest being covered out of pocket, according to GSS records. The data also shows that peer institutions average between 70-80% subsidy of their graduate student health insurance. The Health Insurance Committee demands a subsidize increase of 12-70%, according to that agenda.
On Feb. 19, Mary Magdalene Chumbow and Suleyman Gurbanov, both media arts Ph.D. students, and other international graduate students attended a general body Student Senate meeting to voice their concerns about the increase. University officials gave a presentation about the updated health care plan provided by UnitedHealthcare.
When the students entered Room 235 of Walter Hall, they only had one wish — to be heard. Chumbow felt like she was being exploited by the university, and she was ready for change.
Gurbanov was right beside Chumbow at the Student Senate meeting, sharing similar concerns about the increase of health insurance. Gurbanov said he is tired of talking about the health insurance fiasco; he just wants answers from the university.
“We wanted to be heard. Everybody was angry. Everybody was feeling used and exploited.”—Mary Magdalene Chumbow, Media Arts Ph.D. student
“We wanted to be heard,” Chumbow said. “Everybody was angry. Everybody was feeling used and exploited.”
Sabin said OU does not profit from its health care policies with students.
“Ohio University remains committed to helping students in need however possible,” Sabin said in an email. “The Bobcats Helping Bobcats program was set up to ensure that those in need had access to additional resources, including emergency microgrants, housing assistance, Cats Cupboard, and more.”
Whether a student comes from Egypt or Cameroon, graduate students want to see a change in health care policy.
“Even if I’m leaving, I don’t care,” Abdelaal said. “I care about the students who are coming to Athens.”


Special variant of an RxSocketSubject that translates between regular JS objects and ArrayBuffer streams. Best used for sending high-level protocol values over a low-level stream.
Generated using TypeDoc
Special variant of an RxSocketSubject that translates between regular JS objects and ArrayBuffer streams. Best used for sending high-level protocol values over a low-level stream.


A
Apps Marketplace
Home
History
About
About Us
An application program is a program designed to perform a group of coordinated functions, tasks, or activities for the benefit of the user.
Back


A radiative transfer code which works for dense random media. The R2T2 is a novel method which will be used to simulate light-scattering from asteroid surfaces. Tech: Fortran, MPI.
A modernized version of the Fortran 77 radiative transfer code RT-CB. The reimplementation worked as a base for the R2T2. Tech: Fortran, MPI and OpenMP.
Fortran and C++ ray tracer which can handle densely packed media. Based on the Fortran SIRIS4. Tech: CGAL. Image: Link to the paper and open source version of the
A C++ packing algorithm, which can be used to pack irregular meshes. The output is used as an input for my other works. Tech: FCL: Flexible collision library.
Implemented features for the computational space mission camera simulator Sispo. Tech: Python, Cython, C, Docker.
Implemented openmct plugins for mission control center. Tech: Python, Javascript, SQL.
Solo project submitted to the Junction May Online Challenge. Doorbot reminds you to take the trash out before leaving the apartment. Tech: Slackbot, Raspberry Pi+electronics, Python
Gameboy game for Mini Jam 30 made by using GBStudio. Made while waiting airplane in Shanghai. Graphics were drawn by my sister. Tech: GBStudio
A "Keep Talking and Nobody Explodes"-clone made for the Games Now! Game jam. The art mimics 60's science fiction. Role: Scripting. Tech: Unity3D and C#.
Wank is an old-school button masher, in which 16 players can take part in an intergalactic race called Wank. The game was made at the Tuusula game jam and I helped to implement the user interface. Tech: Unity3D, C#
A strategy game in which the player builds a space station. The game was made by three people as a course project. Tech: Unity3D, C# and Blender.
Multiplayer AR Ping Pong phone game created during Junction 2019. Tech: Unity3D, C#, AR.
Halted WIP: A 2.5D platformer, which is trying to mimic the feeling of games like Pandemonium or Wild 9. Tech used: Unity3D.
Halted WIP: Even a child can pick a language without reading books. In this game, you learn languages like a child. The player is put into different scenarios from which they need to survive. Everything happens in foreign language: If a customs officer wants "huotui", be prepared to show it. Tech used: Unity3D, SteamVR, and Blender (Modeling and animation).
More interactive version of this portfolio. Tech used: Javascript, ThreeJS.


ImageInfo
public struct ImageInfo
Describes pixel dimensions and encoding. Bitmap
, Image
, Pixmap
, and Surface
can be created from ImageInfo
. ImageInfo
can be retrieved from Bitmap
and
Pixmap
, but not from Image
and Surface
. For example, Image
and Surface
implementations may defer pixel depth, so may not completely specify ImageInfo
.
ImageInfo
contains dimensions, the pixel integral width and height. It encodes
how pixel bits describe alpha, transparency; color components red, blue,
and green; and ColorSpace
, the range and linearity of colors.
-
Returns pixel count in each row.
Declaration
Swift
public var width: Int32
-
Returns pixel row count (height)
Declaration
Swift
public var height: Int32
-
Returns the colortype for this ImageInfo
Declaration
Swift
public var colorType: ColorType
-
Returns the alpha type
Declaration
Swift
public var alphaType: AlphaType
-
Returns SkColorSpace, the range of colors - the returned value is immutable
Declaration
Swift
public var colorSpace: ColorSpace?
-
Creates
ImageInfo
from integral dimensions width and height,ColorType
,AlphaType
, and optionally `ColorSpace.If
ColorSpace
cs isnil
andImageInfo
is part of drawing source:ColorSpace
defaults to sRGB, mapping intoSurface
ColorSpace
.Parameters are not validated to see if their values are legal, or that the combination is supported.
Declaration
Swift
public init(width: Int32, height: Int32, colorType: ColorType, alphaType: AlphaType, colorSpace: ColorSpace? = nil)
Parameters
width
pixel column count; must be zero or greater
height
pixel row count; must be zero or greater
colorType
the colortype
alphaType
the alpha type
colorSpace
range of colors; may be
nil
Return Value
created
ImageInfo
-
Creates
ImageInfo
from integral dimensions width and height The returned imageInfo sets the colorType to the default platform color type (rgb8888) and thealphaType
is set to.premul
and the colorspace is set tonil
Parameters are not validated to see if their values are legal, or that the combination is supported.
Declaration
Swift
public init(_ width: Int32, _ height: Int32)
Return Value
created
ImageInfo
-
Number of bits used by the colorType (this is bytesPerPixel multiplied by 8)
Declaration
Swift
public var bitsPerPixel: Int32 { get }
-
Returns the number of bytes necesary to allocate the image of the
width
xheight
that usesbytesPerPixel
to store the data.Declaration
Swift
public var bytesSize: Int { get }
-
Returns the number of bytes necessary to store one row of pixels
Declaration
Swift
public var rowBytes: Int { get }
-
Returns true if
alphaType
is set to hint that all pixels are opaque; their alpha value is implicitly or explicitly 1.0. If true, and all pixels are not opaque, Skia may draw incorrectly.Does not check if
colorType
allows alpha, or if any pixel value has transparency.Declaration
Swift
public var isOpaque: Bool { get }
-
Returns a new ImageInfo instance that has the width and height changed per the specified parameters
Declaration
Swift
public func withDimensions(width: Int32, height: Int32) -> ImageInfo
-
Returns a new ImageInfo instance that has the colorType changed with the specified parameter
Declaration
Swift
public func withColorType(_ colorType: ColorType) -> ImageInfo
-
Returns a new ImageInfo instance that has the colorSpace changed with the specified parameter
Declaration
Swift
public func withColorSpace(_ colorSpace: ColorSpace?) -> ImageInfo
-
Returns a new ImageInfo instance that has the colorSpace changed with the specified parameter
Declaration
Swift
public func withAlphaType(_ alphaType: AlphaType) -> ImageInfo


Cheese for Newbies
Home
Cheese List
Don't settle for Cheese Whiz. Choose a cheese instead
Cheddar
Mozzarella


DowryCoin Bride
The end syllable “coin” had struck a considerable interest in the bridegrooms, fat and near bald father.
As he pursed his lips and rose his spectacle just up to look into his phone about Bitcoin…
…it hit him hard.
He was about to get rich, he dreamt, he drooled. He thought of all the scented toilet paper he could buy, the white gold for his missus and a majestic flat for the family….
…and soon found out the call he was in, had gone silent.
He wouldn’t allow this opportunity to pass like his playful habits of passing gas in crowds…
…fat thumbs which had committed sins because of greed, gluttony and lust, began furiously dialing the numbers of the Bitcoin bride…
…the reply he got was an eerie, static line at the other end, he dialed again and again and with passing time, a chill ran through his senile spine..
..through the window he could see the near frozen haze of the evening as the sun went down…it was cold but he was sweating hard….
..finally the static gave away to his misery and he heard a woman’s voice..
…“hello?”, said the calm female voice, “I missed you so much!”… his eyes bulged, the very same mouth which acted like a sword, many times, had lost it’s voice..
…a feeble gasp accompanied by horror escaped that vile mouth which made the tobacco soaked teeth clearly visible..
“I missed you so much! papa!”
Right in the wall, up the corded phone, hung the picture of this daughter – his dead daughter decorated by flowers and respected by the pious paste of sandalwood.


Forgot the password to your account?  Sign in


Generated applications can be deployed on Azure Spring Apps in a few easy steps, please refer to the readme file in the generated project for the deployment guide.
Detailed documentation is also available here.
Provision your Azure Resources using NubesGen
https://nubesgen.com
Please note that the current version of this form only supports the following selections within NubesGen:
Services, Databases and selections not listed above are currently not supported and code will not be generated by this form if provisioned within NubesGen.


'3BlackChicks Review...'
TRAINING DAY (2001) Rated R; running time 122 minutes Genre: drama/action Seen at: Lowes Star Southfield (Detroit, Michigan) Official site: http://trainingday.warnerbros.com/ IMDB site: http://us.imdb.com/Details?0139654 Written by: David Ayer Directed by: Antoine Fuqua Cast: Denzel Washington, Ethan Hawke, Scott Glenn, Eva Mendes, Snoop Dogg, Dr. Dre, Harris Yulin, Raymond J. Barry, Cliff Curtis, Emilio Rivera, Tom Berenger, Charlotte Ayanna, Macy Gray
Review Copyright Rose Cooper, 2001 Review URL: http://www.3blackchicks.com/bamstrainingday.html
Pardon my tangent, but I like watching Stanley Kubrick's FULL METAL JACKET a lot, especially the home video version. Through the magic of video, I can watch, transfixed, as actors R. Lee Ermey and Vincent D'Onofrio (along with the rest of the gang) teach a masters-level film seminar as a Marine Corps Drill Instructor and his Instructee gone terribly wrong. And, as the emphasis moves from Boot Camp to Vietnam, home video also allows me to turn the TV off and move on to Something Else - since, for me, most everything past FMJ's Boot Camp just doesn't compare to that brilliant first act.
Which brings me to TRAINING DAY.
The Story (WARNING: **spoilers contained below**) LAPD cop Jake Hoyt (Ethan Hawke) is excited about his new gig, as an undercover narcotics officer; still naive, Hoyt believes he can Make A Difference in the War On [Some] Drugs, and he's eager to prove himself to his new boss. Said boss - one Alonzo Harris (Denzel Washington), wants Hoyt to prove himself, alright; but not in the way Hoyt thinks.
Hoyt quickly discovers that Harris is, at best, a rogue cop playing by his own rules, seemingly only answering to his code of street conduct. And at worse, Harris is a completely corrupt cop, taking advantage of the power his badge and shield affords him.  Hoyt has to decide, and decide quickly, just how far into the dirt he'll let Harris drag him.
The Upshot (WARNING: **more spoilers contained below**): Sure, there were other actors populating this movie - Scott Glenn, Harris Yulin, Tom Berenger, Emilio Rivera, and Cliff Curtis, just to name a few (Snoop Dogg counts too, I reckon; my jury's still out on including Macy Grey and Dr. Dre in the "actor" category) . But make no mistake: this picture belonged to Denzel Washington and Ethan Hawke. For better or for worse.
For me, it's the second half to two-thirds of this picture, that make up the "for worse". Like FULL METAL JACKET before it, the "training" bits of TRAINING DAY were a riveting portrait of Denzel Washington at his over-the-top thug life finest; even when he was obviously trying too hard to be Down [did someone buy Denzel a copy of 'GhettoSpeak 101'?], Washington's wolfish narcotics cop was fascinating to watch - and cringe at - in all his raw power. Ethan Hawke as rookie undercover cop Jake Hoyt, in training mode, complimented Washington nicely; even as Alonzo Harris became progressively nastier, and Hoyt settled into wary pupil status, the lessons on surviving in this big bad world, were great to watch. The first few pages of my notepad were riddled with reactions to Professa' Alonzo's whip as it connected with Student Jake's tender butt.
Everything changed suddenly, when class was apparently dismissed, and Harris' earth-bound motivations became clear; once Alonzo was revealed to be indeed smaller-than-life, the thrill was gone for me as a viewer. The longer this film went on, the less I liked it, and the more the sheer mass of my suspended disbelief weighed me down. Scene after scene after endless boggling scene had me silently screaming over how incredibly doofus Hoyt had to be to let himself be caught up in Harris' madness to such an extent.
 I knew I was Through when the repeated cacophony of "my nigga" failed to invoke the gag response in me. By the time the overwrought, ObCrimeDoesn'tPay anticlimactic mishmash of BONNIE AND CLYDE and the "tollbooth" scene from THE GODFATHER went down, I was anxious to Exit, Stage Right.
 Even if every frame was an accurate representation of Life On The Mean Streets (and believe me, my eyes rolled so much, the on-screen 'bangers used them for dice), I simply failed to believe, or care anymore.
Bammer's Bottom Line: As with SERENDIPITY, it looks like I'm swimming upstream again; while most reviewers are apparently giving TRAINING DAY their seal of approval, I can't manage much more than a indifferent yellowlight rating for Washington and Hawke's efforts. And like I said before, Say La Vee.
TRAINING DAY (rating: yellowlight): As a Rilly Bad Guy, Denzel Washington is still a wet-behind-the-ears rookie. But he does look good behind those ears.
Rose "Bams" Cooper Webchick and Editor, 3BlackChicks Review Entertainment Reviews With Flava! Copyright Rose Cooper, 2001 EMAIL<EMAIL_ADDRESS>http://www.3blackchicks.com/
========== X-RAMR-ID: 29729 X-Language: en X-RT-ReviewID: 253563 X-RT-TitleID: 1110027 X-RT-SourceID: 447 X-RT-AuthorID: 3672
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


LIGHTKURVE_CITATION
ASTROPY_CITATION
ASTROQUERY_CITATION
@MISC{2019ascl.soft05007B, author = {{Brasseur}, C.~E. and {Phillip}, Carlita and {Fleming}, Scott W. and {Mullally}, S.~E. and {White}, Richard L.}, title = "{Astrocut: Tools for creating cutouts of TESS images}", keywords = {Software}, year = 2019, month = may, eid = {ascl:1905.007}, pages = {ascl:1905.007}, archivePrefix = {ascl}, eprint = {1905.007}, adsurl = {https://ui.adsabs.harvard.edu/abs/2019ascl.soft05007B}, adsnote = {Provided by the SAO/NASA Astrophysics Data System} }
When using Lightkurve, we kindly request that you cite the following packages:
lightkurve
Copy BibTeX
astropy
Copy BibTeX
astroquery
Copy BibTeX
— if you are using
search_lightcurve()
or
search_targetpixelfile()
.
tesscut
Copy BibTeX
— if you are using
search_tesscut()
.


Volunteer
e-Luminate Foundation
Cambridge, UK
- Implemented, developed and supported a self-hosted wordpress site (running MySQL) for the annual
festival of light. I was also responsible for implementing the design of the site which required me
to learn and apply skills in HTML, CSS, JavaScript and PHP.
- Implemented and supported infrastructure for the foundation. This required me to understand how the
Linux based web hosting was configured. I was also responsible for domain name management, DNS and
email services.
- Worked alongside a team of volunteers and exhibitors year on year, to successfully deliver the 2015,
16 and 17 light festival which consisted of events and installations raising awareness about
sustainability and well being.