text:
  Polylidar3D

Polygon Extraction from 2D Point Sets, Unorganized/Organized 3D Point Clouds, and Triangular Meshes

  Key Features •
  Documentation •
  Use Cases •
  Credits •
  Related •
  Citations •
  License

[![Docs](https://img.shields.io/badge/API-docs-blue)](https://jeremybyu.github.io/polylidar/)
[![Cite 2D](https://img.shields.io/badge/Cite%202D-%2010.1109--LRA.2020.3002212-red)](https://ieeexplore.ieee.org/document/9117017)
[![Cite 3D](https://img.shields.io/badge/Cite%203D-10.3390%2Fs20174819-red)](https://www.mdpi.com/1424-8220/20/17/4819)

## Key Features

* Fast (Multi)Polygon Extraction from multiple sources of 2D and 3D Data
  * Written in C++ for portability
  * Extremely fast single-threaded but includes CPU multi-threading using data and task-based parallelism
  * Polygons with holes may be returned
* Python3 bindings using PyBind11
  * Low overhead for calling python/cpp interface (no copying of point cloud data)
* Python and C++ Examples
  * Examples from 2D point sets, unorganized 3D point clouds, organized 3D point clouds (i.e., range images), and user provided meshes
* Cross platform
  * Windows and Linux ready

Polylidar3D is a non-convex polygon extraction algorithm which takes as input either unorganized 2D point sets, unorganized 3D point clouds (e.g., airborne LiDAR point clouds), organized 3D point clouds (e.g., range images), or user provided meshes. In 3D, the non-convex polygons extracted represent flat surfaces in an environment, while interior holes represent obstacles on said surfaces. The picture above provides an examples of Polylidar3D extracting polygons from a 2D point set and a 3D triangular mesh; green is the concave hull and orange are interior holes. Polylidar3D outputs *planar* triangular segments and their polygonal representations. Polylidar3D is extremely fast, taking as little as a few milliseconds and makes use of CPU multi-threading and GPU acceleration when available.

Here is a small introductory blog-post about [Polylidar3D](https://robosim.dev/posts/polylidar/).

## Documentation and Branches

Please see [documentation](https://jeremybyu.github.io/polylidar/) for installation, api, and examples. Note that Polylidar went though major changes in July 2020 for 3D work, now called `Polylidar3D`. The old repository for 2D work (and some *basic* 3D) is found in the branch [polylidar2D](https://github.com/JeremyBYU/polylidar/tree/polylidar2d) and is connected to this [paper](https://ieeexplore.ieee.org/document/9117017). `Polylidar3D` can still handle 2D point sets but the API is different and not the focus of this repo. For papers referencing Polylidar2D and Polylidar3D please see Citations.

*Eventually* I am going to make a standalone cpp/header file for 2D point set -> polygon extraction for those that don't need any of the features of `Polylidar3D`.

## Polylidar Use Cases

* [Polylidar-RealSense](https://github.com/JeremyBYU/polylidar-realsense) - Live ground floor detection with Intel RealSense camera using Polylidar
* [Polylidar-KITTI](https://github.com/JeremyBYU/polylidar-kitti) - Street surface and obstacle detection from autonomous driving platform
* [PolylidarWeb](https://github.com/JeremyBYU/polylidarweb). An very old Typescript (javascript) version with live demos of Polylidar2D
* [Concave-Evaluation](https://github.com/JeremyBYU/concavehull-evaluation) - Evaluates and benchmarks several competing concavehull algorithms

## Credits

This software is only possible because of the great work from the following open source packages:

* [Delaunator](https://github.com/mapbox/delaunator) - Original triangulation library
* [DelaunatorCPP](https://github.com/delfrrr/delaunator-cpp) - Delaunator ported to C++ (used)
* [parallel-hashmap](https://github.com/greg7mdp/parallel-hashmap) - Fast hashmap library (used)
* [marl](https://github.com/google/marl) - A parallel thread/fiber task scheduler (used)
* [PyBind11](https://github.com/pybind/pybind11) - Python C++ Binding (used)
* [Robust Geometric Predicates](https://www.cs.cmu.edu/~quake/robust.html) - Original Robust Geometric predicates
* [Updated Predicates](https://github.com/danshapero/predicates) -Updated geometric predicate library (used)

## Related Methods

### 2D ConcaveHull Extraction

* [CGAL Alpha Shapes](https://doc.cgal.org/latest/Alpha_shapes_2/index.html) - MultiPolygon with holes
* [PostGIS ConcaveHull](http://postgis.net/docs/ST_ConcaveHull.html) - Single Polygon with holes
* [Spatialite ConcaveHull](https://www.gaia-gis.it/fossil/libspatialite/wiki?name=tesselations-4.0) - MultiPolygon with holes
* [Concaveman](https://github.com/mapbox/concaveman) - A 2D concave hull extraction algorithm for 2D point sets

## Contributing

Any help or suggestions would be appreciated!

## Citation

### 2D

If are using Polylidar for 2D work please cite:

J. Castagno and E. Atkins, "Polylidar - Polygons From Triangular Meshes," in IEEE Robotics and Automation Letters, vol. 5, no. 3, pp. 4634-4641, July 2020, doi: 10.1109/LRA.2020.3002212.
[Link to Paper](https://ieeexplore.ieee.org/document/9117017)

```
@ARTICLE{9117017,
  author={J. {Castagno} and E. {Atkins}},
  journal={IEEE Robotics and Automation Letters},
  title={Polylidar - Polygons From Triangular Meshes},
  year={2020},
  volume={5},
  number={3},
  pages={4634-4641}
}
```

### 3D

If you are using Polylidar3D for 3D work please cite:

J. Castagno and E. Atkins, "Polylidar3D - Fast Polygon Extraction from 3D Data," in MDPI Sensors, vol. 20, no.17, 4819, September 2020, doi: 10.3390/s20174819
[Link to Paper](https://www.mdpi.com/1424-8220/20/17/4819)

```
@Article{s20174819,
author = {Castagno, Jeremy and Atkins, Ella},
title = {Polylidar3D-Fast Polygon Extraction from 3D Data},
journal = {Sensors},
volume = {20},
year = {2020},
number = {17},
article-number = {4819},
url = {https://www.mdpi.com/1424-8220/20/17/4819},
issn = {1424-8220}
}
```

## License

MIT

---

> GitHub [@jeremybyu](https://github.com/JeremyBYU)

repository: JeremyBYU/polylidar

repo_name: JeremyBYU/polylidar


text:
# ReloadHotbar
Loads any changes made to the `hotbar.nbt` file when the "Saved Hotbars" tab in the creative menu is clicked.
Changes made in Minecraft are not saved until the game closes, this is vanilla behavior. Changing this would require more work than I really feel like doing right now, do `/data get entity @s SelectedItem` if you need to bring an item out of Minecraft and edit it.

Uses the [Fabric launcher](https://fabricmc.net/use/), does not use the Fabric API.

license: MIT

repository: Penguin-Spy/ReloadHotbar

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: Penguin-Spy/ReloadHotbar


text:
# Simple Compiler
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
  [![Made in MRL](https://img.shields.io/badge/Made%20in-Mechatronic%20Research%20Labratories-red.svg)](https://www.qiau.ac.ir/)

A simple package for compiler practice

In two **phases**
1. Lexical analyzer
2. Syntax analyzer
---
## Lexical analyzer
![my simple lexical definite final autonama](https://github.com/amirsharifi74/my_compiler_exrecise/blob/master/lexical_analizer/my_scanner_diagram.png "lexical definite final autonama(DFA)")

### Run

`git clone https://github.com/amirsharifi74/my_compiler_exrecise.git`

`python3 lexical_analizer/scanner.py -i <input_file> -o <output_file>`

| Short_param | Long_param | description                     | default |
| ----------- | ---------- | ------------------------------- | ------- |
| -o          | --output   | path to input source code file  | out.txt |
| -i          | --input    | path to outout source code file | test.pp |

## Syntax analyzer
   Simple grammer to detect array of our custum language(my language name is amir)
   Give output of Lexical analizer(tokens) and get the syntax error in CMD
   the rest of the language grammer is similar to this

### Grammer
   ```
   type -> simple

   |  id

   | array [simple] of type

   symple -> integer

   | char

   | num dotdot num

   ```

### params
| Short_param | Long_param | description                    | default |
| ----------- | ---------- | ------------------------------ | ------- |
| -i          | --input    | path to input tokens file | out.txt |

### Run

`python3 syntax_analizer/parser.py  -i <your_tokens_file_path>`

---
## Impilimentation with antlr4
[Antlr4 Github page](https://github.com/antlr/antlr4 "Antlr's Homepage")

### installation antlr4
[getting start with antlr4](https://github.com/antlr/antlr4/blob/master/doc/getting-started.md)

Dont forget to install `pip install antlr4-python3-runtime`

**caution**: for running my sample code you should generate code for python

```
cd antlr/
antlr4 -Dlanguage=Python3 Array.g4
```
### Run antlr
First of all write your code in test.pp
```
cd antlr/
python3 ArrayDetector.py
```

branch_name: refs/heads/master


text:
[![CircleCI](https://circleci.com/gh/TeamAikon/chain-js.svg?style=svg)](https://circleci.com/gh/TeamAikon/chain-js)

<img src="./docs/images/chainjs_logo.png" width="200" >

# Overview

ChainJS is a low-level Javascript helper library that helps you write code that can work with multiple blockchains. ChainJs uses a plug-in model and a unified interface to do common blockchain functions like constructing, signing, and sending blockchain transactions.

Chains plug-ins included: **Algorand**, **EOS**, **Ethereum (V1)** - more coming soon

### Example code for sending a token

```javascript
  // get a chain object (for an Ethereum chain using Ropsten testnet)
  const ethChain = new ChainFactory().create(ChainType.EthereumV1, ropstenEndpoints)
  // create a transaction object
  const sendTokenTx = await chain.new.Transaction()
  // set contract action(s) - composeAction simplifies transaction composition
  sendTokenTx.actions = [ await chain.composeAction(ChainActionType.TokenTransfer, { to: '0x271...', contractAddress: '0x048...', amount: '10.00' }) ]
  ...
  // sign and send the transaction to the chain
  await sendTokenTx.sign([privateKey])
  await sendTokenTx.send(ConfirmType.None)
```

### Example code for creating an account on-chain

```javascript
  // get a chain object (for an EOS chain using Kylin testnet)
  const eosChain = new ChainFactory().create(ChainType.ChainEosV2, kylinEndpoints, chainSettings)

  // new account options
  const accountOptions = {
    accountName: 'abcdefghijkl'
    creatorAccountName: 'mypayeraccnt',
    creatorPermission: 'active',
    ...
  }

  // get an account creator class
  const accntCreator = await eosChain.new.CreateAccount()
  // generate the transaction to create an on-chain account
  await accntCreator.composeTransaction(AccountType.Native)
  // sign and send the transaction to the chain
  await accntCreator.transaction.sign([{myPrivateKeys}])
  accntCreator.transaction.send()

```

### Same code - mulitple chains

By using a standardized symantic for common chain activites, you can write code once that works for many chains. The plug-in maps contract actions, transaction composition, and error types to use a unified set. With ChainJs you can build apps to support mulitple chains much more quickly.

### Native chain libraries included

Although you can do most common tasks using the unified ChainJs api, you can still use the native chain library when necessary. For example, to access the eosjs library for an EOS chain, just cast the generic chain object to an EOS-specific chain object. Then you can access the eosjs api. Same goes for other chains. For example, for Ethereum, you can access web3 directly from the chain object.

```javascript
   /** Using chain-specifc features - ex. eosjs */
   const myChain = new ChainFactory().create(ChainType.ChainEosV2, kylinEndpoints, chainSettings)
   // (Typescript) cast generic chain to EOS chain object
   const eosChain = (mychain as ChainEosV2) // EOSIO node version 2.x
   eosChain.eosjs.api.transact({...})
```
```javascript
   /** Using Ethereum chain-specifc features - ex. web3 */
   ...
   ethChain.web3.api.getBalance(address)
```

More chain plug-ins will be coming soon. You can also build a plug-in to support your chain of choice. Feel free to open a PR to merge in your plug-in or to create an issue for a feature request or bug.

### How to use

Just install the chainjs library to get started
```bash
 $ yarn add @open-rights-exchange/chain-js
```

To run ts files (and examples), use ts-node (with the --files option to include local customTypes)
```bash
 $ ts-node --files mycode.ts
```

repository: Open-Rights-Exchange/chain-js

gha_language: TypeScript

gha_license_id: MIT

repo_name: Open-Rights-Exchange/chain-js


text:
# AVFS

Another Virtual File System for Go

![CI](https://github.com/avfs/avfs/workflows/CI/badge.svg)
[![codecov](https://codecov.io/gh/avfs/avfs/branch/master/graph/badge.svg)](https://codecov.io/gh/avfs/avfs)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/avfs/avfs)](https://pkg.go.dev/github.com/avfs/avfs)
[![Release](https://img.shields.io/github/release/avfs/avfs.svg)](https://github.com/avfs/avfs/releases/latest)
[![License](https://img.shields.io/github/license/avfs/avfs)](/LICENSE)
[![Built with Mage](https://magefile.org/badge.svg)](https://magefile.org)
[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Favfs%2Favfs.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Favfs%2Favfs?ref=badge_shield)

## Overview

**AVFS** is a virtual file system abstraction, inspired mostly
by [Afero](http://github.com/spf13/afero) and Go standard library. It provides
an abstraction layer to emulate the behavior of a **Linux file system** and
provides several features :

- a set of **constants**, **interfaces** and **types** for all file systems
- a **test suite** for all file systems (emulated or real)
- a very basic **identity manager** allows testing of user related functions (
  Chown, Lchown) and file system permissions
- all file systems support user file creation mode mask (**Umask**)
- **symbolic links**, **hard links** and **chroot** are fully supported for some
  file systems (MemFS, OsFS)
- some file systems support **multiple users concurrently**  (MemFS)
- each file system has its **own package**

## Installation

This package can be installed with the go get command :

```
go get github.com/avfs/avfs
```

It is only tested with Go modules enabled (`GO111MODULE=on`) and Go version >=
1.15

## Getting started

To make an existing code work with **AVFS** :

- replace all references of `os`, `path/filepath` and `ioutil`
  with the variable used to initialize the file system (`vfs` in the following
  examples)
- replace all references of `os.TempDir()` by `vfs.GetTempDir()`.
- import the packages of the file systems and, if necessary, the `avfs` package
  and initialize the file system variable.
- some file systems provide specific options available at initialization. For
  instance `MemFS` needs `WithMainDirs` option to create `/home`, `/root`
  and `/tmp` directories.

## Examples

### Symbolic links

The example below demonstrates the creation of a file, a symbolic link to this
file, for a different file systems (depending on an environment variable). Error
management has been omitted for the sake of simplicity :

```go
package main

import (
	"bytes"
	"os"
	"log"

	"github.com/avfs/avfs"
	"github.com/avfs/avfs/vfs/memfs"
	"github.com/avfs/avfs/vfs/osfs"
)

func main() {
	var vfs avfs.VFS

	switch os.Getenv("ENV") {
	case "PROD": // The real file system for production.
		vfs, _ = osfs.New()
	default: // in memory for tests.
		vfs, _ = memfs.New(memfs.WithMainDirs())
	}

	// From this point all references of 'os', 'path/filepath' and 'ioutil'
	// should be replaced by 'vfs'
	rootDir, _ := vfs.TempDir("", avfs.Avfs)
	defer vfs.RemoveAll(rootDir)

	aFilePath := vfs.Join(rootDir, "aFile.txt")

	content := []byte("randomContent")
	_ = vfs.WriteFile(aFilePath, content, 0o644)

	aFilePathSl := vfs.Join(rootDir, "aFileSymlink.txt")
	_ = vfs.Symlink(aFilePath, aFilePathSl)

	gotContentSl, _ := vfs.ReadFile(aFilePathSl)
	if !bytes.Equal(content, gotContentSl) {
		log.Fatalf("Symlink %s : want content to be %v, got %v",
			aFilePathSl, content, gotContentSl)
	}

	log.Printf("content from symbolic link %s : %s", aFilePathSl, gotContentSl)
}
```

### Multiple users creating simultaneously directories

The example below demonstrates the concurrent creation of subdirectories under a
root directory by several users in different goroutines (works only with
MemFS) :

```go
package main

import (
	"fmt"
	"sync"

	"github.com/avfs/avfs"
	"github.com/avfs/avfs/idm/memidm"
	"github.com/avfs/avfs/vfs/memfs"
	"github.com/avfs/avfs/vfsutils"
)

func main() {
	const (
		maxUsers  = 100
		groupName = "test_users"
	)

	vfs, _ := memfs.New(memfs.WithMainDirs(), memfs.WithIdm(memidm.New()))

	rootDir, _ := vfs.TempDir("", avfs.Avfs)
	vfs.Chmod(rootDir, 0o777)

	g, _ := vfs.GroupAdd(groupName)

	var wg sync.WaitGroup
	wg.Add(maxUsers)

	for i := 0; i < maxUsers; i++ {
		go func(i int) {
			defer wg.Done()

			userName := fmt.Sprintf("user_%08d", i)
			vfs.UserAdd(userName, g.Name())

			fsU := vfs.Clone()
			fsU.User(userName)

			path := fsU.Join(rootDir, userName)
			fsU.Mkdir(path, avfs.DefaultDirPerm)
		}(i)
	}

	wg.Wait()

	infos, _ := vfs.ReadDir(rootDir)

	log.Println("number of dirs :", len(infos))
	for _, info := range infos {
		sst := vfsutils.ToSysStat(info.Sys())
		u, _ := vfs.LookupUserId(sst.Uid())

		log.Println("directory :", info.Name(),
			", mode :", info.Mode(),
			", owner :", u.Name())
	}
}
```

## Status

Don't be fooled by the coverage percentages, everything is a work in progress.
All the file systems pass the common test suite, but you should not use this in
a production environment at this time.

## Diagram

The interface diagram below represents the main interfaces, methods and
relations between them :

## File systems

All file systems implement at least `avfs.FS` and `avfs.File` interfaces. By
default, each file system supported methods are the most commonly used from
packages `os`, `path/filepath` and `ioutil`. All methods (except `TempDir` which
is found in packages `os` and `ioutil`)
have identical names as their functions counterparts. The following file systems
are currently available :

File system |Comments
------------|--------
[BasePathFS](vfs/basepathfs)|file system that restricts all operations to a given path within a file system
[DummyFS](vfs/dummyfs)|Non implemented file system to be used as model
[MemFS](vfs/memfs)|In memory file system supporting major features of a linux file system (hard links, symbolic links, chroot, umask)
[OrefaFS](vfs/orefafs)|Afero like in memory file system
[OsFS](vfs/osfs)|Operating system native file system
[RoFS](vfs/rofs)|Read only file system

## Supported methods

File system methods
 `avfs.FS`|Comments
----------------------------------|--------
`Abs`|equivalent to `filepath.Abs`
`Base`|equivalent to `filepath.Base`
`Chdir`|equivalent to `os.Chdir`
`Chmod`|equivalent to `os.Chmod`
`Chown`|equivalent to `os.Chown`
`Chroot`|equivalent to `syscall.Chroot`
`Chtimes`|equivalent to `os.Chtimes`
`Clean`|equivalent to `filepath.Clean`
`Clone`| returns a shallow copy of the current file system (see MemFS) or the file system itself
`Create`|equivalent to `os.Create`
`Dir`|equivalent to `filepath.Dir`
`EvalSymlinks`|equivalent to `filepath.EvalSymlinks`
`FromSlash`|equivalent to `filepath.FromSlash`
`Features`| returns the set of features provided by the file system or identity manager
`GetTempDir`|equivalent to `os.TempDir`
`Getwd`|equivalent to `os.Getwd`
`Glob`|equivalent to `filepath.Glob`
`HasFeature`| returns true if the file system or identity manager provides a given feature
`IsAbs`|equivalent to `filepath.IsAbs`
`IsPathSeparator`|equivalent to `filepath.IsPathSeparator`
`Join`|equivalent to `filepath.Join`
`Lchown`|equivalent to `os.Lchown`
`Link`|equivalent to `os.Link`
`Lstat`|equivalent to `os.Lstat`
`Mkdir`|equivalent to `os.Mkdir`
`MkdirAll`|equivalent to `os.MkdirAll`
`Open`|equivalent to `os.Open`
`OpenFile`|equivalent to `os.OpenFile`
`OSType`| returns the operating system type of the file system
`ReadDir`|equivalent to `ioutil.ReadDir`
`ReadFile`|equivalent to `ioutil.ReadFile`
`Readlink`|equivalent to `os.Readlink`
`Rel`|equivalent to `filepath.Rel`
`Remove`|equivalent to `os.Remove`
`RemoveAll`|equivalent to `os.RemoveAll`
`Rename`|equivalent to `os.Rename`
`SameFile`|equivalent to `os.SameFile`
`Split`|equivalent to `filepath.Split`
`Stat`|equivalent to `os.Stat`
`Symlink`|equivalent to `os.Symlink`
`TempDir`|equivalent to `ioutil.TempDir`
`TempFile`|equivalent to `ioutil.TempFile`
`ToSlash`|equivalent to `filepath.ToSlash`
`Truncate`|equivalent to `os.Truncate`
`Walk`|equivalent to `filepath.Walk`
`WriteFile`|equivalent to `ioutil.WriteFile`

File methods
 `avfs.File`|Comments
-----------------------------|--------
`Chdir`|equivalent to `os.File.Chdir`
`Chmod`|equivalent to `os.File.Chmod`
`Chown`|equivalent to `os.File.Chown`
`Close`|equivalent to `os.File.Close`
`Fd`|equivalent to `os.File.Fd`
`Name`|equivalent to `os.File.Name`
`Read`|equivalent to `os.File.Read`
`ReadAt`|equivalent to `os.File.ReadAt`
`Readdir`|equivalent to `os.File.Readdir`
`Readdirnames`|equivalent to `os.File.Readdirnames`
`Seek`|equivalent to `os.File.Seek`
`Stat`|equivalent to `os.File.Stat`
`Truncate`|equivalent to `os.File.Truncate`
`Write`|equivalent to `os.File.Write`
`WriteAt`|equivalent to `os.File.WriteAt`
`WriteString`|equivalent to `os.File.WriteString`

## Identity Managers

Identity managers allow users and groups management. The ones implemented
in `avfs` are just here to allow testing of functions related to users (Chown,
Lchown)
and access rights, so they just allow one default group per user.

All file systems supporting identity manager implement by default the identity
manager `DummyIdm`
where all functions returns `avfs.ErrPermDenied`.

Identity Manager |Comments
-----------------|--------
[DummyIdm](idm/dummyidm)|dummy identity manager where all functions are not implemented
[MemIdm](idm/memidm)|In memory identity manager
[OsIdm](idm/osidm)|Identity manager using os functions
[SQLiteIdm](https://github.com/avfs/sqliteidm)|Identity manager backed by a SQLite database

Identity Manager methods
`avfs.FS`
 `avfs.IdentityMgr`|Comments
--------------------------------------------------------------|--------
`GroupAdd`| adds a new group
`GroupDel`| deletes an existing group
`LookupGroup`| looks up a group by name
`LookupGroupId`| looks up a group by groupid
`LookupUser`| looks up a user by username
`LookupUserId`| looks up a user by userid
`UserAdd`| adds a new user
`UserDel`| deletes an existing user

All the file systems and some Identity managers (see OsFS) provide an additional
interface `UserConnecter`

UserConnecter methods
`avfs.FS` |Comments
------------------------------------|--------
`CurrentUser`| returns the current user
`User`| sets and returns the current user

## License
[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Favfs%2Favfs.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2Favfs%2Favfs?ref=badge_large)

repository: fossabot/avfs

repo_name: fossabot/avfs


text:
---
slug: /portal-manual/france/portal
title: fiskaltrust.Portal
---

## fiskaltrust.Portal
**[https://portal.fiskaltrust.fr](https://portal.fiskaltrust.fr)**

:::danger **DEPRECATED**

The Portal manual is no longer maintained. For the latest documentation, please refer to the PosDealer or PosCreator section of this site.

In case of any questions, we encourage you to refer to our current [fiskaltrust Documentation Platform](https://docs.fiskaltrust.cloud).
For further details, check the corresponding Knowledge Base Articles (KBA), which can be found on the fiskaltrust.Portal.

:::

Please note that various menus and functions presented in this manual are only visible and therefore available after the corresponding authorization has been assigned in the user administration.

The _primary contact_ is the user who has all authorizations for a company and can therefore administer the authorizations.

### Homepage
The fiskaltrust.Portal (hereinafter _ft.Portal_ or simply _Portal_) can be used free of charge by all partners and their PosOperators. It can be reached directly via the URL https://portal.fiskaltrust.fr or via the hyperlink on the homepage  .
All PosOperators, PosDealers, Consultants and PosCreators can easily manage the necessary functions for operating the POS-Systems via the Portal. Further more auditors of the fiscal authorities can export fiscal archives with the functionality of the portal.

![Homepage of fiskaltrust](images/www.fiskaltrust.fr/portal-homepage.png)

![Number 1](../images/Numbers/circle-1o.png) By clicking on the hyperlink _PORTAIL_ on the homepage, the fiskaltrust.Portal can be accessed.
The registration of the user and the company is explained in chapter [Registration](registration-login.md#registration).

### Landing page
The landing page is the welcome page of the fiskaltrust.Portal and can be accessed directly via the URL: https://portal.fiskaltrust.fr

![Landing page of the fiskaltrust.Portal](images/www.fiskaltrust.fr/portal-landing-page.png)
Landing-Page of the ft.portal | [https://portal.fiskaltrust.fr](https://portal.fiskaltrust.fr)

![Number 1](../images/Numbers/circle-1o.png) The login or registration of a user/company on the ft.Portal is initiated by clicking on ![Portal](../images/Buttons/035.png "Portal").

![Landing page (Partner) of the fiskaltrust.Portal](images//www.fiskaltrust.fr/portal-landing-page-partner.png)
Landing-Page of the ft.portal | [https://portal.fiskaltrust.fr](https://portal.fiskaltrust.fr)

![Number 2](../images/Numbers/circle-2o.png) As a PosCreator, PosDealer or consultant, you can voluntarily register in the list of fiskaltrust.Partners via the ft.Portal. These companies will be added to the list found at https://portal.fiskaltrust.fr/public/FilterPartners with their contact details.

repository: fiskaltrust/portal-manual-doc

gha_language: JavaScript

repo_name: fiskaltrust/portal-manual-doc


text:
# ConvolutionTransformation transformation {#openvino_docs_OV_UG_lpt_ConvolutionTransformation}

ngraph::pass::low_precision::ConvolutionTransformation class represents the `Convolution` operation transformation.

The transformation propagates dequantization operations on activations and weights through the `Convolution` operation. The transformation supports several weights quantization approaches:
* quantized weights in low precision with dequantization operations,
* weights in original precision with `FakeQuantize` operation.

Result dequantization `Multiply` constant value *result* is calculated as multiplication for dequantization `Multiply` constant value on activations *a* and dequantization `Multiply` constant value on weights *b* :

\f[
result_{i} = a_{i} \cdot b_{i}
\f]

## Limitations

* Dequantization on activations must be per-tensor. It means that dequantization `Multiply` constant value on activations must be scalar.

## Subgraph before transformation

### Quantized weights in low precision with dequantization operations
The subgraph with quantized `Convolution` before transformation with quantized weights in low precision constant and dequantization operations:

![Convolution before](img/fq_and_convolution.common.png)

### Weights in original precision with FakeQuantize operation
The subgraph with quantized `Convolution` before transformation with weights in original precision and `FakeQuantize` operation:

![Convolution before](img/fq_fq_and_convolution.common.png)

## Subgraph after transformation
The subgraph with `Convolution` operation after the transformation:

![Convolution after](img/fq_and_convolution.transformed.png)

repository: openvinotoolkit/openvino

repo_name: openvinotoolkit/openvino


text:
# docs

## index

1. [monad](monad.md) the monad and applicative
1. [if](if.md) the if expression
1. [for](for.md) the for expression
1. [for-each](for-each.md) the for-each expression
1. [while](while.md) the while and do-while expression
1. [try](try.md) the try expression
1. [MList](MList.md) list
1. [ptr](ptr.md) pointer, a value container
1. [flow](flow.md) code flow
1. [util](util.md) utilities
1. [event-emitter](event-emitter.md) the event emitter
1. [stream](stream.md) the event stream

## relations to vertx and java

The `f.Monad` implements `vertx.Future`
The `f.MList` implements `java.List`

Almost all functions accepts `vertx.Future` or `java.List` as input parameter, and returns `f.Monad` or `f.MList` as output value, so you can easily use `lib f` to work with existing vertx or java world.

In docs, inputs might be marked with `f.Monad` or `f.MList`, but you should know that, it's guaranteed that `vertx.Future` or `java.List` can be the input parameter.

## structure

Utility functions are held in `class F`, including Monad construction.
Operators are held in `class Op`.
Other classes are holding their own functionalities.

Except for container types (e.g. MList, Monad, Ptr), all classes provide their entrance methods with static modifier. (As a result, you can use `import static` to simplify the code.)

## null check

Null checks are performed on all public methods. The following input arguments should not be null:

* monad/future objects
* functions
* container objects

Also, if a function would return a monad/future object, then the returned value should not be null.

For example:

The compose method takes a function, then the function should not be null; the function should returns a future object, then the returned value should not be null.

repository: wkgcass/f

repo_name: wkgcass/f


text:
#Kill 'unclosable' window

Sometimes something glitchy happens with [X11](https://en.wikipedia.org/wiki/X_Window_System) when closing windows e.g. it stops operating and it just won't close (regardless of what window manager you're using). This can be annoying at times.

 Enter `xwininfo` on your terminal
2. You will be prompted to click on a window. Click the 'unclosable' one.
3. Information about the window will appear on your terminal including its `id`
4. Enter `xkill -id <window_id>`and you should be good!

For more info on the commands used, check their manuals:
```sh
man xwininfo # manual for xwininfo
man xkill # manual for xkill
```

repository: jbfrrr/til

repo_name: jbfrrr/til


text:
# CLWO Chat Reader

> A wrapper around MyBB's DVZ shoutbox to allow access to chat logs via HTML request.

## Installation

```sh
$ git clone https://github.com/popey456963/clwo-chat-reader
$ cd clwo-chat-reader
$ npm i
$ npm start
```

## Usage

The API, by default, binds to :3040.  It contains the following endpoints:

 - `/get_comments?from=<from>` - Retrieve the past twenty comments from the specified `from` value or the latest twenty if not specified.

A web-socket address is also served via the same port which will stream new messages as they arrive.

## License

ISC © [popey456963](https://github.com/popey456963)

license: ISC


text:
# cupcake
A lightweight theme for hugo.

# Tips
  - **no pagination**
  - all articles are displayed on the homepage **(Only one page)**
  - articles with **only text or few pictures** is recommended

# Example Site Config
```toml
baseURL = "http://example.org/"
languageCode = "en-us"
title = "site title"
theme = "cupcake"

# Highlight options.
# @See https://gohugo.io/content-management/syntax-highlighting/
PygmentsCodeFences = true # Enable syntax highlighting with GitHub flavoured code fences
PygmentsUseClasses = true # Use CSS classes to format highlighted code
PygmentsCodefencesGuessSyntax = true
PygmentsOptions = "linenos=table"

[params]
  # The date format to use; for a list of valid formats
  # @see https://gohugo.io/functions/format/
  dateFormatToUse = "2006年1月2号"

  # site motto
  motto = "example motto"

[params.social]
    a-email =<EMAIL_ADDRESS>    g-github = "https://github.com/yourname"
```


text:
---
title: "About Me"
layout: single
header:
  overlay_image: /assets/images/hello.jpg
  overlay_filter: 0.5
  caption: "Photo credit: [**Unsplash**](https://unsplash.com)"
author_profile: true
---

Hello! I’m Vivek, a [Computer Science + Linguistics](http://cs-ling.linguistics.illinois.edu/) major at the [University of Illinois, Urbana-Champaign](http://illinois.edu/). I’m passionate about using technology to impact society.

Currently, I work as a Data Engineering Intern at [Capital One](https://www.capitalone.com/). My other activities include Member of Corporate Staff, [ACM@UIUC](https://acm.illinois.edu/) and Executive Course Assistant, [CS196@Illinois.](http://cs196.xyz/) You can find my resume [here](https://vivekvaidya.me/Resume.pdf).

In my free time, I enjoy contributing to open source projects on [Github](https://github.com/vivekvaidya) and (occasionally) messing around on [Twitter](https://twitter.com/thevivekvaidya?lang=en). I also like traveling, photography, and eating food.

While most of my social media links are on the left, the best way to get in touch with me is vivekvaidya [at] outlook [dot] com. Thanks for stopping by!

repository: vivekvaidya/old-website

repo_name: vivekvaidya/old-website


text:
devnotes

## Gather Meraki meta information

REST
- merakiDevices (access points)
    `/organizations/:organizationId/devices`
- wifiClients
    `/networks/:networkId/clients`
- bleClients
    `/networks/:networkId/wireless/bluetoothClients`
- floorPlans
    `/networks/:networkId/floorPlans`

## Subscribe to MR MQTT stream for real-time telemetry

MQTT
- beacons (WiFi & BLE)
    - via MQTT stream

## Merge and store enriched data

Computed Resources
- discoverdClients (unique clients from beacons)
   - recordsByAp (array of beacons by access point)
   - stats
        - totalWifiClients
        - totalBleClients
        - bleBeaconTypes
        - beaconsPerSecond

- discoveredAPs (unique APs from beacons)
    - stats
        - mqttMessagesPerSecond
        - clientCount

## Visualization

- Statistics
- Clients table
- Clients map (toggle selected client or all)
    - floor plan
- RSSI Radar
- Access Points table
- Access Points map

## Settings

- API Key
- MQTT Broker
- MQTT Topic

- History/frequency/performance

BLE

Tile:
UUID: 9d41000035d6f4ddba60e7bd8dc491c0
major: 9015
minor: 19919

## Multi API Demo Concept

Dashboard API
- meta info

Scanning API
- initial location / telemetry

MQTT
- real-time "Live Tool"

# App Flow

## Server
- Meraki API / MQTT handling
- Scanning API receiver + /lastScan

## Client
- Initialize
    - pull in orgs, nets, devices, clients, bleClients
    - pull in lastScan

- Tables and Stats
    - refresh with Scanning API data

- "Live Tools"
    - MQTT subscribe to topic, based on netId/clientId
    - Display real-time widgets
    - Track client on map


text:
---
layout: post
title: "Week 6   Machine Learning"
permalink: week-6---machine-learning
date: 2019-06-17 09:21:38
comments: true
description: "Week 6 - Machine Learning"
keywords: ""
categories:

tags:

---
###  Advice on machine learning

If your machine learning algorithm is not working well, you can try following things.

* Get more training examples.
* Try smaller set of features.
* Additional features.
* Adding polynomial features.
* Decreasing or increasing λ - the regularization parameter.

##### Machine learning diagnostic.

A test you can run to gain insight what is/isn't working with a learning algorithm, and gain guidance as to how best to improve its performance.

##### Evaluating hypothesis.
* Overfitting
  * Use part of training examples as test set.
  * Typically random 30% of training examples are used as test set.
  * If hypothesis overfits - then error in training set will be low, but high in test set.
* Degree of polynomial
  * Linear, quadratic, cubic.. etc.
  * Keep 20% of training examples for cross validation set.
  * 60% training set, 20% cross validation set, 20% test set.

##### High bias or variance problem.
* Bias problem - training set and cross validation set errors both will be high.
* Variance problem - training set error is low, but cross validation errors are high.

![Bias or variance problem](/images/bias-variance-problem.png)

##### Learning Curve.
* Plot average squared error for training set size.
* Plot both average squared error for cross validation set (JCV) and training set Jtrain.
* As the training set gets larger, the error for a quadratic function increases.
* The error value will plateau out after a certain m, or training set size.
* High bias - JCV and Jtrain both will be high, will converge for sufficiently large value of training set size. More data will not help.
* High variance - Jtrain << JCV, will not converge. More data will likely help.

##### Neural networks.
* Smaller networks prone to under fitting.
* Larger networks prone to over fitting, but can be solved using regularization.
* Number of hidden layers is similar to degree of polynomial and same techniques can be used to optimize that.

##### Machine Learning System Design
* How to spend your time to reduce error of your algorithm?
  * Collect lots of data.
  * Develop sophisticated features.
* Error analysis
  * Start with a simple algorithm.
  * Plot learning curves to decide whether you need more features or data.
  * Eye ball data where algorithm is going wrong.
* Use a single numerical evaluation metric for your algorithm - error rate or something like that.
  * This evaluation will helps with deciding whether your changes are useful or not.

##### Skewed classes in classification algorithm.
* Data may be skewed to contain far more number of examples for certain class.
* For example - far more samples (99%) of patients who dont have cancer, compared to small sample of patient who do.
* _Throwing out data to reducing skew is incorrect, as skew is representative of real world._
* Using error metric will not be very useful to determine performance of such algorithm.
* In classification, you can change threshold from 0.5 to higher or lower values to force your algorithm to predict positive class only when very confident.
* __Precision__(P) - true positives / (true positives + false positives)
  * What percent of predicted positive results were correct.
  * Good algorithm will have closer to 1.
* __Recall__(R) - true positives / (true positives + false negative)
  * What percent of positive results were predicted correctly
  * Good algorithm will have closer to 1.
* Trade off between Precision and Recall is a hard and depends on context.
* Trying out different algorithms and comparing P and R for them is a good to determine which algorithm is better.
* F score - 2 * (P * R)/(P + R) - Higher the value the better.
  * This score is used to compare performance of various algorithm.

##### Data for machine learning
* Very large data set makes even an "inferior algorithm" work better, almost at par with better algorithms.
* Although having large data set is not sufficient.
* Is the data useful and contains necessary information to write a good enough algorithm?
* __Can a human expert predict output confidently based on example and set of features?__
* For example - you can't predict housing price based on data which contains only size of the house as information, irrespective of how many examples you have.

repository: sushrutb/website

gha_language: SCSS

repo_name: sushrutb/website


text:
---
layout: default
---

# 1996-05-21 - Re: An alternative to remailer shutdowns

## Header Data

From: "Rev. Mark Grant, ULC"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: d24b0d5259cc79a2ee05e65e023c6161269cfbd5a23da1e959c98f075c6227a4

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-05-21 20:29:48 UTC

Raw Date: Wed, 22 May 1996 04:29:48 +0800

## Raw message

```
{% raw  %}From: "Rev. Mark Grant, ULC"<EMAIL_ADDRESS>Date: Wed, 22 May 1996 04:29:48 +0800
To<EMAIL_ADDRESS>Subject: Re: An alternative to remailer shutdowns
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Mon, 20 May 1996, Rich Graves wrote:

> On Tue, 21 May 1996, Declan B. McCullagh wrote:
> I like the "knock-knock" approach, though it would of necessity impose
> load. If someone has an anonymous message waiting, send them a simple note
> with instructions on how to retrieve it.

I have a partial implementation of this for Mixmaster if anyone wants to
try integrating it into the main code. It works (or worked) for single
packet messages but I never finished the multi-packet code. Of course, if
Mixmaster is being rewritten anyway then it won't be much use.

AFAIR it also relies on the 'In-Reply-To:' field in the header working
correctly.

	Mark

{% endraw %}
```

## Thread

+ Return to [May 1996](/archive/1996/05)

+ Return to "["Rev. Mark Grant, ULC" <mark@unicorn.com>](/authors/rev_mark_grant_ulc_mark_at_unicorn_com_)"

+ 1996-05-21 (Wed, 22 May 1996 04:29:48 +0800) - Re: An alternative to remailer shutdowns - _"Rev. Mark Grant, ULC"<EMAIL_ADDRESS>


text:
Kodi Configuration for Intel NUC
================================

This repository has some of the configuration necessary for getting an Intel
NUC D34010WYK up and running from vanilla Ubuntu.

The main interesting bit for this repository is the script to get the IR sensor
working correctly with Kodi. You can find that in the `system` directory in two
parts: 1) the script to get the IR service working, and 2) a `systemd` service
to run the script on startup.

Installing
==========

I start with [Xubuntu Core][xubuntu-core], so download the [`mini.iso`][mini-iso]
for the version of Ubuntu that you want to start with, then:

1. (For me only) Set the HTTP proxy on setup to be http://apt-cacher.underworld:3142
   so that [Apt-Cacher NG][apt-cacher] will serve as a proxy for all `apt`-related
   tasks.
2. Choose the *Xubuntu minimal installation task* during install, or
3. Pick the smallest number of dependencies and then, after the installer has
   finished, run:

        sudo apt install -y xubuntu-core^

I created a `Makefile` that I can use to install Kodi and the customized
scripts and settings for my environment.

Run:

    sudo apt install -y git
    git clone https://github.com/fbristow/kodi-nuc
    cd kodi-nuc
    sudo make install

[xubuntu-core]: http://xubuntu.org/news/introducing-xubuntu-core/ "Xubuntu Core"
[mini-iso]: https://help.ubuntu.com/community/Installation/MinimalCD "Ubuntu Minimal CD"
[apt-cacher]: https://www.unix-ag.uni-kl.de/~bloch/acng/ "Apt-Cacher NG, a caching proxy server for Apt."

license: Unlicense

repository: fbristow/kodi-nuc

repo_name: fbristow/kodi-nuc


text:
Version 4.1
===========
* Compability for Twig 3 (thanks @benr77)

Version 4.0
===========
* Remove symfony 3 compability
* Set min php version to 7.2 as requirment for coming code styling
* Pass tree root via constructor (thanks @elonmir)
* Update phpunit to v8

repository: gzumba/FeatureFlagsBundle

repo_name: gzumba/FeatureFlagsBundle


text:
# Hastlayer - Communication Tester

Command line application for testing the communication layer.

## About

This application sends test data to any device that has a matching `ICommunicationService` registered. It does not program
the hardware or alter the input so automatic verification is only useful if the device is already behaving as loopback.
You can upload generated content (see `--payload-type` switch) or any binary files. Both generated input and the output
can be saved to file or displayed on the console.

## Usage

1. Check for available devices: `Hast.Communication.Tester.exe --list`
2. Consult with the help screen to learn about input options: `Hast.Communication.Tester.exe --help`
3. Send test entry, for example: `Hast.Communication.Tester.exe --device Catapult --bytes 1024 --member-id 0 -i CONSOLE -o CONSOLE -n`

The above call sends 1kB payload to Catapult over its default communication service (`CatapultCommmunicationService`)
without testing the output for loopback type equivalency. Both the input and the output are displayed on the console in
a hexdump style.

If you need to iterate the output you can do so by using

`Hast.Communication.Tester.exe --device Catapult --bytes 1024 --member-id 0 -i CONSOLE -o CONSOLE -n`

## Switches

- `-l`, `--list`
List available devices and exit.
- `-d`, `--device`
Name of the selected device.
- `-b`, `--bytes`
The total size of the payload in bytes.
- `-k`, `--kilo-bytes`
The total size of the payload in kilobytes.
- `-c`, `--cells`
The total size of the payload in number of cells.
- `-m`, `--member-id`
The simulated MemberId.
- `-t`, `--payload-type`
What kind of data to send (`ConstantIntOne`, `Counter`, `Random`, `BinaryFile`).
- `-f`, `--file-type`
Type of the files where input and output are dumped to (`None`, `Hexdump`, `Binary`).
- `-i`, `--input`
Generated data is saved to or payload is read from this file when using BinaryFile as file-type.
- `-o`, `--output`
Output file name. (overrides `-f` to `Hexdump` if it's `None`; use value 'CONSOLE' to write hexdump to the console)
- `-j`, `--json`
Create a summary as JSON file.
- `-n`, `--no-check`
Skips result check at the end.
- `--help`
Display this help screen.
- `--version`
Display version information.

## Payload Types

The first 3 options consider each 4 byte cell in the `SimpleMemory` as an `Int32`.

- `ConstantIntOne`: Sets each cell's value to 1.
- `Counter`: The value counts up from 0 by 1, so it is the same as the cell index.
- `Random`: Each cell is set to a random `int`. Uniqueness is not guaranteed.
- `BinaryFile`: Loads the input from an external file byte-by-byte.

If it's set to BinaryFile then the input is read from `--input` instead of written to.

Random is non-repeatable so if that becomes an issue you can first export a generated input using the
`-t Random -f Binary -i random.bin` options and then use `-t BinaryFile -i random.bin` in consecutive runs.

## File Types

This switch controls both the input and the output file types.

- `None`: They aren't saved. If either input or output file paths are set then it's changed to `Hexdump`.
- `Hexdump`: The data is formatted as hexadecimal in a similar style as seen in a hexdump.
- `Binary`: The data is saved/loaded raw as a binary file.

If instead of saving you want to display on the command line you can type the value CONSOLE in all capitals as
`-i CONSOLE` or `-o CONSOLE`.

Some additional diagnostics can be saved using the `--json filename.json`. This includes the `Success` property
which shows if the call finished successfully. If the value is true, it contains the `IHardwareExecutionInformation`
as the `Result` property. If false, it contains the serialized exception in the `Exception` property.

repository: Lombiq/Hastlayer-SDK

branch_name: refs/heads/dev

gha_language: VHDL

repo_name: Lombiq/Hastlayer-SDK


text:
**This is an explanation of how to use NANOME pipeline phasing and 5hmC call. For general usage, please check [Usage](https://github.com/LabShengLi/nanome/blob/master/docs/Usage.md).**

## Phasing reads for methylaiton
NANOME support phasing long-reads into haplotypes using [Clair3](https://github.com/HKU-BAL/Clair3) (variant calling) and [Whatshap](https://whatshap.readthedocs.io/en/latest/) (long-read phasing). The option for running phasing step is `--phasing`.

Below is an example:
```angular2html
nextflow run LabShengLi/nanome\
    -profile singularity,winter \
    --dsname NA19240_PhasingDemo \
    --input https://storage.googleapis.com/jax-nanopore-01-project-data/nanome-input/NA19240_phasing_test_data_chr11_chr15_n49.tar.gz\
    --genome hg38 --phasing --hmc --ctg_name 'chr11,chr15'
```

Phasing outputs is below, methylation outputs for Megalodon and NANOME will be split into H1 and H2 haplotypes:
```angular2html
[dd/10cf26] process > EnvCheck (NA19240_PhasingDemo)      [100%] 1 of 1 ✔
[5c/6522a7] process > Untar (NA19240.tar)     [100%] 1 of 1 ✔
[f1/e53635] process > Basecall (NA19240.tar)  [100%] 1 of 1 ✔
[60/73dd05] process > QCExport (NA19240_PhasingDemo)      [100%] 1 of 1 ✔
[41/e623cd] process > Megalodon (NA19240.tar) [100%] 1 of 1 ✔
[c9/65ae15] process > MgldnComb (NA19240_PhasingDemo)     [100%] 1 of 1 ✔
[18/91c19b] process > Report (NA19240_PhasingDemo)        [100%] 1 of 1 ✔
[06/93d747] process > Clair3 (NA19240_PhasingDemo)        [100%] 1 of 1 ✔
[ff/8f16be] process > Phasing (NA19240_PhasingDemo)       [100%] 1 of 1 ✔
Completed at: 26-Apr-2022 22:28:00
Duration    : 2m 38s
CPU hours   : 0.5 (68.3% cached)
Succeeded   : 3
Cached      : 6

ls results/NA19240_PhasingDemo-phasing/
```

## Call 5hmC by Megalodon
NANOME support 5hmC call by Megalodon using param `--hmc`.

repository: LabShengLi/nanome

gha_language: Python

repo_name: LabShengLi/nanome


text:
# MemeMe

MemeMe is an app for iOS, and one of the projects composing Udacity's iOS nanodegree. It allows the user to create image memes and share them.

The core requirements for this app:
- From the landing page, the user can tap Add ("+") to go to the meme editor.
- In the meme editor, the user can select a photo from the camera or gallery and caption it with top and bottom text.
- The user may share the meme using Apple's standard activity selector, which gives them several ways to share.
- Shared memes are saved in memory and appear on the landing page.
- Using a tab bar at the bottom of the landing page, the user may select to view the shared memes in a list or grid.
- Tapping a shared meme on the landing page takes the user to a detail view where they can get a closer look at the meme.
- The UI must adapt to the various iOS device screen sizes and to device orientation changes.

This version of the app fulfils those requirements and adds some features:
- The classic image meme font, Impact, is bundled with the app and used in the meme editor.
- Swipe-to-delete: when viewing shared memes as a list, the user can swipe a row to the left to reveal a Delete button, allowing them to delete the meme.
- Edit existing memes: After tapping a shared meme on the landing page and opening the meme detail view, the user can tap "Edit" (top right of screen) to open the meme in the meme editor view. They can edit the top and bottom text and share it again. After sharing, the meme editor will close to reveal the changed meme in the meme detail view.

repository: jasonwedepohl/udacity-ios-meme-me

repo_name: jasonwedepohl/udacity-ios-meme-me


text:
---
title: Accessibility guide
---

Current a11y status

*Please note, this guide is a work in progress and will be updated regularly. We welcome your comments and feedback.*

The goal of software accessibility is to remove barriers and create inclusive product experiences that work for everyone, regardless of physical ability.

Since accessibility is best achieved when considered early in the design and development process, we ask everyone who contributes to or consumes PatternFly to understand accessibility needs and how they can be met. The following guide provides techniques and suggestions to help you design, develop, and test UIs to ensure that everyone has a good user experience.

## Understanding users’ needs

Great user experiences don’t just happen; they’re designed, tested, and refined with the user in mind. To develop inclusive products, it’s important to understand the varying needs of a wide range of users and consider the assistive tools and methods they use. This section provides information to help you better understand and address the needs of these [different user groups](https://a11yproject.com/posts/myth-accessibility-is-blind-people/).

Note: It’s possible for a user to fall into more than one group, or to use tools and devices designed for a different user group. One of the greatest benefits of an inclusive design practice is that methods designed for a specific user group will often provide benefits to everyone.

### No vision

Users with no vision rely on screen readers to access web sites and applications. Often, screen reader users will navigate a page by browsing specific elements, like headers, links, or form elements. Use semantic elements and check that labels are meaningful when pulled out of context.

### Low vision

Users with low vision can have different needs depending on the nature of their visual impairment. Users may have difficulty with color differentiation, blurriness, or lack of vision in central or peripheral areas. These needs mean that interfaces should not rely on color to communicate information, palettes need to have sufficient contrast, and layouts should be responsive when font sizes are increased.

### Motor

Users with poor motor control can use a range of devices to access contents. Users who rely on a keyboard need elements that are keyboard accessible and highly visible when in focus. Users who rely on a mouse or touch need target areas that are large enough to be hit easily.

### Cognitive

Users who have difficulty processing information benefit from well-written content. Information should clear, concise, and easy to scan. Consider visual hierarchy, chunk content into short, related sections, and avoid long paragraphs.

## Designing and developing for accessibility

Our goal is to meet [level AA in the Web Content Accessibility Guidelines 2.1](https://www.w3.org/WAI/WCAG21/quickref/?currentsidebar=%23col_customize&levels=aaa). To help you get started, the following sections break some of these down by area of focus.

## Checklists

### What PatternFly should address

If you use PatternFly, or contribute to PatternFly as a designer or developer, these are the items that are expected to be covered in PatternFly:

| Guideline  | Link  |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Semantic html structures are used to accurately communicate purpose and relationship of UI elements | [WCAG 1.3.1](https://www.w3.org/WAI/WCAG21/quickref/#info-and-relationships) | `design` | `html` | `css` |  |
| Color is not the only method of communication. Providing meaning through color is supplementary to providing meaning with text | [WCAG 1.4.1](https://www.w3.org/WAI/WCAG21/quickref/#use-of-color) | `design` | `html` | `css` |  |
| Colors used provide sufficient contrast | [WCAG 1.4.3](https://www.w3.org/WAI/WCAG21/quickref/#contrast-minimum) and [1.4.11](https://www.w3.org/WAI/WCAG21/quickref/#non-text-contrast) |  |  | `css` |  |
| Font sizes can scale up to 200% without loss of content or functionality, and up to 400% without needing to scroll in more than one direction.  | [WCAG 1.4.4](https://www.w3.org/WAI/WCAG21/quickref/#resize-text) and [1.4.10](https://www.w3.org/WAI/WCAG21/quickref/#reflow) |  |  | `css` |  |
| Styles that affect text spacing (line height, space between paragraphs, letter spacing, and word spacing) can be increased without loss of content or functionality | [WCAG 1.4.12](https://www.w3.org/WAI/WCAG21/quickref/#text-spacing) |  |  | `css` |  |
| Contents that appear on hover and focus are dismissable, hoverable, and persistent | [WCAG 1.4.13](https://www.w3.org/WAI/WCAG21/quickref/#content-on-hover-or-focus) |  | `html` | `css` | `js` |
| All functionality is keyboard accessible | [WCAG 2.1.1](https://www.w3.org/WAI/WCAG21/quickref/#keyboard) and [2.1.2](https://www.w3.org/WAI/WCAG21/quickref/#no-keyboard-trap) |  | `html` |  |  |
| Order of elements in the HTML and in the layout follow a logical order | [WCAG 1.3.2](https://www.w3.org/WAI/WCAG21/quickref/#meaningful-sequence) and [2.4.3](https://www.w3.org/WAI/WCAG21/quickref/#focus-order) | `design` | `html` | `css` |  |
| Elements with focus are clearly visible | [WCAG 2.4.7](https://www.w3.org/WAI/WCAG21/quickref/#focus-visible) |  |  | `css` |  |
| Flashing content | [WCAG 2.3.1](https://www.w3.org/WAI/WCAG21/quickref/?showtechniques=231#three-flashes-or-below-threshold) |  |  | `css` |  |
| Functionality that uses complex gestures can also be operated with a single pointer without a path based gesture | [WCAG 2.5.1](https://www.w3.org/WAI/WCAG21/quickref/#pointer-gestures) | `design` |  |  |  |
| Pointer events can be cancelled  | [WCAG 2.5.2](https://www.w3.org/WAI/WCAG21/quickref/#pointer-cancellation) | | | | `js` |
| Visible labels of UI components are either the same as the accessible name or used in the beginning of the accessible name | [WCAG 2.5.3](https://www.w3.org/WAI/WCAG21/quickref/#label-in-name) |  | `html` |  |  |
| The target area for clickable elements is at least 44 by 44 [CSS pixels](https://www.w3.org/TR/WCAG21/#dfn-css-pixels) | [WCAG 2.5.5 (AAA)](https://www.w3.org/WAI/WCAG21/quickref/#target-size)* |  |  | `css` |  |
| An accessible name is provided for all elements | [WCAG 4.1.2](https://www.w3.org/WAI/WCAG21/quickref/#name-role-value) | `design` | `html` |  |  |
| Status messages can be programmatically determined through role or properties | [WCAG 4.1.3](https://www.w3.org/WAI/WCAG21/quickref/#status-messages) |  | `html` |  |  |

*WCAG 2.5.5 is included for reference only. This guideline suggests a size that is larger than what PatternFly requires.

### What products should address

If you consume PatternFly in your product, these are the items that are outside the scope of PatternFly, and should be addressed by the product developers and designers:

| Guideline  | Link  |  |  |
| --- | --- | --- | --- |
| Skip to main links | [WCAG 2.4.1](https://www.w3.org/WAI/WCAG21/quickref/#bypass-blocks) |  | `development` |
| Page titles | [WCAG 2.4.2](https://www.w3.org/WAI/WCAG21/quickref/#page-titled) |  | `development` |
| Links — If more than one link has the same label, it should also have the same url. Screen reader users can access the list of links that are on a page, which pulls the links out of context. If you have links with different URLs but the same label, then add additional text to provide context to the screen reader user. | [WCAG 2.4.4](https://www.w3.org/WAI/WCAG21/quickref/#link-purpose-in-context) | `design`  | `development` |
| Landmarks — Use landmark roles to clearly identify regions that communicate page structure. If more than one landmark role occurs in the page, use aria-label to differentiate the landmark elements | [ARIA11](https://www.w3.org/TR/WCAG20-TECHS/ARIA11.html) | `design`  | `development` |
| Headings — Heading text should be descriptive. Correct heading levels should be used to communicate the outline of the page. | [WCAG 2.4.10](https://www.w3.org/WAI/WCAG21/quickref/#section-headings) and [H42](https://www.w3.org/TR/WCAG20-TECHS/H42.html) | `design`  | `development` |
| Contents — Should be meaningful, clear, and concise |  | `design` |  |

## Guidelines and references

- [Web Content Accessibility Guidelines 2.1](https://www.w3.org/TR/WCAG21/)
- [WebAIM's WCAG 2.0 Checklist](https://webaim.org/standards/wcag/checklist)
- [A11Y Project Checklist](https://a11yproject.com/checklist)

### PatternFly guidelines
These are guidelines that we have defined for PatternFly.

#### Experience parity
  - There should be parity between the screen reader contents and visibly rendered contents (refer to the [first note for aria-hidden](https://www.w3.org/TR/wai-aria/#aria-hidden)).
  - There should be parity among all input types: touch, mouse, and keyboard.
      - Don’t optimize the experience for one input type at the expense of another.
      - Contents that a user can interact with using a mouse are also accessible using touch or keyboard.
      - Don’t show interactive elements on hover. Interactive elements that can display in a popup must display on click/touch/Enter events.
  - There should be parity between hover and focus events.
      - Any information that’s available on hover for the mouse user should be available on focus for the keyboard-only user, and also available to the screen reader user using `aria-describedby` (refer to [Tooltips & Toggletips example from Inclusive Components](https://inclusive-components.design/tooltips-toggletips/)).

## Techniques

The [WCAG 2.0 techniques](https://www.w3.org/TR/WCAG20-TECHS/Overview.html#contents) provide examples on how to meet accessibility guidelines. Any techniques that are adopted as standard within PatternFly for handling specific patterns are included below.

### Labels and accessible names

- #### Form fields
  - Use explicit linking between `label` and form input elements (e.g. `input`, `textarea`, or `select`) when both elements are present. Aside from providing an accessible name to screen readers, this method also increases the clickable area of the form element by making the label clickable, too. ([H44](https://www.w3.org/TR/WCAG20-TECHS/H44.html))
  - When a `label` element cannot accompany a form input element:
      - Provide the label using `aria-label` or `aria-labelledby`. ([ARIA14](https://www.w3.org/TR/WCAG20-TECHS/ARIA16.html))
      - In a single-field form, the submit button label can serve as the field label for sighted users ([G167](https://www.w3.org/TR/WCAG20-TECHS/general.html#G167)) as well as assistive devices when using `aria-labelledby`
- #### Landmark roles
  - Screen reader users can navigate to sections of a page when [landmark roles](https://www.w3.org/TR/wai-aria-1.1/#landmark_roles) are used. Whenever a landmark role is used more than once, provide a name using `aria-label` or `aria-labelledby` to provide context for that landmark. ([ARIA6](https://www.w3.org/TR/WCAG20-TECHS/ARIA6.html), [ARIA16](https://www.w3.org/TR/WCAG20-TECHS/ARIA16.html))
  - While [`toolbar`](https://www.w3.org/TR/wai-aria-1.1/#toolbar) is not a landmark role, the same rule applies to this role.
- #### Icons
  Icons can either be decorative or semantic. Icons are **decorative** if you can remove an icon without affecting the information that is presented on the page. Icons are **semantic** when they provide information that otherwise isn't present, such as indicating status, indicating type of alert message, or replacing text as button labels. When an icon is semantic, the meaning must be provided in alternative ways to the user. The following guidelines should be followed when using icons within PatternFly components.
  - Add `aria-hidden="true"` for all icons, either to the icon element or a parent element of the icon. This renders the icon as something that assistive devices can ignore.
  - Additionally, for **semantic** icons:
      - Add a label for the icon in tooltip text that displays on hover, and also on focus for focusable elements.
      - For interactive elements like `<a>` and `<button>` where an icon is used as the label instead of text, provide the label on the interactive element using `aria-label`. For example:
      ```html
      <button class="..." aria-label="Close dialog">
        <i class="..." aria-hidden="true"></i>
      </button>
      ```
      - For non-interactive icons, include `.pf-screen-reader` text near the icon. Depending on the component, the `.pf-screen-reader` text might not be a direct sibling to the icon element. For example, in the alert component, the icon label text is adjacent to the message. This way, when `role="alert"` is added to `.pf-c-alert__body` for dynamically displayed alerts, the type of message is announced along with the message text.
      ```html
      <div class="pf-c-alert pf-m-success" aria-label="Success alert">
        <div aria-hidden="true" class="pf-c-alert__icon">
          <i class="fas fa-check-circle"></i>
        </div>
        <div class="pf-c-alert__body">
          <h4 class="pf-c-alert__title">
            {{#> screen-reader}}Success:{{/screen-reader}} Success alert title
          </h4>
        </div>
      </div>
      ```

### Trapping focus
The recommended interaction pattern for the modal components like the modal or popover is to trap focus within the modal element of the component when it becomes visible. For keyboard-only users that use the tab key to navigate the interface, this means that focus cannot be shifted outside of the modal when using the tab key. Instead, when focus leaves the last focusable item, it should be placed on the first focusable item of the modal. For screen reader users, the other contents on the page should be hidden from the screen reader.

The method we recommend based on the screen reader / browser combinations we use for testing is to apply `aria-hidden="true"` to the parent wrapping element of the page contents. Note that the modal element of the component must not be a descendent of this element with `aria-hidden="true"` and should be included as a sibling to this element.

## Testing
Many accessibility issues can be found by doing a few simple checks:

1. Use an accessibility audit tool to check for violations. If you are using PatternFly in your project, we recommend using [aXe: The Accessibility Engine](https://www.deque.com/axe/) to check for accessibility violations. If you are contributing to PatternFly, refer to our [README.md](https://github.com/patternfly/patternfly/blob/master/README.md#testing-for-accessibility) on how to run this tool.
2. Test keyboard accessibility, and check that these requirements are met:
    - All functionality is keyboard accessible
    - Order of elements in the HTML and in the layout follow a logical order
    - Elements with focus are clearly visible
3. Disable styles, then test the information architecture and presence of adequate text labels. The [WAVE browser extension from WebAIM](https://wave.webaim.org/extension/) provides this feature if it isn't available in the browser you are using.
4. Test with any screen reader available in your operating system. Screen readers that we target for testing PatternFly are:
    - JAWS with Chrome, Windows ([keyboard shortcuts](https://dequeuniversity.com/screenreaders/jaws-keyboard-shortcuts))
    - Voiceover with Safari, Mac ([keyboard shortcuts](https://dequeuniversity.com/screenreaders/voiceover-keyboard-shortcuts))
    - NVDA with Firefox, Windows ([keyboard shortcuts](https://dequeuniversity.com/screenreaders/nvda-keyboard-shortcuts))
5. Check color contrast for:
    - Text color against background color ([Understanding WCAG 1.4.3](https://www.w3.org/WAI/WCAG21/Understanding/contrast-minimum.html))
    - Text color against link color ([Technique G183](https://www.w3.org/TR/WCAG20-TECHS/G183.html))
    - Visible boundaries of buttons and form elements against adjacent background color ([Understanding WCAG 1.4.11](https://www.w3.org/WAI/WCAG21/Understanding/non-text-contrast.html))


text:
# my2Collector
My2Collector (my2) is a simple, self contained MySQL statistics collector

## MySQL Statistics Collector
Most intresting MySQL performance data is available in the GLOBAL_STATUS system table,
but MySQL does not mantain any history of it.
My2Collector (my2) is a simple, self contained MySQL statistics collector.
my2 creates the `my2.status` table that contains the history of performance statistics.
Every 10 minutes my2 automatically executes a Stored Routine to collect data.

## Install my2

To install *my2Collector* execute the following command on Your MySQL database:

	mysql --user=root -pXXX < my2.sql

For security reasons the creation of the user my2 is commented out: change the password and create the user!

my2 user creation is in the last 3 lines of the script.

#### Database structure

`my2.status` table has columns similar to the MySQL GLOBAL_STATUS system table:
* variable_name
* variable_value

my2.status adds a third column `timest` with the timestamp

#### Available statistics

`my2.status` table collects several performance statistics:
* All numeric GLOBAL_STATUS variables
* All statement execution counters ("statement/sql/%" from events_statements_summary_global_by_event_name)
* Some PROCESSLIST information (eg. USER, HOST, COMMAND, STATE)
* Some summary statistic (eg. sum_timer_wait from events_statements_summary_global_by_event_name)
* Some GLOBAL_VARIABLE variables
* Delta values for most used counters using `my2.current` stage table
* Database size (collected daily and not every 10 minutes)
* And other useful stats...

### Statistics usage

	SELECT variable_value+0 as value, timest as time_sec
	  FROM my2.status
	 WHERE variable_name='THREADS_CONNECTED'
	 ORDER BY timest ASC;

## Version support

my2 can connect to any version of MySQL, MariaDB, Percona, or other forks but...
with old MySQL releases many statistics not available.
my2 uses a Scheduled Job which is available since MySQL 5.1 (2008).
PROCESSLIST table is available since 5.1.7 while GLOBAL_STATUS is available since 5.1.12.
The PERFORMANCE_SCHEMA was introduced in 5.5 version and greatly enhanched in 5.6 version.
There are many little differences between different MySQL versions: My2 is aware of them
and tries to collect all the information available. For MySQL 8.0 a different script is provided.
my2 gives its best with MySQL 5.7, MySQL 8.0 and MariaDB 10.x with performance schema enabled.

repository: dannellim/StudyMama

gha_language: Java

repo_name: dannellim/StudyMama


text:
## DPLA Rights Statements

1. Download and unzip DPLA records [https://dp.la/info/developers/download](https://dp.la/info/developers/download)
2.

repository: lfarrell/dpla-rights

repo_name: lfarrell/dpla-rights


text:
# serverless rust [![Build Status](https://travis-ci.org/softprops/serverless-rust.svg?branch=master)](https://travis-ci.org/softprops/serverless-rust) [![npm](https://img.shields.io/npm/v/serverless-rust.svg)](https://www.npmjs.com/package/serverless-rust)

> A ⚡ [Serverless framework](https://serverless.com/framework/) ⚡ plugin for [Rustlang](https://www.rust-lang.org/en-US/) applications 🦀

## 📦 Install

Install the plugin with npm

```sh
$ npm i -D serverless-rust
```

💡 This serverless plugin assumes you are building Rustlang lambdas targetting the AWS Lambda "provided" runtime. The [AWS Lambda Rust Runtime](https://github.com/awslabs/aws-lambda-rust-runtime) makes this easy.

Add the following to your serverless project's `serverless.yml` file

```yaml
service: demo
provider:
  name: aws
  runtime: rust
plugins:
  # this adds informs servleress to use
  # the serverless-rust plugin
  - serverless-rust
# creates one artifact for each function
package:
  individually: true
functions:
  test:
    # handler value syntax is `{cargo-package-name}.{bin-name}`
    # or `{cargo-package-name}` for short when you are building a
    # default bin for a given package.
    handler: your-cargo-package-name
    events:
      - http:
          path: /test
          method: GET
```

## 🖍 customize

You can optionally adjust the default settings of the dockerized build env using
a custom section of your serverless.yaml configuration

```yaml
custom:
  # this section allows for customization of the default
  # serverless-rust plugin settings
  rust:
    # flags passed to cargo
    cargoFlags: '--features enable-awesome'
    # custom docker tag
    dockerTag: 'some-custom-tag'
```

### 🎨 Per function customization

If your serverless project contains multiple functions, you may sometimes
need to customize the options above at the function level. You can do this
by defining a `rust` key with the same options inline in your function
specficiation.

```yaml
functions:
  test:
    rust:
      # function specific flags passed to cargo
      cargoFlags: '--features enable-awesome'
    # handler value syntax is `{cargo-package-name}.{bin-name}`
    # or `{cargo-package-name}` for short when you are building a
    # default bin for a given package.
    handler: your-cargo-package-name
    events:
      - http:
          path: /test
          method: GET
```

## 🏗 serverless templates

### 0.2.*

* a minimal echo application - https://github.com/softprops/serverless-aws-rust
* a minimal http application - https://github.com/softprops/serverless-aws-rust-http
* a minimal example multi-function application - https://github.com/softprops/serverless-aws-rust-multi

### 0.1.*

Older versions targeted the python 3.6 AWS Lambda runtime and [rust crowbar](https://github.com/ilianaw/rust-crowbar) and [lando](https://github.com/softprops/lando) applications

* lando api gateway application - https://github.com/softprops/serverless-lando
* multi function lando api gateway application - https://github.com/softprops/serverless-multi-lando
* crowbar cloudwatch scheduled lambda application - https://github.com/softprops/serverless-crowbar

Doug Tangren (softprops) 2018

repository: danbruder/serverless-rust

repo_name: danbruder/serverless-rust


text:
## IntraVideo Search
## Specifications for Milestone 4.a

### (1) Plan for Implementation 2
- For the GUI and Input/Output, and local data processing:
    We are focusing on making sure that the frontend connects to the backend. We will also be updating the GUI to have a cleaner and easier-to-use interface. Previously, we intended to include a way for the clips to be displayed in a helpful way and to implement an option for the user to download the individual clips from the GUI. We will not be doing this anymore because after Iteration 1, we decided that it is not reasonable to display a potentially large number of clips on screen, so the implementation for Iteration 2 will simply save clips without giving the user any other option.
- For API interaction and Post-API Data Processing:
    We are planning to implement a semantic similarity (matching search terms with related words) to improve/bolster the relevancy of outputted clips.
- New Features:
    We will also be implementing two new features. First, we will implement a new feature that returns a sentence caption that describes what is occurring in each clip. Second, we will implement an option for the user to input a URL link to a YouTube video instead of uploading a video file.

### (2) Who Will Do What
- **David:** Sentence caption feature tests and implementation
- **Krish:** Semantic similarity feature tests and implementation
- **Rachel:** Youtube option feature tests and implementation
- **Mahmoud:** GUI run_the_job() to connect frontend to backend (validate settings and start job from GUI); GUI framework and logic
- **Jeremy:** GUI framework and logic
- **Ralph:** update GUI
- **Michael:** update GUI
- **AK:** update GUI

### (3) Unit Test Cases
Note: Running the test cases is the same as for previous milestones. We have provided the same instructions below for convenience.
- To install the necessary packages, run
    ```
    pip install -r requirements.txt
    ```
    Note:
      - Python 3.7 is required
      - For a system with multiple python versions, run
      ```
      python3.7 -m pip install -r requirements.txt
      ```
- To run all tests, run
    ```
    pytest -vv
    ```
    - `-vv` ensure verbose output
    - if there is a module import error, run `python -m pytest -vv`
- Note: to run a single test file, just append the test file path like so
    ```
    pytest test/test_controller.py -vv
    ```
    and to run a single function, add the `-k` flag and the function name:
    ```
    pytest test/test_controller.py -k "test_classify_img" -vv
    ```
    This might be necessary since functions like `classify_img` take a while because loading a ML model for the first time is expensive.


text:
[![Build Status](https://travis-ci.org/KMITFOSS/openmrs-webgl-globe.svg?branch=master)](https://travis-ci.org/KMITFOSS/openmrs-webgl-globe)

The **OpenMRS WebGL Globe** is a fork from chromeexperiments to visualize openrms implementers data provided at openmrs atlas.

Check out the examples at http://www.chromeexperiments.com/globe, and if you create a globe, please [share it with us](http://www.chromeexperiments.com/submit). We post our favorite globes publicly.

![](http://4.bp.blogspot.com/-nB6XnTgb4AA/TcLQ4gRBtfI/AAAAAAAAH-U/vb2GuhPN6aM/globe.png)

----

**The WebGL Globe** supports data in `JSON` format, a sample of which you can find [here](https://github.com/dataarts/webgl-globe/blob/master/globe/population909500.json). `webgl-globe` makes heavy use of the [Three.js library](https://github.com/mrdoob/three.js/).

# Data Format

The following illustrates the `JSON` data format that the globe expects:

```javascript
var data = [
    [
    'seriesA', [ latitude, longitude, magnitude, latitude, longitude, magnitude, ... ]
    ],
    [
    'seriesB', [ latitude, longitude, magnitude, latitude, longitude, magnitude, ... ]
    ]
];
```

# Basic Usage

The following code polls a `JSON` file (formatted like the one above) for geo-data and adds it to an animated, interactive WebGL globe.

```javascript
// Where to put the globe?
var container = document.getElementById( 'container' );

// Make the globe
var globe = new DAT.Globe( container );

// We're going to ask a file for the JSON data.
var xhr = new XMLHttpRequest();

// Where do we get the data?
xhr.open( 'GET', 'myjson.json', true );

// What do we do when we have it?
xhr.onreadystatechange = function() {

    // If we've received the data
    if ( xhr.readyState === 4 && xhr.status === 200 ) {

        // Parse the JSON
        var data = JSON.parse( xhr.responseText );

        // Tell the globe about your JSON data
        for ( var i = 0; i < data.length; i ++ ) {
            globe.addData( data[i][1], {format: 'magnitude', name: data[i][0]} );
        }

        // Create the geometry
        globe.createPoints();

        // Begin animation
        globe.animate();

    }

};

// Begin request
xhr.send( null );
```

# Starting a local development server

```
npm install
npm start
```

Navigate to http://localhost:3000 to see the demo.

Tested with Node 5.7 and npm 3.6.

# Deploy to Heroku

1. Create a Procfile
```
touch procfile
nano procfile
```
2. Add this line to the procfile-
```
web: node index.js
```

3. Follow the steps on the website to download heroku-cli
https://devcenter.heroku.com/articles/getting-started-with-nodejs#set-up after that
```
heroku login
```

4. In the terminal go to your repo or clone it & cd into it
```
git clone https://github.com/Foo/Bar.git
cd Bar
```

5. Create a heroku app, a random name gets generated & its git remote is added

```
heroku create

git push heroku master
```

6. To view your app
```
heroku open
```

**Wanna know some more regarding openmrs?**

**OpenMRS**
- OpenMRS is a collaborative open source project to develop software to support the delivery of health care in developing countries
- [OpenMRS](http://openmrs.org)

**OpenMRS Atlas**
- The OpenMRS Atlas is a website on which members of the OpenMRS Community can register their site(s).  The Atlas serves not only to let the world know about your site, but also help sites to discover other implementations in their region.
- [OpenMRS Atlas](http://atlas.openmrs.org)

repository: KMITFOSS/openmrs-webgl-globe

repo_name: KMITFOSS/openmrs-webgl-globe


text:
# TCP Listener

One of the addons you can use in combination with Kerberos is a TCP Listener. The TCP listener can execute a specific action when it received a TCP packet from Kerberos (TCP Client).

## Examples

### Text-To-Speech

You can use node to build a simple TCP server, this is a lot easier than if we would have to do it in C; but ofcourse that's also possible. A cool feature would be to use the **say.js** library. You can use say.js on OSX/Linux to execute speech to text. So you could send a message from the Kerberos instance to the node TCP server, and on receiving the message you could make your TCP server speak.

For example you can configure the Kerberos TCP client with a message "There's someone at the frontdoor". When Kerberos detects something it will execute the TCP client and send a TCP packet - which includes the message - to the predefined IP address of the TCP server, afterwards the TCP server will use the say.js library to actually say the message.

<iframe src="//player.vimeo.com/video/122785370?autoplay=0&color=943633" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="width:100%; height: 400px;"></iframe>

You could place another Raspberry Pi in your living room, which would run a TCP server with node and with some speakers attached; see the configuration below. But you can also use your local working station, like I've did in the video above.

    cd /home && mkdir tcp-client && cd tcp-client

Install the festival library and voice package

	pacman -S festival festival-english
	pacman -S alsa-utils

Update the festival.scm file, add following lines at the end of the file */usr/share/festival/festival.scm*.

	(Parameter.set 'Audio_Method 'Audio_Command)
	(Parameter.set 'Audio_Command "aplay -q -c 1 -t raw -f s16 -r $SR $FILE")

Don't forget to install say and time first.

	npm install say date-utils

Create a new node file

    nano kerberos-listener.js

and copy-paste the code below

    // Import libraries
    var net = require('net');
    var say = require('say');
    require('date-utils');

    // Variables
    var listenerPort = 1337;
    var time1 = new Date();

    net.createServer(function (socket)
    {
        // Handle incoming messages from the magnet controller.
        socket.once('data', function (data)
        {
            var time2 = new Date();
            var timeBetween = time1.getSecondsBetween(time2);
            if(timeBetween > 30)
            {
                say.speak('Victoria', data);
            }

            time1 = time2;
        });

    }).listen(listenerPort);

    // Put a friendly message on the terminal of the server.
    console.log("Kerberos.io listener running at port 1337\n");

### Auto-start tcp listener

Create a new service file.

    nano /etc/systemd/system/kerberos-listener.service

Copy and paste following configuration in the service file.

    [Unit]
    Description=Kerberos listen for tcp packets
    [Service]
    Type=oneshot
    ExecStart=/usr/bin/node /home/tcp-client/kerberos-listener.js &
    [Install]
    WantedBy=multi-user.target

Activate the service file.

    systemctl enable kerberos-listener.service

### Pushbullet notifications

You can expand the Text-To-Speech feature (described above), with pushbullet notifications. Pushbullet is a free notifcation service, which you can use to send messages to your devices; smartphone, tablet, and/or workingstation. You can download the pushbullet node library with **npm**, and use it in the TCP listener.

    npm install pushbullet

When the library is installed correctly, you can use following code in the TCP listener.

    var PushBullet = require('pushbullet');

    var pusher = new PushBullet('your key');

     pusher.devices(function(error, response)
     {
         var devices = response.devices;
         devices.forEach(function(device)
         {
             pusher.note(device.device_iden, "Kerberos.io: " + data.toString(), data.toString());
         });
     });


text:
OpenMP 4.x SIMD Benchmarks
==========================

This repository contains a set of benchmark kernels to be called from within a SIMD context (e.g. a loop or another SIMD kernel).
The general idea is to assess compiler (SIMD) vectorization capabilities using simple reproducer kernels that were extracted from real-world scientific codes.
The kernels `k` implement
- wrapped math function calls (sqrt, log, exp): `k=simple`,
- conditional math function calls: `k=conditional_math`,
- early return from functions: `k=early_return`,
- nested branching with conditional math function calls: `k=nested_branching`,
- while loop on SIMD lanes with varying trip count not known at compile time: `k=while_loop`.

The different implementations `i` of the kernels include a(n)
- sequential reference version: `i=reference`,
- OpenMP 4.x version using the `omp declare simd` feature: `i=explicit_vectorization`,
- OpenMP 4.x version using `omp simd` loops to process user-defined vector data types: `i=enhanced_explicit_vectorization`,
- SIMD intrinsics version: `i=manual_vectorization`,
- C++ SIMD class version (using the Vc library): `i=simd_class_vectorization`.

Structure
---------
This repository has the following structure:
```
   build.<cxx=gnu,clang,intel>
   makefile.<cxx=gnu,clang,intel>[.<xphi=knc,knl>]
   readme.md
   LICENSE                // BSD-2 license file.

src/
   makefile_global
   makefile_local

src/common
   benchmark.cpp          // contains the main() function.
   simd_data_types.cpp

include/common
   kernel.hpp
   simd_data_types.hpp

include/<k>               // one sub-directory for each kernel k.
   kernel_<i>.cpp         // contains the implementations i.

data/Euro-Par-2016-conference
   hsw*                   // benchmark data cites in the Euro-Par paper for Haswell,
   knc*                   // Xeon Phi Knights Corner (KNC),
   knl*                   // Xeon Phi Knights Landing (KNL).
   notes.txt              // some information about the benchmarking setups.
```

Build
=====

Use the `build.<cxx>[.<xphi>]` scripts to generate the executables `bin.<cxx>[.<xphi>]/.<k>_<i>.x` for the different platforms and compilers.

The build scripts take as optional command line arguments
- `FUNC=<SQRT_SQRT,SQRT_LOG,SQRT_EXP,LOG_LOG,LOG_EXP,EXP_EXP>` the math function(s) to be used throughout the kernel execution,
- `SIMDWIDTH=<2,4,8,...>` the "logical" SIMD width to be used by OpenMP 4.x SIMD. The default is "logical=native" SIMD width (e.g. 4 on an AVX(2) system with 64 bit words). In case of `i=<reference,manual_vectorization,simd_class_vectorization>` the `SIMDWIDTH` paramter has no effect---these implementations always use "logical=native".

Example: build all kerneles with the Intel compiler for Xeon Phi KNL using log as math call and SIMD width 8
```
$> build.intel.knl FUNC=LOG_LOG SIMDWIDTH=8
```

Vc library
----------
If the Vc library is available and should be used, set up the environment variables `VC_AVAILABLE=<yes,[no=default]>` and `VC_ROOT=<Vc install directory>` in `build.*` appropriately.

Non-system glibc library
------------------------
In case of a non-system glibc should be used (e.g. to make use of `libmvec`, which comes with glibc-2.22 and later), set up the environment variable `GLIBC_ROOT=<glibc install directory>` in `build.*` appropriately.

Execute
=======

The executables `bin.<cxx>[.<xphi>]/<k>_<i>.x` take as optional command line arguments
- `-n <some integer value>` the number of array entries to be processed by the SIMD loop,
- `-l <some double value>` a lower bound for the random numbers to be assigned to the arrays,
- `-u <some double value>` an upper bound for the random numbers to be assigned to the arrays.

Default values are `n=8192`, `l=-1.0`, `u=+1.0`.

The executables are senstive to the `OMP_NUM_THREADS` environment variable.
You maybe need to explicitly manage the thread placement, e.g., via `KMP_AFFINITY` for Intel.

Output
------
All executables output
- the number of OpenMP threads used for the execution (weak scaling experiment),
- the mean/min/max loop execution times in seconds and the statistical error for 6 benchmark iterations,
- the first 8 entries of the result array (per thread),
- the maximum absolute relative error when comparing the output arrays generated by the sequential and the SIMD execution of the loop (per thread).

An example run (and output) with 12 OpenMP threads could look like this:
```
$> export OMP_NUM_THREADS=12
$> export KMP_AFFINITY=scatter
$> bin.intel.knl/conditional_math_call_explicit_vectorization.x -n 8192 -l -1.0 -u 1.0
# number of OMP threads : 12
# timings per loop iteration:
# mean	      err	min		max
9.72674e-09   5.65089e-11		8.41101e-09	1.07393e-08
# output (thread 0): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# output (thread 3): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# max. abs. rel. error (thread 8): 2.31621e-13
# max. abs. rel. error (thread 9): 2.31621e-13
# max. abs. rel. error (thread 10): 2.31621e-13
# max. abs. rel. error (thread 11): 2.31621e-13
# output (thread 2): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# output (thread 1): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# max. abs. rel. error (thread 0): 2.31621e-13
# output (thread 4): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# output (thread 5): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# max. abs. rel. error (thread 3): 2.31621e-13
# output (thread 6): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# output (thread 7): 6.37885 10 9 10 8.18427 10 8.38018 8.2433
# max. abs. rel. error (thread 2): 2.31621e-13
# max. abs. rel. error (thread 1): 2.31621e-13
# max. abs. rel. error (thread 4): 2.31621e-13
# max. abs. rel. error (thread 5): 2.31621e-13
# max. abs. rel. error (thread 6): 2.31621e-13
# max. abs. rel. error (thread 7): 2.31621e-13
```

Tested setups
-------------
- GNU 5.3.0 + glibc-2.22 on Intel Haswell platform
- GNU 6.1.0 + glibc-2.23 on Intel Haswell platform
- Intel 16.0.[1,2,3] on Intel Haswell, KNC, KNL platform
- Clang 3.8, 3.9(pre) on Intel Haswell platform

References
==========
*Portable SIMD Performance with OpenMP 4.x Compiler Directives*, Florian Wende, Matthias Noack, Thomas Steinke, Michael Klemm, Chris J. Newburn, and Georg Zitzlsberger, Euro-Par 2016, Grenoble, France, 2016


text:
![](http://i.imgur.com/TquxyUj.png)

## Where

<http:lucasviola.github.io/easyshell>

## Why?

GNU/Linux, at first sight, seems like a really scary platform for most
day to day users and even for some IT professionals. This is a
collection of boilerplate shell commands presented in a nice and
organized way aimed to help people lose their fear and start using
this awesome Operational System!

## Who

My name is [Lucas Viola](http://github.com/lucasviola). I'm software enthusiast who is passionate about new technologies,
functional languages, solving problems, DevOps culture and
obviously...Linux!

## Building
```
$ sudo gem install github-pages
$ git clone git@github.com:lucasviola/easyshell.git
$ cd easyshell/
$ jekyll serve -w
```

Check [here](http://fontawesome.io/icons/) to get more information about icons.
## License

[The MIT License (MIT)](http://opensource.org/licenses/MIT)

repository: lucasviola/easyshell

gha_language: CSS

repo_name: lucasviola/easyshell


text:
## Tools and Tutorials for developing Open API spec based API's

### Tools
* [Swagger Tools on github](https://github.com/swagger-api/swagger.io/blob/wordpress//tools/index.md)
* [Swagger 2.0 implementation for go](https://github.com/go-swagger/go-swagger)

### Tutorials
* [Open API Specification (fka Swagger Specification) tutorial](https://gist.github.com/arno-di-loreto/5a3df2250721fb154060)
* [Writing OpenAPI (Swagger) Specification Tutorial](https://apihandyman.io/writing-openapi-swagger-specification-tutorial-part-1-introduction/)
* [Swagger Core Jersey 2.X Project Setup 1.5](https://github.com/swagger-api/swagger-core/wiki/Swagger-Core-Jersey-2.X-Project-Setup-1.5)
* [Creating a Simple Movie Store API with Swagger](https://www.codementor.io/ayushgupta/creating-a-simple-movie-store-api-with-swagger-tmecy3y8t)
* [ Converting your Swagger 2.0 API Definition to OpenAPI 3.0](https://blog.runscope.com/posts/tutorial-upgrading-swagger-2-api-definition-to-openapi-3)

* [Swagger API documentation tutorial for beginners - 4 - Open API specification summary](https://www.youtube.com/watch?v=GE3QT05hWs4)
* [API Design with Swaggerhub -   how to use the IDE. I define API,generate code for the API etc..](https://www.youtube.com/watch?v=G3FQc5hcV2U)

### Other Related Links
* [The OAI Announces the OpenAPI Specification 3.0.0](https://www.openapis.org/blog/2017/07/26/the-oai-announces-the-openapi-specification-3-0-0)
* [The OpenAPI Spec, Based on Swagger, Reaches 3.0](https://www.infoq.com/news/2017/01/openapi-3)

repository: iggym/openapispecnotes

repo_name: iggym/openapispecnotes


text:
# Merge Sort
* [Repo](https://github.com/alex-white-401-advanced-javascript/data-structures-and-algorithms/tree/master/code-challenges/sorts/merge-sort)
* [PR](https://github.com/alex-white-401-advanced-javascript/data-structures-and-algorithms/pull/13)
* [Lecture README](https://github.com/alex-white-401-advanced-javascript/data-structures-and-algorithms/blob/master/code-challenges/sorts/merge-sort/LECTURE-NOTES.md)

## Challenge
* Write a function for merge sort that takes in an unsorted array and returns the array sorted using merge sort.
* Present a complete set of working tests

## Approach & Efficiency
* Utilized the Single-responsibility principle
* Code is efficient, clean, and testable

### Author: Alexander White
* [Resources](https://hackernoon.com/programming-with-js-merge-sort-deb677b777c0)


text:
# OSMN: One-Shot Modulation Network for Semi-supervised Video Segmentation

This repo is the released code of one-shot modulation network described in the CVPR 2018 paper:
```
@article{ Yang2018osmn,
  author = {Linjie Yang and Yanran Wang and Xuehan Xiong and Jianchao Yang and Aggelos K. Katsaggelos},
title = {Efficient Video Object Segmentation via Network Modulation},
  journal = {CVPR},
  year = {2018}
}
```
In this work, we propose to use a meta neural network named modulator to manipulate the intermediate layers of the segmentation network given the appearance of the object in the first frame. Our method only takes 140ms/frame for inference on DAVIS dataset.

<img src='doc/ims/model_structure.png'>

## Installation
1. Clone the repository
   ```Shell
   git clone https://github.com/linjieyangsc/video_seg.git
   ```
2. Install if necessary the required dependencies:

   - Python 2.7
   - Tensorflow r1.0 or higher (`pip install tensorflow-gpu`) along with standard [dependencies](https://www.tensorflow.org/install/install_linux)
   - Densecrf by [Philipp Krähenbühl and Vladlen Koltun](https://github.com/lucasb-eyer/pydensecrf)
   - Other python dependencies: PIL (Pillow version), numpy, scipy

## Training on DAVIS

### Stage 1: Training the network on MS-COCO
1. Download MS-COCO 2017 dataset from [here](http://cocodataset.org/#download).
2. Download the VGG 16 model trained on Imagenet from the TF model zoo from [here](http://download.tensorflow.org/models/vgg_16_2016_08_28.tar.gz).
3. Place the vgg_16.ckpt file inside `models/`.
4. Run `python osmn_coco_pretrain.py --data_path DATA_PATH --model_save_path MODEL_SAVE_PATH --gpu_id GPU_ID --training_iters 200000` to train the model with a default learning rate 1e-5. After it finishes, run `python osmn_coco_pretrain.py --data_path DATA_PATH --model_save_path MODEL_SAVE_PATH --gpu_id GPU_ID --training_iters 300000 --learning_rate 1e-6` to further train it with a decreased learning rate. Be sure to keep `MODEL_SAVE_PATH` the same as in the first step to restore from existing checkpoint.
For reference to other arguments, please check them by running `python osmn_coco_pretrain.py -h`.

### Stage 2: Fine-tuning the network on DAVIS
1. Download DAVIS 2017 dataset from [here](http://davischallenge.org/code.html).
2. Preprocess the dataset by running `python preprocessing/preprocess_davis.py DATA_DIR`.
3. To finetune and evaluate the model on DAVIS 2017 as stated in the paper, run `python osmn_train_eval.py --data_path DATA_PATH --whole_model_path WHOLE_MODEL_PATH --result_path RESULT_PATH --model_save_path MODEL_SAVE_PATH_FT --gpu_id GPU_ID --batch_size 4 --fix_bn --randomize_guide --training_iters 50000 --learning_rate 1e-6`. Here `WHOLE_MODEL_PATH` should be the path to the model saved by Stage 1 training. Other arguments can be seen by running `python osmn_train_eval.py -h`. After it finishes, the prediction result on DAVIS 2017 will be saved into `RESULT_PATH`.

### One-shot finetuning on DAVIS
1. The trained model can be further improved by online one-shot finetuning on specific video sequences. Run the following command to finetune the model on either DAVIS 2016 or 2017.
```
python osmn_online_finetune.py --whole_model_path WHOLE_MODEL_PATH --result_path RESULT_PATH --model_save_path MODEL_SAVE_PATH_OL --gpu_id GPU_ID --batch_size 1 --training_iters 100 --data_version [2016/2017]
```

## Evaluation
1. To evaluate either Stage 1 or 2 model on DAVIS. Please run the following command.
```
python osmn_train_eval.py --data_path DATA_PATH --whole_model_path WHOLE_MODEL_PATH --result_path RESULT_PATH --only_testing --data_version [2016/2017] --gpu_id GPU_ID [--save_score] [--use_full_res]
```
`--save_score` need to be set while testing on DAVIS 2017, which is required to combined score maps of different objects for final prediction. `--use_full_res` is to use full resolution images for inference, which can be beneficial when visual guide is small.
Then run the following command to get the mIU score.
```
python davis_eval.py DATA_PATH RESULT_PATH DATASET_VERSION DATASET_SPLIT
```
2. To evaluate the model on [Youtube Objects](http://vision.cs.utexas.edu/projects/videoseg/). First download the dataset, then preprocess the dataset by running `python preprocessing/preprocess_youtube.py DATA_DIR`. Then evaluate the model.
```
python osmn_eval_youtube.py --data_path DATA_PATH --whole_model_path WHOLE_MODEL_PATH --result_path RESULT_PATH --gpu_id GPU_ID
```
Then use the following command to get the mIU score.
```
python youtube_eval.py DATA_PATH RESULT_PATH
```
3. We release official model for both Stage 1 and 2, which can be downloaded from [here](https://www.dropbox.com/sh/6i5mgicuzmhart2/AACMO_C5guWcRHUD8K3ZHCV9a?dl=0). The Stage 1 model obtains mIU 72.2 on DAVIS 2016 and 52.5 on DAVIS 2017. The Stage 2 model obtains mIU 74.0 on DAVIS 2016.

## Training on YoutubeVOS
YoutubeVOS (https://youtube-vos.org/) is currently the largest video object segmentation dataset. To train and evaluate the model on YoutubeVOS, run `python osmn_train_eval_ytvos.py --data_path DATA_PATH --result_path RESULT_PATH --model_save_path MODEL_SAVE_PATH --gpu_id GPU_ID --batch_size BATCH_SIZE --randomize_guide --training_iters 200000`. After it finishes, further train the model with a decreased learning rate `1e-6` for 100k iterations.
To evaluate the model, run the following command to generate results for each object.
```
python osmn_train_eval_ytvos.py --data_path DATA_PATH --whole_model_path WHOLE_MODEL_PATH --result_path RESULT_PATH --only_testing --gpu_id GPU_ID --save_score
```
Then use the script `ytvos_merge_result.py` to merge objects in the same video:
```
python ytvos_merge_result.py DATA_PATH PRED_PATH OUTPUT_PATH DATA_SPLIT
```
Finally upload the results to Codalab website of the ECCV challenge.

## Contact ##
If you have any questions regarding the repo, please send email to Linjie Yang (yljatthu@gmail.com).


text:
airframe-http
====

airframe-http is a library for creating HTTP web servers at ease.
**airframe-http-finagle** is an extention of airframe-http to use Finagle as a backend HTTP server.

- [Documentation](https://wvlet.org/airframe/docs/airframe-http)
- Blog article: [Airframe HTTP: Building Low-Friction Web Services Over Finagle](https://medium.com/@taroleo/airframe-http-a-minimalist-approach-for-building-web-services-in-scala-743ba41af7f)

**build.sbt**

[![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.wvlet.airframe/airframe-http-finagle_2.12/badge.svg)](http://central.maven.org/maven2/org/wvlet/airframe/airframe-http-finagle_2.12/)
[![Scaladoc](http://javadoc-badge.appspot.com/org.wvlet.airframe/airframe-http_2.12.svg?label=scaladoc)](http://javadoc-badge.appspot.com/org.wvlet.airframe/airframe-http_2.12)
```scala
libraryDependencies += "org.wvlet.airframe" %% "airframe-http-finagle" % (version)
```

repository: wvlet/airframe

gha_language: Scala

repo_name: wvlet/airframe