text:
## Project: Search and Sample Return

---

**The goals / steps of this project are the following:**

**Training / Calibration**

* Download the simulator and take data in "Training Mode"
* Test out the functions in the Jupyter Notebook provided
* Add functions to detect obstacles and samples of interest (golden rocks)
* Fill in the `process_image()` function with the appropriate image processing steps (perspective transform, color threshold etc.) to get from raw images to a map.  The `output_image` you create in this step should demonstrate that your mapping pipeline works.
* Use `moviepy` to process the images in your saved dataset with the `process_image()` function.  Include the video you produce as part of your submission.

**Autonomous Navigation / Mapping**

* Fill in the `perception_step()` function within the `perception.py` script with the appropriate image processing functions to create a map and update `Rover()` data (similar to what you did with `process_image()` in the notebook).
* Fill in the `decision_step()` function within the `decision.py` script with conditional statements that take into consideration the outputs of the `perception_step()` in deciding how to issue throttle, brake and steering commands.
* Iterate on your perception and decision function until your rover does a reasonable (need to define metric) job of navigating and mapping.

[//]: # (Image References)

[image1]: ./misc/rover_image.jpg
[image2]: ./calibration_images/example_grid1.jpg
[image3]: ./calibration_images/example_rock1.jpg
[image4]: ./output/example_grid_warped.jpg
[image5]: ./output/example_rock_warped.jpg
[image6]: ./output/example_grid_mask.jpg
[image7]: ./output/example_grid_ground.jpg
[image8]: ./output/example_grid_obstacles.jpg
[image9]: ./output/example_grid_samples.jpg
[image10]: ./output/example_rock_ground.jpg
[image11]: ./output/example_rock_obstacles.jpg
[image12]: ./output/example_rock_samples.jpg
[image13]: ./output/roversim_0124_1.png
[image14]: ./output/roversim_0124_2_5min.png
[image15]: ./output/roversim_0124_2_10min.png

## [Rubric](https://review.udacity.com/#!/rubrics/916/view) Points
### Here I will consider the rubric points individually and describe how I addressed each point in my implementation.

---
### Writeup / README

#### 1. Provide a Writeup / README that includes all the rubric points and how you addressed each one.  You can submit your writeup as markdown or pdf.

You're reading it!

### Notebook Analysis
#### 1. Run the functions provided in the notebook on test images (first with the test data provided, next on data you have recorded). Add/modify functions to allow for color selection of obstacles and rock samples.

Example grid and example rock images:

![alt text][image2]

![alt text][image3]

Warped perspective of the two example images:

![alt text][image4]

![alt text][image5]

I used the field of view masking technique provided in the project overview video rather than simply negating the navigable terrain. The masked field of view looks identical regardless of source image.

![alt text][image6]

To identify the navigable terrain versus obstacles versus rocks, I updated the color_thresh function provided during the classwork to take a range of RGB values rather than a single low threshold. For the ground terrain, the RGB range is from (160,160,160) to (255,255,255). The identification of an obstacle is those areas within the FOV mask that are identified as not navigable. For the samples, there is a low amount of blue present in pixels for the samples. For the rock samples, the RGB range is from (110,110,0) to (200,200,60). Here are the navigable terrain, obstacles, and rock for the example_grid file provided:

![alt text][image7]

![alt text][image8]

![alt text][image9]

There is no rock in the example_grid image so the all-black presentation is as expected. Now here are the images produced for navigable, obstacles, and rock for example_rock image:

![alt text][image10]

![alt text][image11]

![alt text][image12]

Here you see the small blip of white indicating pixels that passed the rock samples filter in the bottom center of the image.

#### 1. Populate the `process_image()` function with the appropriate analysis steps to map pixels identifying navigable terrain, obstacles and rock samples into a worldmap.  Run `process_image()` on your test data using the `moviepy` functions provided to create video output of your result.

### Autonomous Navigation and Mapping

#### 1. Fill in the `perception_step()` (at the bottom of the `perception.py` script) and `decision_step()` (in `decision.py`) functions in the autonomous mapping scripts and an explanation is provided in the writeup of how and why these functions were modified as they were.

The perception_step implemented looks substantially similar to the process_image function. I used the same source/destination for perspective transform as was used in the lab. The Rover.vision_image was updated as in the overview video. To improve the fidelity of the map, the updates to the world_map are only done when both the roll and the pitch are less than 1deg absolute value.

I made a few significant changes to the decision_step() processing. First, I noted there was a propensity for the rover to get stuck in a condition where the obstacle is out of view of the camera. Here, I deal with that by noting that some number of samples have been seen (I chose 100) with a clear path ahead but the velocity is still less than 0.2. In such a situation, I stop the robot and force the four wheel turning for 20 samples. Relatedly, I noted that the rover would sometimes falsely consider the forward progress possible when already stopped. In this case, I find that although there are plenty of navigable pixels in my field of view, all of those angles are outside of the -15 to +15 steering range of the rover. In this case, I want to continue behaving as if I need to do four wheel turning. With these changes in place the rover no longer gets stuck in place.

I modified the rover to support picking up of samples. When a sample is present in the field of view and the path forward is available, I steer the rover towards the center of the sample. In order to attempt to avoid rolling past the samples, once the rover has gotten close to the samples I apply the brakes. This logic is not foolproof. Mainly, the rover often has the sample exit the field of view and the rover has no memory that it was in the field of view and thus continues onward.

Finally, I noted that even with the changes to prevent the rover from getting stuck in place, I noticed that my area mapping was often too low. The situation is that the rover is in a fairly wide open space. In such a situation, the rover's navigation logic of choosing the mean navigable angle results in circular motion. The idea I had to deal with that was to try to get the rover to follow alongside a wall. In order to do this, I decided to follow the angle corresponding to the third quartile of the navigable angles. I did this by taking the mean of all of the navigable angles that are greater than the mean angle. With this logic change, left to run the mapping exceeds 98%.

#### 2. Launching in autonomous mode your rover can navigate and map autonomously.  Explain your results and how you might improve them in your writeup.

**Note: running the simulator with different choices of resolution and graphics quality may produce different results, particularly on different machines!  Make a note of your simulator settings (resolution and graphics quality set on launch) and frames per second (FPS output to terminal by `drive_rover.py`) in your writeup when you submit the project so your reviewer can reproduce your results.**

I executed my tests using the "Good" graphics quality and 1024x768 resolution and 14FPS. My platform is Ubuntu 17.10 on a Dell XPS13 with the Core I7 processor. The first run is illustrated in the figure below. Here after 15 minutes of runtime, the rover has achieved 77% mapping at 67% fidelity and has located and collected 4 samples.

![alt text][image13]

The next test shows screen captures at the 5 minute and 10 minute intervals to illustrate how the rover progresses:

![alt text][image14]

![alt text][image15]

There are several areas for improvement here. The terrain exploration is rather slow. In some start locations where the terrain is wide open, the rover can find itself in a wide circle. I have tried to mitigate this issue somewhat by introducing some randomness into the steering. When searching an unexplored canyon and encountering a rock, the rover may end up turning around after having retrieved the rock rather than continuing to explore the canyon. This is due to the rover not really having a concept of exploring unknown territory. In some cases, the rover approaches the rock but fails to retrieve it because the logic results in the rover either unable to achieve sufficient velocity to pick up the rock, for example when the rock is on the side of the wall, or the rover drives over the rock because it was unable to stop in time. Finally, I did not attempt to add in the necessary logic for the rover to return to the start to deliver the supplies.

repository: kscharpf/RoboND-Rover-Project

repo_name: kscharpf/RoboND-Rover-Project


text:
# svelte-loader

[![Build Status](https://travis-ci.org/sveltejs/svelte-loader.svg?branch=master)](https://travis-ci.org/sveltejs/svelte-loader)

A [webpack](https://webpack.js.org) loader for [svelte](https://svelte.technology).

## Usage

Configure inside your `webpack.config.js`:

```javascript
  ...
  module: {
    rules: [
      ...
      {
        test: /\.(html|svelte)$/,
        exclude: /node_modules/,
        use: 'svelte-loader'
      }
      ...
    ]
  }
  ...
```

Check out the [example project](https://github.com/sveltejs/template-webpack).

### Extracting CSS

If your Svelte components contain `<style>` tags, by default the compiler will add JavaScript that injects those styles into the page when the component is rendered. That's not ideal, because it adds weight to your JavaScript, prevents styles from being fetched in parallel with your code, and can even cause CSP violations.

A better option is to extract the CSS into a separate file. Using the `emitCss` option as shown below would cause a virtual CSS file to be emitted for each Svelte component. The resulting file is then imported by the component, thus following the standard Webpack compilation flow. Add [ExtractTextPlugin](https://github.com/webpack-contrib/extract-text-webpack-plugin) to the mix to output the css to a separate file.

```javascript
  ...
  module: {
    rules: [
      ...
      {
        test: /\.(html|svelte)$/,
        exclude: /node_modules/,
        use: {
          loader: 'svelte-loader',
          options: {
            emitCss: true,
          },
        },
      },
      {
        test: /\.css$/,
        use: ExtractTextPlugin.extract({
          fallback: 'style-loader',
          use: 'css-loader',
        }),
      },
      ...
    ]
  },
  ...
  plugins: [
    new ExtractTextPlugin('styles.css'),
    ...
  ]
  ...
```

Alternatively, if you're handling styles in some other way and just want to prevent the CSS being added to your JavaScript bundle, use `css: false`.

### Source maps

JavaScript source maps are enabled by default, you just have to use an appropriate [webpack devtool](https://webpack.js.org/configuration/devtool/).

To enable CSS source maps, you'll need to use `emitCss` and pass the `sourceMap` option to the `css-loader`. The above config should look like this:

```javascript
module.exports = {
    ...
    devtool: "source-map", // any "source-map"-like devtool is possible
    ...
    module: {
      rules: [
        ...
        {
          test: /\.(html|svelte)$/,
          exclude: /node_modules/,
          use: {
            loader: 'svelte-loader',
            options: {
              emitCss: true,
            },
          },
        },
        {
          test: /\.css$/,
          use: ExtractTextPlugin.extract({
            fallback: 'style-loader',
            use: [{ loader: 'css-loader', options: { sourceMap: true } }],
          }),
        },
        ...
      ]
    },
    ...
    plugins: [
      new ExtractTextPlugin('styles.css'),
      ...
    ]
    ...
};
```

This should create an additional `styles.css.map` file.

## License

MIT

license: MIT

repository: bryanwood/svelte-loader

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: bryanwood/svelte-loader


text:
# BetterX-Android
BetterX-Android is a data collection app used in the [BetterX.org](http://www.betterx.org) research project.  BetterX-Android works on the background and collects device, network and sensor data.

## Functionality
It consists of 5 parts: the sensor logger, the network logger, the firefox extension web logger (see [BetterX-Firefox](https://github.com/eliasall/BetterX-Firefox)), the features logger (device data) and the main body application which provides the setup and GUI to the user.  All parts produce json formatted data files which are relayed back into AWS s3 on a daily basis.

### Setup Parameters
AWS_S3_ACCESSKEYID _access key for s3_
AWS_S3_SECRETKEYACCESS _secret key for s3_
AWS_S3_USERNAME _username for s3_
AWS_S3_BUCKET _folder for s3_
PUB_KEY _public key for encrypting zip file before sending it over_
GCM_PROJECT_NUMBER _Google Cloud Messaging API Key_

### Sensor Logger
The purpose of the sensor logger is to monitor and record sensor data including location data.  The [SensorManager](https://github.com/emotionsense/SensorManager) library provides most of the functionality for sensor reading and the [SensorDataManager](https://github.com/emotionsense/SensorDataManager) provides most of functionality to send the data. The sensor logger uses the adaptive sampling mechanism in order to reduce the volume of the recorded data.

* Environment Sensors
  * AMBIENT_TEMPERATURE
  * LIGHT
* Pull Sensors
  * ACCELEROMETER
  * GYROSCOPE
  * LOCATION (Latitude, Longitude, Accuracy, Speed, Bearing, Provider, Time)
  * MAGNETIC_FIELD
  * WIFI (SSID, BSSID, Capabilities, Level, Frequency)
* Push Sensors
  * BATTERY
  * CONNECTION_STATE
  * CONNECTION_STRENGTH
  * LOCATION
  *	SCREEN
  *	Phone State
  * Step Counter

### Network Logger
The purpose of the netlogger is to monitor and record all the device network status changes.  The Network Logger uses this [Network Events Library](https://github.com/pwittchen/NetworkEvents).

* WifiStatus
*	MobileStatus
*	WiMaxStatus
*	HasInternet
* DetailedState
* ExtraInfo
* Capabilities
* LinkProperties
*	BSSID
*	SSID
*	Frequency
*	SignalStrength
*	IP
*	LinkSpeed
*	MAC
*	NetID
*	RSSI
*	Available Networks

### Features Logger
* UID (IMEI+MEID+SIMSERIAL+ANDROID_ID)
* Device Manufacturer
* Device Model Number
* Android Version
* Screen Size
* Running Apps

### Main App Screens
![a](screens-demo/main1.png)
![b](screens-demo/main2.png)

### Info Screens
![1](screens-info/s1.png)
![2](screens-info/s2.png)
![3](screens-info/s3.png)
![4](screens-info/s4.png)
![5](screens-info/s5.png)
![6](screens-info/s6.png)
![7](screens-info/s7.png)
![8](screens-info/s8.png)
![9](screens-info/s9.png)
![10](screens-info/s10.png)
![11](screens-info/s11.png)

### Setup Screens
![13](screens-demo/demo1.png)
![14](screens-demo/demo2.png)
![15](screens-demo/demo3.png)
![16](screens-demo/demo4.png)
![17](screens-demo/demo5.png)

### Referencing
Usage of any parts of this software or data requires referencing in any published or publicised work. The correct referencing is presented below in Harvard, MLA8 and APA styles.

Harvard

`Allayiotis, E. (2017) BetterX System. N.A: BetterX.org.`

MLA8

`Allayiotis, Elias. “BetterX System.” 23 Feb. 2017, www.betterx.org.`

APA

`Allayiotis, E. (2017). BetterX System (Version 1.2). [Application software]. Retrieved from <http://www.betterx.org/>`

### License
Anyone interested in this project can download/modify/contribute to the source code that is made available.   The BetterX project is licenced under the Apache License, Version 2.0

_Copyright 2017 Elias Allayiotis_

_Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0_

_Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License._

repository: eliasall/BetterX-Android

repo_name: eliasall/BetterX-Android


text:
# Abacc Cultural Club Portal

Online management portal of an organization with admin panel. Feel free to use or modify this project.

Postgres is used for data persistance and Spring Security & JWT are used for handling authentication.

In addition, botstrap is used for template design

# Docker Build
To build docker image, install docker in your system

then open terminal in your project directory and run the following command

```
mvn clean install -DskipTests=true
```
It will create the "abaccAdelaide.jar" file in target directory then run the following command to create docker image

```
docker compose up
```
Now you have 2 docker containers up and running in your system.

branch_name: refs/heads/main


text:
## Pages
* **Homepage**
* **About**
* **Service**
* **Portfolio**
* **Portfolio Dingle**
* **Pricing**
* **Blog Grid**
* **Blog Full Width**
* **Blog Left Sidebar**
* **Blog Right Sidebar**
* **Blog Single**
* **Contact**
* **FAQ**
* **404**
* **Coming Soon**

### Usage
To start working you have some dependencies to install. Then you can run it on your localhost. You can view the package.json file to see which scripts are included.

#### Install Dependencies
* **Node Installation:** [Install node js](https://nodejs.org/en/download/)
* **Gulp Installation:** Install gulp globally from your terminal
```
npm install --global gulp-cli
```
Or visit original [docs](https://gulpjs.com/docs/en/getting-started/quick-start)

#### Run Theme
After succesfully install those dependencies, open this theme with any IDE [[VS Code](https://code.visualstudio.com/) recommended], and then open internal terminal of IDE [vs code shortcut ctrl/cmd+\`]

* Install node package modules
```
npm install
```
* Run gulp
```
gulp
```
After that, it will open up a preview of the template in your default browser, watch for changes to core template files, and live reload the browser when changes are saved.

👉🏻 [visit documentation](https://docs.themefisher.com/airspace/)

## License

**Code License:** Released under the [MIT](https://github.com/themefisher/Airspace-Bootstrap-Agency-Template/blob/master/LICENSE) license.

## Resources
[Link to the original template](https://github.com/themefisher/Airspace-Bootstrap-Agency-Template)

Some third-party plugins that we used to build this template. Please check their licence.
* **Bootstrap v4.5**: https://getbootstrap.com/docs/4.5/getting-started/introduction/
* **Jquery v3.5.1**: https://jquery.com/download/
* **Ionicons Icons v2.0**: https://ionicons.com/v2/
* **Google Fonts**: http://fonts.google.com/
* **Animate CSS**: https://animate.style/
* **Magnific Popup**: https://dimsemenov.com/plugins/magnific-popup/
* **Slick**: https://kenwheeler.github.io/slick/
* **Shuffle**: https://vestride.github.io/Shuffle/
* **SyoTimer**: http://syomochkin.xyz/folio/syotimer/demo.html

repository: saimibrahim/SSGarageDoorsWebsite

repo_name: saimibrahim/SSGarageDoorsWebsite


text:
# Karoo GP

Karoo GP is an evolutionary algorithm, a genetic programming application suite written in Python which supports both
symbolic regression and classification data analysis. It is ready to work with your datasets, is multicore and GPU
enabled by means of the powerful library TensorFlow. The packge includes a Desktop application with an intuitive user
interface, and a Server application which supports fully scripted runs. Output is automatically archived.

Batteries included. No programming required.

Learn more at kstaats.github.io/karoo_gp/ ...


text:
---
layout: single
title: About
permalink: /about/
author_profile: true
---

I decided to start this blog while I was experimenting with GitHub. I've been involved in all kinds of software development projects: small, big, front-end, backend, IoT, mobile etc. and I've had to learn (And re-learn from time to time) lots of things on my own, looking for docs and examples on every corner of the Internet and although there are tons of good posts about almost anything you can imagine, I've sometimes felt **there's something missing**, sometimes a simple example, sometimes a not-so-simple one, or simply a usecase.

This blog is a complement to all those missing things and the repository where I *should* come back to quick-re-learn all of the things I've put in here. I hope it can be useful for others too.

gha_language: HTML

gha_license_id: MIT


text:
# **rs_driver**

[中文介绍](README_CN.md)

## 1 Introduction

**rs_driver** is cross-platform driver kernel for RoboSense LiDAR which is easy for users to do advanced development.

### 1.1 LiDAR type support

- RS16
- RS32
- RSBP
- RS128
- RS80
- RSM1-B3
- RSHELIOS

## 2 Compilation and Installation

**rs_driver** is compatible with the following platforms and compilers:

- Windows
  - MSVC ( tested with VC2017 and VC2019)
  - Mingw-w64 (tested with x86_64-8.1.0-posix-seh-rt_v6-rev0 )
- Ubuntu (16.04, 18.04)
  - gcc (4.8+)

### 2.1 Install dependencies

**rs_driver** depends on the following third-party libraries. They must be compiled/installed properly in advance:

- Boost
- pcap
- PCL (optional, only needed if build the visualization tool)
- Eigen3 (optional, only needed if use the internal transformation function)

#### 2.1.1 Install dependencies in Ubuntu

```sh
sudo apt-get install libboost-dev libpcap-dev libpcl-dev libeigen3-dev
```

#### 2.1.2 Install dependencies in Windows

##### Boost

In Windows, Boost needs compiling from source, please refer to the [official guide](https://www.boost.org/doc/libs/1_67_0/more/getting_started/windows.html) for detailed instructions.

Once finishing installing Boost, add a system environment variable named  ```BOOST_ROOT```  which is set to your Boost path.

##### PCAP

Firstly, install [pcap runtime](https://www.winpcap.org/install/bin/WinPcap_4_1_3.exe).

Then, download pcap's [developer's pack](https://www.winpcap.org/install/bin/WpdPack_4_1_2.zip) to your favorite location and add the path to ```WpdPack_4_1_2/WpdPack``` folder to the ```Path``` environment variable.

##### PCL

*Note: you can skip installing PCL if you don't want to compile visualization tool.*

(1) MSVC

Please use the provided official  [All-in-one installer](https://github.com/PointCloudLibrary/pcl/releases).

Select the "Add PCL to the system PATH for xxx" option during installation.

![](./doc/img/install_pcl.PNG)

(2) Mingw-w64

Since there'are no installers for mingw-w64 compiler available, PCL needs to be compiled out from source as instructed in this [tutorial](https://pointclouds.org/documentation/tutorials/compiling_pcl_windows.html).

## 3 Usage

### 3.1 Install in advance

*Note: installation is not supported in Windows.*

 Install the driver.

```bash
cd rs_driver
mkdir build && cd build
cmake .. && make -j4
sudo make install
```

Then find  **rs_driver** package and link to it in your ```CMakeLists.txt```.

```cmake
find_package(rs_driver REQUIRED)
include_directories(${rs_driver_INCLUDE_DIRS})
target_link_libraries(project ${rs_driver_LIBRARIES})
```

### 3.2 Use rs_driver as a submodule

Add **rs_driver** as your project's submodule, then find **rs_driver** package and link to it in your ```CMakeLists.txt```.

```cmake
add_subdirectory(${PROJECT_SOURCE_DIR}/rs_driver)
find_package(rs_driver REQUIRED)
include_directories(${rs_driver_INCLUDE_DIRS})
target_link_libraries(project ${rs_driver_LIBRARIES})
```

## 4 Quick Start

[Online connect LiDAR](doc/howto/how_to_online_use_driver.md)

[Decode pcap bag](doc/howto/how_to_decode_pcap.md)

## 5 Demo Code & Visualization Tool

### 5.1 Demo Code

**rs_driver** offers two demo programs in ```rs_driver/demo```：

- demo_online.cpp
- demo_pcap.cpp

User can refer to the demo code for usage of api. To build demo programs, set the following option to ```ON``` when configuring using cmake:

```bash
cmake -DCOMPILE_DEMOS=ON ..
```

### 5.2 Visualization Tool

**rs_driver** offer a visualization tool based on PCL in ```rs_driver/tool```：

- rs_driver_viewer.cpp

To build it, set the following option to ```ON``` when configuring using cmake:

```bash
cmake -DCOMPILE_TOOLS=ON ..
```

For basic usage of this tool, please refer to [Visualization tool guide](doc/howto/how_to_use_rs_driver_viewer.md)

## 6 Coordinate Transformation

**rs_driver** has the coordinate transformation function built inside and it can output the transformed point cloud directly, which can save the extra time cost of doing transformation after receiving point clouds from rs_driver. To enable this function, set the following option to ```ON``` when executing cmake command:
```bash
cmake -DENABLE_TRANSFORM=ON ..
```

For more details about the tool, please refer to  [Transformation guide](doc/howto/how_to_use_transformation_function.md)

## 7 Others

Please refer to the following files for more infomation.

- **Parameters definition**: ```rs_driver/src/rs_driver/driver/driver_param.h```
- **Point Cloud message definition**: ```rs_driver/src/rs_driver/msg/point_cloud_msg.h```
- **API definition**: ```rs_driver/src/rs_driver/api/lidar_driver.h```
- **Error code definition**: ```rs_driver/src/rs_driver/common/error_code.h```

Multi-Cast function: [Multi-Cast](doc/howto/how_to_use_multi_cast_function.md)

gha_license_id: NOASSERTION


text:
# Install Certbot

**[Certbot Install Guide](https://certbot.eff.org/lets-encrypt/ubuntubionic-nginx)**

* Add Certbot PPA

```
sudo apt-get update
sudo apt-get install software-properties-common
sudo add-apt-repository universe
sudo add-apt-repository ppa:certbot/certbot
sudo apt-get update
```

* Install Certbot

```
sudo apt-get install certbot python-certbot-nginx
```

* Get the certificate

```
sudo certbot -d <domain> --manual --preferred-challenges dns certonly
```

* ‘Please deploy a DNS TXT record under the name xxxx with the following value: <DNS_TXT_VALUE>’ displays
* Open a new browser window and enter the following into the address bar:
    * https://www.duckdns.org/update?domains=<domain_name_only>&token=<your_token_value>&txt=<DNS_TXT_value>
    * OK should appear in your browser
* Navigate back to the terminal, hit enter
* Certificate has been issued. Note the location of the certificate files.

**Note: If you were unable to acquire certificate after following the steps above, install Certbot-Auto and repeat step 4.**

* Certbot-auto installation steps:

```
wget https://dl.eff.org/certbot-auto
sudo mv certbot-auto /usr/local/bin/certbot-auto
sudo chown root /usr/local/bin/certbot-auto
sudo chmod 0755 /usr/local/bin/certbot-auto
```

## Clone this repository

* Make sure git is installed and clone the repo:

```
sudo apt-get install git
git clone https://github.com/cvisionai/Tator.git
cd Tator
```

## Real Secrets

* Copy the example secrets file to the real secrets file.

```
cp k8s/example-secrets.yaml k8s/real-secrets.yaml
```

* Update TATOR_SECRET_POSTGRES_USER
* Update TATOR_SECRET_POSTGRES_PASSWORD
* Update TATOR_SECRET_DOCKER_USERNAME: `<your Docker username>`
* Update TATOR_SECRET_DOCKER_PASSWORD: `<your Docker password>`
* Copy certificate information from the generated certificate files into the real-secrets.yaml file.

repository: jrtcppv/tator

repo_name: jrtcppv/tator


text:
Google Mobile Ads SDK for iOS
=============================
The Google Mobile Ads SDK is the latest generation in Google mobile advertising featuring refined ad formats and streamlined APIs for access to mobile ad networks and advertising solutions. The SDK enables mobile app developers to maximize their monetization in native mobile apps.

This repository contains the source for the DFP Showcase project, which shows a variety of ways that Doubleclick for Publishers can be integrated into your app.

Requirements:
-------------
* The latest Google AdMob Ads SDK
* Xcode version 4.5 or higher
* iOS simulator/device 5.0 or higher

Installation steps:
-------------------
1. Download the Google AdMob Ads SDK from
   https://developers.google.com/mobile-ads-sdk/download.

2. Add the SDK library and header files to your project.

3. Make sure to link the SDK library in your Build Phases.

4. Run the application on an iPhone 5.0 or higher device.

Downloads
----------
Please check out our [releases](https://github.com/googleads/googleads-mobile-ios-dfpshowcase/releases) for the latest downloads for the different sample apps.

Documentation
--------------
Check out our [developers site](https://developers.google.com/mobile-ads-sdk/) for documentation on using the SDK, and join the developer community on [our forum](https://groups.google.com/forum/#!forum/google-admob-ads-sdk).

Suggesting improvements
-----------------------
To file bugs, make feature requests, or to suggest other improvements, please use [github's issue tracker](https://github.com/googleads/googleads-mobile-ios-dfpshowcase/issues).

License
--------
[Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0.html)

Contributing
------------
Pull requests are welcome! Please sign [this Google Code contributor agreement](https://developers.google.com/open-source/cla/individual?csw=1) before submitting.


text:
---

Dr.Dimitri Vulis KOTM
Brighton Beach Boardwalk BBS, Forest Hills, N.Y.: +1-718-261-2013, 14.4Kbps

{% endraw %}
```

## Thread

+ Return to [January 1998](/archive/1998/01)

+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to "[John Gilmore <gnu<span>@</span>toad.com>](/authors/john_gilmore_gnu_at_toad_com_)"

+ 1998-01-19 (Sun, 18 Jan 1998 21:11:48 -0800 (PST)) - [Unofficial transcript of Bernstein hearing published](/archive/1998/01/ac42f8c8a2a206d1e9e8aa7c0fa04d70b6355f6c76bf1114fd3645b7217bcc1f) - _John Gilmore<EMAIL_ADDRESS>  + 1998-01-19 (Mon, 19 Jan 1998 13:43:19 +0800) - Re: Unofficial transcript of Bernstein hearing published -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_


text:
# IPython Extensions

Work in progress.

Contents:

* [Notebook theme toggle](#notebook-theme-toggle)
* [Notebook web notifications](#notebook-web-notifications)

## Notebook theme toggle

IPython notebook extension to toggle between two CSS themes, `theme_default.css` and `theme_alt.css`. If `theme_default.css` is not found, no CSS is loaded for the default setting, i.e. only the pre-installed default theme is used.

Installation:

    $ curl -L https://raw.github.com/sjpfenninger/ipython-extensions/master/nbextensions/theme_toggle.js > $(ipython locate)/nbextensions/theme_toggle.js
    $ curl -L https://raw.github.com/sjpfenninger/ipython-extensions/master/nbextensions/theme_alt.css > $(ipython locate)/nbextensions/theme_alt.css

Then, load it with the following code in your `custom.js`:

```javascript
$([IPython.events]).on("app_initialized.NotebookApp", function () {
    IPython.load_extensions('theme_toggle');
});
```

To load the alternative theme (`theme_alt.css`) by default, add the following after the loading code:

```javascript
// Always load alternative theme
require(["nbextensions/theme_toggle"], function (theme_toggle) {
    $([IPython.events]).on("notebook_loaded.Notebook", theme_toggle.theme_toggle);
});
```

To enable a ``t`` as a keyboard shortcut, add the following after the loading code:

```javascript
// Enable keyboard shortcut
require(["nbextensions/theme_toggle"], function (theme_toggle) {
    $([IPython.events]).on("notebook_loaded.Notebook", theme_toggle.theme_toggle_shortcut);
});
```

## Notebook web notifications

IPython notebook extension to display a web notification to notify you when the IPython kernel becomes idle. This can be useful when running tasks that take more than a couple of seconds to complete.

The extension has been tested with the most recent versions of Firefox, Chrome and Safari.

Initially, a button to request notification permissions is shown in the toolbar. After notification permissions have been granted, this button is replaced by a dropdown menu with five choices: `Disabled`, `0`, `5`, `10` and `30`. To activate notifications, select a minimum kernel busy time required to trigger a notification (e.g. if selecting `5`, a notification will only be shown if the kernel was busy for more than 5 seconds). The selection is saved in the notebook's metadata and restored when the notebook is re-opened.

Screenshot:

<img src="notification.png" alt="Notification screenshot" style="width: 372; height: 101px; "/>

Installation:

    $ curl -L https://raw.github.com/sjpfenninger/ipython-extensions/master/nbextensions/notify.js > $(ipython locate)/nbextensions/notify.js

Then, load it with the following code in your `custom.js`:

```javascript
$([IPython.events]).on("app_initialized.NotebookApp", function () {
    IPython.load_extensions('notify');
});
```

## License

The MIT License (MIT)

Copyright (c) 2014 Stefan Pfenninger

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

repository: choyichen/ipython-extensions

repo_name: choyichen/ipython-extensions


text:
# How to Integrate the Telerik UI for ASP.NET Core (Kendo) components with the ABP MVC UI

This is an example project that demonstrates how to integrate the Telerik UI for ASP.NET Core (Kendo) components with the ABP MVC UI. See the article that explain this project:

**https://community.abp.io/posts/how-to-integrate-the-telerik-ui-for-asp.net-core-kendo-components-with-the-abp-mvc-ui-u2voab2a**

repository: abpframework/abp-samples

gha_language: C#

repo_name: abpframework/abp-samples


text:
---
category: Student > Submission
title: Managing Submission Versions
redirect_from:
  - /student/managing_versions
---

## Reviewing Previous Submissions

The server stores all uploaded files and all automated grading results
for each of your submissions.

You may review the results of automated grading for the most recent
submission or any prior submission by choosing that version from the
"Select Submission Version:" drop down menu.

![](/images/student_ui_progression.png)

## Reverting to an Earlier Submission

By default, the server marks as "active" your most recent submission
(with the highest version number).  Your "active" submission is the
version that will be graded by the teaching assistant and recorded in
the gradebook.

![](/images/Rollback.png)

If you would like to specify that an earlier version be used as your
"active" version (if you accidentally submit files to the wrong
assignment!), you may do so by selecting that version from the "Select
Submission Version:" drop-down menu, and then pressing the "Grade This
Version" button.

![](/images/Rollback2.png)

## Cancelling Your Submission

Similarly, you may click the "Do Not Grade This Assignment" button if
you would like to retract all of your submissions to this assignment.
The system does not delete your uploaded materials, but the assignment
will not be graded by the TAs and you will receive a '0' for this
assignment.

Note:  You may not change the "active" version after TA grading has begun.

gha_language: JavaScript


text:
# VidMover Chunked File Upload using jQuery, based on Kaltura Libraries
Based on blueimp/jQuery-File-Upload library, this upload widget provides JavaScript based chunked upload with pause-and-resume and automatic optimization of file chunk size. Use this widget to implement a file upload workflow in your web based applications.

This is designed to work with VidMover accounts.  Sign up for an account at: http://vidmover.com.

# Project Specific Sections and Information
This JavaScript project can be used as reference or basis to implementing your own reliable chunked file upload to Kaltura.
To quickly see how it works, simply download the project to your localhost, edit index.php and switch the value of `$the_user_ks_to_use` to a valid Kaltura Session, then load the page from your localhost, open your browser console and try uploading a file. You'll see all the steps printed to the browser console.

# License and Copyright Information
All code in this project is released under the [MIT license](https://opensource.org/licenses/MIT) unless a different license for a particular library is specified in the applicable library path.

Copyright © Kaltura Inc. All rights reserved.
Authors and contributors: See [GitHub contributors list](https://github.com/kaltura/mwEmbed/graphs/contributors).

### Open Source Libraries
Review the [list of Open Source 3rd party libraries](open-source-libraries.md) used in this project.

repository: vidmover/chunked-file-upload-jquery

repo_name: vidmover/chunked-file-upload-jquery


text:
# Changelog

## 0.0.18 - in progress
### Added
- Initial zoom can be specified for scatterplots.
- Allow background imagery to be translated horizontally and vertically.
- Close cell set tabs.
- Color cell sets.
- Split long menu of cell operations into smaller menus from icons.
- Cell sets can be exported and imported as JSON.
- Union, intersection, and complement of cell sets.
- View all set descendants at a particular level.
- More public demos.
### Changed
- Gave up on CSS modules. We'll still split out CSS into separate files, but the extra name-munging was just confusing.
- Crosshairs are now full height and width.
- S3 data is now organized by dataset.
- Not making a UMD bundle any longer: It was very large, and slow.

## [0.0.17](https://www.npmjs.com/package/vitessce/v/0.0.17) - 2019-07-19
### Added
- Polygon selection tool leveraging the Nebula.gl package.
- Tooltip in heatmap.
- WIP: Using CSS modules.
- Hierarchical cell set manager component with save, name, rename, delete, rearrange, and view functionality.
### Changed
- PubSubVitessceGrid is now exported, and the registry lookup function is a parameter.
- A HiGlass demo no longer requires HiGlass to be checked in as part of this project.

## [0.0.16](https://www.npmjs.com/package/vitessce/v/0.0.16) - 2019-06-26
### Added
- Linked hover effect between spatial, scatterplot, and heatmap.
- Tooltip for cell status text upon hover in spatial and scatterplot views.
### Changed
- Using Deck.gl's built in picking instead of quadtree.

## [0.0.15](https://www.npmjs.com/package/vitessce/v/0.0.15) - 2019-06-07
### Added
- The `<TitleInfo>` component now takes children, and our JSX is tidier.
- Using [docz](https://www.docz.site/) for documentation, and add to the push script.
- Each JSON schema now checks that we are getting all and only the expected fields...
and we have a sort-of schema for the schema to make sure these checks are in place.
- Handle arbitrary mappings, not just t-SNE. Now computing PCA in vitessce-data.
- Flexible configuration: load components by name, or have multiple instances
of the same type of component.
- Half-baked proof-of-concept integration with HiGlass.
- Separate registry that holds Name -> Component mappings.
- Easy deployment to vitessce.io.
- Friendlier error page on AWS deployment.
- Display current version info in deployed demo.
- Can now specify the URL of a JSON config to load.
### Changed
- Make Heatmap more usable as a standalone.
- Fix (?) the scrollbars which had spontaneously appeared.
- Factor out the grid machinery into a separate package, `vitessce-grid`.
- More information on the Welcome page, so changed it to a two-column layout.

## [0.0.14](https://www.npmjs.com/package/vitessce/v/0.0.14) - 2019-04-29
### Added
- Add Cypress.io tests.
- Thank-you to NIH on the front page.
- Add Google Analytics to all pages.
- "Please wait" now waits for all layers.
- Use [react-grid-layout](https://github.com/STRML/react-grid-layout) for draggable panes;
Layouts can be specified either responsively, or with fixed grid positions. Grid height is
based on window height at load.
- Script (`push-demo.sh`) to push demo to S3, without making a new release.
- Use [OpenSeadragon](http://openseadragon.github.io/) for tiled imagery.
### Changed
- Spatial viewport is part of the initial FAKE_API_RESPONSE, instead of being hardcoded.
- Neighborhoods are enabled, but hidden by default.

## [0.0.13](https://www.npmjs.com/package/vitessce/v/0.0.13) - 2019-03-26
### Changed
- Lots of display tweaks to create a consistent dark color scheme.

## [0.0.12](https://www.npmjs.com/package/vitessce/v/0.0.12) - 2019-03-26
### Added
- Heatmap is row-normed. (This is a change in `vitessce-data`.)
- Borders on heatmap components... but this will be reverted.
- Cells are visible on initial load.
### Changed
- Dark color scheme, with better contrast when colored
- Heatmap spans the entire bottom.

## [0.0.11](https://www.npmjs.com/package/vitessce/v/0.0.11) - 2019-03-20
### Added
- Roll up the layers list when not hovered.
- Component titles give summary stats about data.
### Changed
- Change color scales, styling of unselected cells, and marquee rendering, to improve contrast.
- Only update selected set at end of drag.

## [0.0.10](https://www.npmjs.com/package/vitessce/v/0.0.10) - 2019-03-19
### Added
- Heatmap: Gene expression levels occupy most of the space; Above, there are bands showing
the currently selected cell set, and the current cell coloring.
### Changed
- Spatial and t-SNE backgrounds are now black.
- Move the Factor radio buttons to their own component, above Genes.

## [0.0.9](https://www.npmjs.com/package/vitessce/v/0.0.9) - 2019-03-17
### Added
- Neighborhoods layer: no interactivity, and it's obvious that the source data has some problems.
### Changed
- Got the image registration right, finally.
- Initial viewport is hardcoded: Data is no longer centered on (0, 0) origin.

## [0.0.8](https://www.npmjs.com/package/vitessce/v/0.0.8) - 2019-03-16
### Added
- Load and validate JSON for clusters, categorical factors, gene expression levels, and cell neighborhoods.
- Toggle between factor values: Spatial and t-SNE categorical colors are updated.
- Toggle between gene expression levels: Spatial and t-SNE continuous colors are updated.
- Toggle between multiple imagery layers.
### Changed
- The stained imagery is positioned and scaled better, but still slightly off.
- No outlines on cell polygons.

## [0.0.7](https://www.npmjs.com/package/vitessce/v/0.0.7) - 2019-03-07
### Added
- Component diagram and minimal documentation of library.
- Make space for a brief description of the dataset on the welcome page.
- Load background imagery.
- More unit tests.
- Label each component, and identify the current dataset.
- Replace global selection tools with in-component tools.
- Toggle visibility of each layer.
- "Please wait" while molecules load.
- Add placeholder for genes component.
### Changed
- Use a quadtree to identify the cells in the selected region.

## [0.0.6](https://www.npmjs.com/package/vitessce/v/0.0.6) - 2019-02-25
### Added
- Welcome screen where user picks dataset.
- All the cells are selected on start.
### Removed
- No longer supports drag and drop to add file.

## [0.0.5](https://www.npmjs.com/package/vitessce/v/0.0.5) - 2019-02-20
### Added
- Distinguish pan and single-select mode from drag-to-select.
- Drag-to-select supported for both Spatial and Tsne: Selection state is linked.
- Set of selected cells is updated during drag; there is also a grey overlay.
- Add the strict AirBNB linting rules.
- Load Linnarsson cell data by default, rather than starting from a blank screen.
### Changed
- Assume data has been scaled to fit a 2000 pixel-wide window, centered on the origin,
  and adjust line widths and dot sizes accordingly.

## [0.0.4](https://www.npmjs.com/package/vitessce/v/0.0.4) - 2019-02-08
### Added
- Drag and drop JSON files representing cells and molecules.
- There is a helpful link to the sample data download.
- JSON files are validated against schema, and detailed errors go to console.
- Flexbox CSS for clean columns.

repository: ThHarbig/vitessce

repo_name: ThHarbig/vitessce


text:
author : Emine Tas
date : 03/05/2019

# Servomotor programming
## Metal rods

### What's a servomotor ?
*" It's a motor capable of maintaining an opposition to a static force and whose position is continuously checked and corrected according to the measurement. " Wikipedia*
*" The position is defined with an angle travel limit of 180 degrees, but also available in continuous rotation. " Wikipedia*
 It have an angle generally ranging from 0 to 180 °.

### How to connect it?
It's composed of 3 cables : red, brown and orange.
* Red for + (5V)
* Brown for - (ground)
* Orange for signal

### What is his purpose in this project ?
Simply rotate continuously from right to left or from left to right depending on
the position of the robot in the field.

```C
/* The "Servo" library must be included to handle the servomotor */
#include <Servo.h>

/* Creating a servo object to control the servo motor */
Servo monServomoteur;
Servo monServomoteur2;

void setup() {
  /* Attach the servomotor to pin x */
  monServomoteur.attach(9);
  monServomoteur2.attach(10);

  /* According to the signal on the pin 7 activation of one of the servomotor */
  /* Definition of the starting point at 90° */
  if(digitalRead(7)){
     monServomoteur2.write(90);
     delay(15);
  }else{
     monServomoteur.write(90);
     delay(15);
  }
}

void loop() {
  /* The left one : right to left */
  if(digitalRead(7)){
    for (int position = 110; position <= 40; position++) {
      monServomoteur2.write(position);
      delay(15);
    }
  }else{
  /* The right one : left to right */
    for (int position = 110; position >= 40; position--) {
      monServomoteur.write(position);
      delay(15);
    }
  }
}
```

### Tips for construction
If you want to make a assembly with screws caution !
To screw the rod on the servomotor it was necessary to make a big hole so that it does not turn in void.

repository: nofazo/Tutorials

repo_name: nofazo/Tutorials


text:
# Contributing to csvw

## Installing csvw for development

1. Fork `cldf/csvw`
2. Clone your fork
3. Install `csvw` for development (preferably in a separate [virtual environment](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/)) running
```shell script
pip install -r requirements
```

## Running the test suite

The test suite is run via

```shell script
pytest
```

Cross-platform compatibility tests can additionally be run via
```shell script
tox -r
```

repository: Gaunt/csvw

repo_name: Gaunt/csvw


text:
---
layout: post
title: Session-Scoped Routes
---

DON'T. Session-scoping a route is **very dangerous** since if the user opens two tabs,
that route instance will be shared between the two tabs, leading to unpredictable errors.

When a new tab is open, and it shows the same route as the first tab, the route will detach
from the first tab and attach to the second tab. Remember: every tab has its own `UI` instance.
Effectively, the route detaches from the UI in first tab and attaches to the UI in the second tab.

The problem is that JavaScript components in the first tab of the browser are still
visible and responsive to events such as clicks; the clicks will be sent to the
route which is not attached to this UI anymore. That can lead to strange behavior.

I've created an example Vaadin 23.3.4-based project which demoes this issue, and observed the behavior.
When a button is clicked in the first tab, Vaadin detects that the route is no longer attached to this
UI, and assumes that the component is no longer there.
The intuitive corrective measure is to correct the client-side state by removing
the JavaScript components from the DOM tree, and that's exactly what happens.

However, the behavior may change in the future, so don't depend on it.

Scope to UI instead. Note that this can not be done properly, see [Vaadin UI/Tab Scoping](../vaadin-ui-scope/).
Also see [Cached Vaadin Routes](../cached-vaadin-routes/).

gha_language: SCSS


text:
## Planar Pose Estimation

A ROS package for a simple object detection and planar pose estimation method for textured objects.

[![CodeFactor](https://www.codefactor.io/repository/github/paul-shuvo/planar_pose/badge)](https://www.codefactor.io/repository/github/paul-shuvo/planar_pose)
[![Build Status](https://www.travis-ci.com/paul-shuvo/planar_pose.svg?branch=main)](https://www.travis-ci.com/paul-shuvo/planar_pose)
![](https://img.shields.io/badge/ROS-Noetic%20%7C%20Melodic%20%7C%20Kinetic-blue)
![](https://img.shields.io/badge/Python-2.7%20%7C%203.3+-green)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://opensource.org/licenses/MIT)

<!-- __Note:__ `sudo apt install ros-noetic-tf-conversions` before installing it

following is an important image

![](https://user-images.githubusercontent.com/2781007/35928250-8c7dcb76-0be1-11e8-8f57-ce1ec9e9f36d.png)

[crocos_installation](https://github.com/orocos/orocos_kinematics_dynamics/blob/master/python_orocos_kdl/INSTALL.md)

[image_issue](https://github.com/orocos/orocos_kinematics_dynamics/issues/115) -->

<!-- ## Table of contents -->
- [Planar Pose Estimation](#planar-pose-estimation)
  - [Dependencies](#dependencies)
  - [Install](#install)
  - [Run](#run)
  - [Published Topics](#published-topics)
  - [Demo](#demo)
  - [Citation](#citation)
  - [TODO](#todo)

### Dependencies

- ROS Noetic/Melodic/Kinetic
- Python 2.7, 3.3+ for ROS Noetic (should support Python 3 for other ROS Distros as well)
- OpenCV (Tested on opencv 4, should work with other opencv versions as well)

### Install
For new projects:

```
mkdir catkin_ws/src
cd catkin_ws/src
git clone https://github.com/paul-shuvo/planar_pose.git
cd planar_pose
pip install -r requirements.txt
cd ../../..
catkin_make
```

For existing project:

```
cd 'your_project_path'/src
git clone https://github.com/paul-shuvo/planar_pose.git
cd planar_pose
pip install -r requirements.txt
cd ../../..
catkin_make
```

### Run

This package contains a object detection module and a planar pose estimation module. Planar pose estimation module depends on the object detection module.

To run the object detection module:
```
cd 'your_project_path`
source devel/setup.bash
rosrun planar_pose object_detection.py
```

Then, to run the planar pose estimation module:
```
cd 'your_project_path`
source devel/setup.bash
rosrun planar_pose planar_pose_estimation.py
```

### Published Topics

 - `/detected_object`
    Coordinates of the boundary of the detected objects in terms of a json string.
    ```json
    ---
    "data: {\"cheezeit\": [[369, 252], [367, 344], [423, 339], [429, 251]], \"book-1\": [[518, 234],\
    \ [525, 225], [513, 230], [590, 222]]}"
    ---
    ```
 - `/object_pose_info`
    Pose (Quaternion) info of the detected objects in terms of a json string.
    ```json
    ---
    data: "{\"cheezeit\": {\"position\": [-0.21074476838111877, 0.17126992344856262, 1.377000093460083],\
    \ \"orientation\": [-0.7785678371108322, -0.03650856877418329, 0.6243951877330678,\
    \ 0.05128252098335612]}, \"book-1\": {\"position\": [0.10074007511138916, 0.07484704256057739,\
    \ 0.8750000596046448], \"orientation\": [-0.99671235271185, -0.024004214965333632,\
    \ -0.05656042965190621, 0.052812890595937564]}}"
    ---
    ```
 - `/object_pose_array`
    PoseArray of the detected objects.
    ```yaml
    ---
    header:
        seq: 9
        stamp:
            secs:<PHONE_NUMBER>
            nsecs: 180106401
        frame_id: "kinect2_rgb_optical_frame"
    poses:
      -
        position:
            x: -0.3775361180305481
            y: 0.18009251356124878
            z: 1.2940000295639038
        orientation:
            x: -0.8238780569888
            y: -0.005098909875330737
            z: 0.5370874941853346
            w: 0.1809308484481323
        -
        position:
            x: 0.04039544239640236
            y: 0.06119309365749359
            z: 0.8650000691413879
        orientation:
            x: -0.997179603918241
            y: -0.036229147670746836
            z: -0.0050051373858676085
            w: 0.06553804229804013
    ---
    ```

### Demo

The images of the objects' planes should be put inside the `src/objects` folder. The path could be changed in the `config.py` file. For the demo below, the following image of a "Cheezit" box was used.

![](src/objects/cheeze-it.png)

![](doc_/pose_viz.gif)

`(a)`, `(b)`, `(c)` are recovered poses from robot’s camera and `(d)`, `(e)`, `(f)` are corresponding poses visualized in RViz

![](doc_/cam_rviz.png)

### Citation

Please cite these papers in your publications if it helps your research:

```tex
@inproceedings{paul2020object,
      title={Object Detection and Pose Estimation from RGB and Depth Data for Real-time, Adaptive Robotic Grasping},
      author={S. K. Paul and M. T. Chowdhury and M. Nicolescu and M. Nicolescu},
      booktitle={Proceedings of the International Conference on Image Processing, Computer Vision, and Pattern Recognition (IPCV)}
      year={2020},
}
```

### TODO

- [ ] Do more tests


text:
# TF-DNA-PredictionsDB [![CircleCI](https://circleci.com/gh/Duke-GCB/TF-DNA-PredictionsDB.svg?style=svg)](https://circleci.com/gh/Duke-GCB/TF-DNA-PredictionsDB)
Website for viewing transcription factor predictions for gene lists and custom DNA sequences.

## Major Components
__Predictions Config File__

predictionsconf.yaml - this config file determines what will be downloaded and how prediction database will work

__Predictions Database__

Postgres database contains indexed gene lists, custom user data and predicitions data for use by webserver.py

__Database Loading Script__

load.py - downloads files and loads the database based on predictionsconf.yaml

__Webserver__

webserver.py serves web portal and API for accessing the 'pred' database

__Database Vacuum Script__

vacuum.py deletes old user data from the 'pred' database

__Web Portal__

Directory portal/ contains the reactjs project that builds static/js/bunde.js for webserver.py to serve.

__Custom Prediction/Preference Worker__

Calculates predictions and preferences for user uploaded sequences.
https://github.com/Duke-GCB/Predict-TF-Binding-Worker

## Running:

__Deployment__

We use playbook tf_dna_predictions.yml from https://github.com/Duke-GCB/gcb-ansible.

__Run via docker-compose__

Download `docker-compose.yml` and `.env_sample`.
Rename `.env_sample` to `.env`
Change DB_PASS_ENV and POSTGRES_PASSWORD to be whatever password you want.
Start the database and webserver.
```
docker-compose up -d
```
Populate the database. (This will take quite a while depending upon predictionsconf.yaml)
```
docker-compose run --no-deps --rm web python load.py
```

## Javascript unit tests:
Requires mocha and chai.
Setup:
```
cd portal
npm install -g mocha
npm install --dev
```

To run:
```
cd portal
npm run test
```

## Python unit tests:
From the root directory run this:
```
nosetests
```
Integration tests are skipped (they are run by circleci).
See tests/test_integration.py skip_postgres_tests for instructions for running them manually.

## Config file updates:
Under the `util` directory there is a python script for updating the config file.
It can be run like so:
```
cd util
python create_conf.py
```
This will lookup the latest predictions based on the __DATA_SOURCE_URL__ in create_conf.yaml.
If you want to add a new gene list you will need to update __GENOME_SPECIFIC_DATA__ in create_conf.yaml.

repository: gordanlab/TF-DNA-PredictionsDB

repo_name: gordanlab/TF-DNA-PredictionsDB


text:
# Device Detector [![npm](http://img.shields.io/npm/v/node-device.svg)](https://www.npmjs.com/package/node-device) ![Downloads](https://img.shields.io/npm/dm/node-device.svg) [![Build Status](https://secure.travis-ci.org/leonardothibes/node-device.png)](http://travis-ci.org/leonardothibes/node-device) [![Package Quality](http://npm.packagequality.com/shield/node-device.svg)](http://packagequality.com/#?package=node-device) [![License](https://img.shields.io/npm/l/node-device.svg)](LICENSE)

Node.js device detector.

Installation
------------

```bash
npm install node-device --save
```

Examples
--------

* [Providing User Agent](#providing-user-agent)
* [Not Providing User Agent](#not-providing-user-agent)

Providing User Agent
--------------------

```js
const device = require('node-device');

const userAgent = 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_6; en-US) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27';

device.detect(userAgent); // { browser: 'Safari', device: 'Desktop', os: 'macOS' }
```

Not Providing User Agent
------------------------

```js

// In Browser
<script src="dist/node-device.min.js"></script>

window.device.detect(); // { browser: 'Safari', device: 'Desktop', os: 'macOS' }

// In Node.js
const device = require('node-device');

device.detect() // { browser: 'Unknow', device: 'Node.js', os: 'Node.js' }

```

Test and development
--------------------

* Install external dependencies: **``npm install``**
* Run the test suite without coverage: **``npm test``**
* Run the test suite with coverage: **``npm run testdox``**

How to Contribute
-----------------

* Open a pull request or an issue about what you want to implement / change. We're glad for any help!
* Please be aware that we'll only accept fully tested code.

Contributors
------------

 * **Leonardo Thibes<EMAIL_ADDRESS>
LICENSE
=======

Copyright (c) 2018 Leonardo Thibes

The MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: leonardothibes/node-device

repo_name: leonardothibes/node-device


text:
# imgaug-doc

This repository contains code and assets to generate the documentation of [imgaug](https://github.com/aleju/imgaug).
The files were moved to their own repository (instead of a folder inside `imgaug`)
as they were starting to become too large -- especially the images.

To generate the docs, first install the necessary packages, e.g. via:
```bash
pip install Sphinx numpydoc sphinx_rtd_theme
```

Then generate the documentation via
```bash
make html
```

When calling `make html`, the content of this repository (`imgaug-doc`) must be a folder
inside the main repository (`imgaug`), i.e. something like `imgaug/doc` where `doc`
contains this repository's content.

Note that when calling `make html` you will probably get lots of warnings saying
`WARNING: toctree contains reference to nonexisting document (...)`. That is normal.
Just ignore these messages.

gha_language: Jupyter Notebook


text:
# DeepMatchVO
Implementation of ICRA 2019 paper: [Beyond Photometric Loss for Self-Supervised Ego-Motion Estimation](https://arxiv.org/abs/1902.09103)
```
@inproceedings{shen2019icra,
  title={Beyond Photometric Loss for Self-Supervised Ego-Motion Estimation},
  author={Shen, Tianwei and Luo, Zixin and Zhou, Lei and Deng, Hanyu and Zhang, Runze and Fang, Tian and Quan, Long},
  booktitle={International Conference on Robotics and Automation},
  year={2019},
  organization={IEEE}
}
```

#### Update (Sep-26, 19):
We published an follow-up paper on this topic, whose updated loss terms have positive influence on the depth estimation performance. See [Self-Supervised Learning of Depth and Motion Under Photometric Inconsistency
](https://arxiv.org/abs/1909.09115) for details.
```
@inproceedings{shen2019iccvw,
  title={Self-Supervised Learning of Depth and Motion Under Photometric Inconsistency},
  author={Shen, Tianwei and Zhou, Lei and Luo, Zixin and Yao, Yao and Li, Shiwei and Zhang, Jiahui and Fang, Tian and Quan, Long},
  booktitle={International Conference on Computer Vision (ICCV) Workshops},
  year={2019},
  organization={IEEE}
}
```

# Environment
This codebase is tested on Ubuntu 16.04 with Tensorflow 1.7 and CUDA 9.0.

# Demo
### Download Pre-trained Models
Download the [models](https://drive.google.com/file/d/1xWNm9MclJHD729uS6U6k2Oopn--Vnban/view?usp=sharing) presented in the paper, and then unzip them into the `ckpt` folder under the root.

### Run a Simple Script
After downloading the model, you can run a simple demo to make sure the setup is correct.
```bash
python demo.py
```
The output is shown below
<img src='data/demo_result.png'>

# Generate Train and Test Data
Given that you have already downloaded the [KITTI](http://www.cvlibs.net/datasets/kitti/) odometry and raw datasets, the provided python script `data/prepare_train_data.py` is able to generate the training data with SIFT feature matches. Yet, the feature and match files are in accord with our internal format, which are not publicly available at this point. Alternatively, we suggest first generating the concatenated image triplets by

```bash
# for odometry dataset
python data/prepare_train_data.py --dataset_dir=$kitti_raw_odom --dataset_name=kitti_odom --dump_root=$kitti_odom_match3 --seq_length=3 --img_width=416 --img_height=128 --num_threads=8
```
where `$kitti_raw_odom` and `$kitti_odom_match3` are the input odometry dataset and output files for training. Some example input paths (on my machine) are shown in `command.sh`.

Then download our pre-computed camera/match files from [link](https://drive.google.com/open?id=1ZnLtQqFDqEVghtDjEOVnBlFpyDaJY_Um). Replace the corresponding generated camera files in `$kitti_odom_match3` with the ones you have downloaded. It contains the all the camera intrinsics and the sampled matching information (for each file of an image triplet, the first line is the camera intrinsics, then the next 200 (2*100) lines are the matching coordinates for two image pairs (target image with left source image and target image with right source image)).

# Train
The training is done, e.g. on the KITTI odometry dataset, by using

```bash
# Train on KITTI odometry dataset
match_num=100
python train.py --dataset_dir=$kitti_odom_match3 --checkpoint_dir=$checkpoint_dir --img_width=416 --img_height=128 --batch_size=4 --seq_length 3 \
    --max_steps 300000 --save_freq 2000 --learning_rate 0.001 --num_scales 1 --init_ckpt_file $checkpoint_dir'model-'$model_idx --continue_train=True --match_num $match_num
```

We suggest training from a pre-trained model, such as the ones we have provided in [models](https://drive.google.com/file/d/1xWNm9MclJHD729uS6U6k2Oopn--Vnban/view?usp=sharing). Also note that do not use the model trained on the KITTI odometry dataset (for pose evaluation) on depth evaluation, nor the model trained on the KITTI Eigen split on pose evaluation. Otherwise, you will get better but biased (train-on-test) results because test samples in one dataset have overlap with the training samples in another.

# Test
To evaluate the depth and pose estimation performance in the paper, use

```bash
# Testing depth model
r=250000
depth_ckpt_file=$rootfolder$checkpoint_dir'model-'$r
depth_pred_file='output/model-'$r'.npy'
python test_kitti_depth.py --dataset_dir $kitti_raw_dir --output_dir $output_folder --ckpt_file $depth_ckpt_file #--show
python kitti_eval/eval_depth.py --kitti_dir=$kitti_raw_dir --pred_file $depth_pred_file #--show True --use_interp_depth True
```
You can also use `--show` option to visualize the depth maps.

```bash
# Testing pose model
sl=3
r=258000
pose_ckpt_file=$root_folder$checkpoint_dir'model-'$r
for seq_num in 09 10
do
    rm -rf $output_folder/$seq_num/
    echo 'seq '$seq_num
    python test_kitti_pose.py --test_seq $seq_num --dataset_dir $kitti_raw_odom --output_dir $output_folder'/'$seq_num'/' --ckpt_file $pose_ckpt_file --seq_length $sl --concat_img_dir $kitti_odom_match3
    python kitti_eval/eval_pose.py --gtruth_dir=$root_folder'kitti_eval/pose_data/ground_truth/seq'$sl'/'$seq_num/  --pred_dir=$output_folder'/'$seq_num'/'
done
```

It outputs the same result in the paper:

| Seq     | ATE mean | std    |
|---------|----------|--------|
| 09      | 0.0089   | 0.0054 |
| 10      | 0.0084   | 0.0071 |

# Contact
Feel free to contact me (Tianwei) if you have any questions, either by email or by issue.

# Acknowledgements
We appreciate the great works/repos along this direction, such as [SfMLearner](https://github.com/tinghuiz/SfMLearner) and [GeoNet](https://github.com/yzcjtr/GeoNet), and also the evaluation tool [evo](https://github.com/MichaelGrupp/evo) for KITTI full sequence evaluation.


text:
# Changelog

All notable changes to this project will be documented in this file, in reverse chronological order by release.

## 1.0.1 - TBD

### Added

- Nothing.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Nothing.

## 1.0.0 - 2018-10-18

### Added

- Adds the method `OAuth2User::getDetail(string $name, $default = null)` in
  order to fulfill the zend-expressive-authentication 1.0.0 API for the
  `UserInterface`.

### Changed

- The method `OAuth2User::getUserRoles() : array` was refactored to
  `OAuth2User::getRoles() : iterable` in order to match the
  zend-expressive-authentication 1.0.0 API.

- The method `OAuth2User::getUserData() : array` was refactored to
  `OAuth2User::getDetails() : array` in order to match the
  zend-expressive-authentication 1.0.0 API.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Nothing.

## 0.2.1 - 2018-03-28

### Added

- Nothing.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Fixes how the callback factory produces a pipeline. Instead of using an
  `Application` instance derived from the `ApplicationFactory` (which will
  receive a shared route collector and shared middleware), it now produces a
  `MiddlewarePipe` instance into which it pipes the various middleware. It also
  creates a _new_ router, based on the type returned from the container (it
  assumes no constructor arguments are necessary), and passes that to a new
  `RouteMiddleware` instance to ensure it is sandboxed from the main
  application.

## 0.2.0 - 2018-03-27

### Added

- [#1](https://github.com/phly/phly-expressive-oauth2clientauthentication/pull/1)
  adds support for Expressive v3 and zend-expressive-authentication 0.4+.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- [#1](https://github.com/phly/phly-expressive-oauth2clientauthentication/pull/1)
  removes support for Expressive v2 releases, including pre-0.4 releases of
  zend-expressive-authentication.

### Fixed

- Nothing.

## 0.1.2 - 2017-11-16

### Added

- Nothing.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Fixes an import in the DebugProviderMiddlewareFactory for the
  RedirectResponseFactory to ensure it resolves correctly.

## 0.1.1 - 2017-11-16

### Added

- Adds templates for PlatesPHP, Twig, and zend-view.
- Adds documentation covering templates.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Nothing.

## 0.1.0 - 2017-11-16

### Added

- Everything.

### Changed

- Nothing.

### Deprecated

- Nothing.

### Removed

- Nothing.

### Fixed

- Nothing.


text:
---
author: jpliew
title: "Exercise 3 - Kinght Rider LED"
layout: guide
lang: nl
hidden: true
contents:
- Exercise 3 - Knight Rider LED

parts:
 RES_330R: 5
 LED_RED: 5
 JUMPER_WIRE: 5
schematic:
 exercise_03_schematic.svg
breadboard:
 exercise_03_breadboard.svg

---

## Exercise 3 - Knight Rider LED

![(STMB) - Kinght Rider LED](img/exercise_03_knightrider.svg){: .full-w }

The Knight Rider LED is inspired by the advanced artificial intelligent self-aware car from the 80's Knight Rider TV series. The car was a customized 1982 Pontiac Trans-Am easily identified by its light scanning from left to right. This exercise is to simulate the scanner light using LEDs.

{% include schematic.html %}

{% include parts.html %}

1. Connect a JUMPER WIRE to GND and 31J.
2. Connect a JUMPER WIRE to 31G and 33G.
3. Connect a JUMPER WIRE to 33H and 35H.
4. Connect a JUMPER WIRE to 35G and 37G.
5. Connect a JUMPER WIRE to 37H and 39H.
6. Connect a 330Ω RESISTOR to PIN2 and 40J.
7. Connect a 330Ω RESISTOR to PIN3 and 38J.
8. Connect a 330Ω RESISTOR to PIN4 and 36J.
9. Connect a 330Ω RESISTOR to PIN5 and 34J.
10. Connect a 330Ω RESISTOR to PIN6 and 32J.
11. Connect the anode (longer) pin of a RED LED to 40F and cathode (shorter) pin to 39F.
12. Connect the anode (longer) pin of a RED LED to 38F and cathode (shorter) pin to 37F.
13. Connect the anode (longer) pin of a RED LED to 36F and cathode (shorter) pin to 35F.
14. Connect the anode (longer) pin of a RED LED to 34F and cathode (shorter) pin to 33F.
15. Connect the anode (longer) pin of a RED LED to 32F and cathode (shorter) pin to 31F.
{: .connections }

{% include breadboard.html %}

gha_language: CSS


text:
[kin-android](../../../index.md) / [org.kin.sdk.base.tools](../../index.md) / [NetworkOperation](../index.md) / [State](index.md) / [QUEUED](./-q-u-e-u-e-d.md)

# QUEUED

`object QUEUED : State`

Operation has been added to the `activeOperations` list and is awaiting scheduling.

repository: samdowd/kin-android

repo_name: samdowd/kin-android


text:
# SAP Emarsys Integration with SAP Emarsys APIs

\| [Recipes by Topic](../../readme.md ) \| [Recipes by Author](../../author.md ) \| [Request Enhancement](https://github.com/SAP-samples/cloud-integration-flow/issues/new?assignees=&labels=Recipe%20Fix,enhancement&template=recipe-request.md&title=Improve%20SAP%20Emarsys%20Integration%20with%20SAP%20Emarsys%20APIs) \| [Report a bug](https://github.com/SAP-samples/cloud-integration-flow/issues/new?assignees=&labels=Recipe%20Fix,bug&template=bug_report.md&title=Issue%20with%20SAP%20Emarsys%20Integration%20with%20SAP%20Emarsys%20APIs)\| [Fix documentation](https://github.com/SAP-samples/cloud-integration-flow/issues/new?assignees=&labels=Recipe%20Fix,documentation&template=bug_report.md&title=Docu%20fix%20SAP%20Emarsys%20Integration%20with%20SAP%20Emarsys%20APIs) \|

 ![SAP Business Accelerator Hub](https://github.com/SAPAPIBusinessHub.png?size=50 ) | [SAP Business Accelerator Hub](https://api.sap.com/allcommunity) |
 ----|----|

This integration flow allows you to connect to the SAP Emarsys APIs

The integration of SAP Emarsys Integration with SAP Emarsys APIs illustrates how to use WSSE authentication over SSL and communicate with the SAP Emarsys APIs.

It can be used to integrate scenarios related to the Customer Engagement platform.

For example, it can be used to integrate Business Partners, Sales Orders from SAP S/4HANA with SAP Emarsys by exposing a REST endpoint in Cloud Integration.

Please also refer to: https://dev.emarsys.com/

[Download the integration package](SAPEmarsysIntegrationwithSAPEmarsysAPIs.zip)\
[View package on the SAP Business Accelerator Hub](https://api.sap.com/package/SAPEmarsysIntegration)\
[View documentation](EmarsysStarterPack_SampleIntegrationforContactsReplication.pdf)\
[View high level effort](effort.md)
## Integration flows
### Replicate Contacts to SAP Emarsys API
This integration flow illustrates authentication handling and consumption of SAP Emarsys APIs \
 ![input-image](Replicate_Contacts_to_SAP_Emarsys_API.png)
### Custom Mapping for replicating Contacts to SAP Emarsys
Sample iFlow to extend/customize the Contacts replication mapping \
 ![input-image](Custom_Mapping_for_replicating_Contacts_to_SAP_Emarsys.png)

repository: SAP/apibusinesshub-integration-recipes

gha_language: Java

repo_name: SAP/apibusinesshub-integration-recipes


text:
### [CVE-2015-8606](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-8606)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Multiple cross-site scripting (XSS) vulnerabilities in SilverStripe CMS & Framework before 3.1.16 and 3.2.x before 3.2.1 allow remote attackers to inject arbitrary web script or HTML via the (1) Locale or (2) FailedLoginCount parameter to admin/security/EditForm/field/Members/item/new/ItemEditForm.

### POC

#### Reference
- http://seclists.org/fulldisclosure/2015/Dec/55
- http://www.openwall.com/lists/oss-security/2015/12/17/1
- http://www.openwall.com/lists/oss-security/2015/12/17/11
- http://www.openwall.com/lists/oss-security/2015/12/18/5
- http://www.silverstripe.org/download/security-releases/ss-2015-026
- https://cybersecurityworks.com/zerodays/cve-2015-8606-silverstripe.html

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
![Preview](https://raw.githubusercontent.com/mschuchard/linter-terraform-syntax/master/linter_terraform_syntax.png)

### Linter-Terraform-Syntax
`Linter-Terraform-Syntax` aims to provide functional and robust `terraform validate/plan` linting functionality within Atom.

### Installation
`Terraform` is required to be installed before using this. The `Linter` and `Language-Terraform` Atom packages are also required but should be automatically installed as dependencies thanks to steelbrain's `package-deps`.

### Usage
- In the package settings there is an option to use `terraform plan` instead of `terraform validate`. Both options will show syntax errors for the current file and notify syntax errors and non-syntax validation errors for the current directory. The plan option will additionally notify non-syntax plan errors for the current directory.

repository: Arcanemagus/linter-terraform-syntax

repo_name: Arcanemagus/linter-terraform-syntax


text:
---
title: Buzzfeed Quizzes
layout: post
author: dhilan.nathwani
permalink: /buzzfeed-quizzes/
source-id: 1cCYV7-STV8XbsjvTuJEdzMKSodfaUuEdzOgIg0MPs-I
published: true
---

    Title:
     Starting to create buzzfeed quizzes using Python
    Date:
     23/04/18

    Lesson Review

     How did I learn? What strategies were effective?

    Today we started to create buzzfeed quizzes which is very enjoyable for me because my cousin does these quizzes lots and I have always wondered what is is like to create one. My quiz is based on creating your perfect holiday by asking questions which I use to figure out what time of person you are. I have to find out whether you enjoy exciting, active holidays or relaxing holiday spending most of your time in a spa. At the end of the lesson we got to do other buzzfeed's which helped me understand more about the structure of this type of quiz. I am glad we got to do that at the end of a lesson

     What limited my learning? Which habits do I need to work on?

    I forgot that you need to order your potential answers in a scale so that you can create an average which actually is meaningful. At the start my 3rd answer was spa and my 4th was ziplane which are 2 completely different answers but the number only changes by 1. Spa should be the 1st answer and zipline as the 4th so that the difference between the numbers 3. This changes the average by a lot more so that you can get different answers. I would have got more progress done if I realised that at the start of the lesson

    What will I change for next time? How will I improve my learning?

    Next lesson I will make sure I have completely understood the task before attempting to complete it so that I get more progress done and I am not frantically panicking at the end of the lesson


text:
# The report

### The backend works as followed

![layout of stystem](layout.png)

The Server is connected by the router to a domain of transIP. Apache2 is running in the server which acts as a reverse proxy. This means that the sender doesn't know were the server is, but gets the correct data. Normally a proxy protects the sender, but in the reverse proxy the reciever is protected.

The Ubuntu server contains some dockers:
* MySQL
* Scaper
* RESTful API
* Site files

The SQL database consist of three tables:
* kamernet tabel; for all the room info
* kmaernet_log; for all the extra info, such as number of new uploads
* kamernet_sms; for the list of numbers which needs to be notified (has the posibility for preferece extention)

The RESTful API
A representational state transfer api. Is in fact the brain of the project. Here is most data formatted and all data extracted from the databases. The api has more than 10 calls, which all retrieve different data.

The scraper
Is schedualed every hour and parses the data, which it saves in the mysql databases. Also logs other useful info and sends text (if there are any credits...)

The site
contains 7 htmls, some data and few javascripts. The following htlms are there:
* Home page
* Visualization page
* sms service page
* Api request page
* Data base to table page
* predict price page
* contact page
All pages are pretty self explanetory.

### the visuals

There are four visuals, one main view, two linked and one extra. All give info about the boring data from kamernet. All is better then the boring

repository: FlorisFok/DataVisualisation

repo_name: FlorisFok/DataVisualisation


text:
---
layout: post
title: "SpongeBob SquarePants"
description: "The character-driven cartoon chronicles the nautical and often nonsensical adventures of SpongeBob, an incurably optimistic and earnest sea sponge, and his underwater friends. Dwelling a few fathoms beneath the tropical isle of Bikini Atoll in the sub-surface city of Bikini Bottom, SpongeBob lives in a two-story pineapple. Instead of taking the logical approach to everyday challenges, SpongeBob approaches life .."
img: 0206512.jpg
kind: tv series
genres: [Animation,Comedy,Family,Fantasy]
tags: Animation Comedy Family Fantasy
year: 1999
imdb_rating: 8.1
votes: 80183
imdb_id: 0206512
netflix_id: 70155547
color: 472d30
---
Director: `N/A`

Cast: `Tom Kenny` `Bill Fagerbakke` `Rodger Bumpass` `Clancy Brown` `Mr. Lawrence`

Spongebob Squarepants is a cartoon about a yellow sponge named Spongebob Squarepants who lives underwater in the Pacific Ocean in a two story pineapple house in a town called Bikini Bottom with his neighbor Squidward Tentacles and his best friend Patrick Star. He works at the Krusty Krab, the most popular restaurant in Bikini Bottoms, as a chef who cooks their most famous burger, The Krabby Patty. With his job in the Krusty Krab, Spongebob meets new characters such as his crazy boss named Eugene Krabs who is in love with money and Plankton, a tiny sea creature who is determined to steal the Krabby Patty formula and make his restaurant more famous! Spongebob goes through crazy adverntures with his best friend Patrick and Mrs. Puff his boarding school teacher who is always going through some trouble when a Spongebob sits behind the wheel. But with his humorous and optimistic attitude, it doesn't even matter anymore because spongebob makes an amazing and fun character!

repository: meparth/BongNetflix

repo_name: meparth/BongNetflix


text:
# Osiris Mapviewer for Android

## Introduction

This code contains an Android demo application for visualizing indoor areas using
the Osiris platform. The application, uses Mapsforge (https://github.com/mapsforge/mapsforge)
for displaying the background map image in the mobile device. Uses the overlay drawing
capabilities for displaying the different levels of the buildings.

## Configuration

The configuration parameters are set using Android resources files. Specifically,
the file "values/strings.xml" is used for loading the configuration.

The main configuration parameters that need to be set in the application are the following:

- Environment, set using the attribute name *osiris_app_host*, for instance

  `<string name="app_host">http://myserver.com/osiris</string>`

- Application ID, set by the attribute *osiris_app_id*

  `<string name="app_id">myOsirisApplication</string>`

The application will load this configuration at startup and download the map and indoor
information if necessary.

Also, the configuration of the URLs for the different osiris services can be found in
the file `OsirisEndpoint.java`

repository: afleshel/mapviewer-android

repo_name: afleshel/mapviewer-android


text:
# .img (Work In Progress!)
.img (pronounced “dot image”) is a powerful and versatile, yet easy to use image composer.
Check out the [Live Demo](http://bonjourinternet.top/lab/dotimg/index.html)!

## How does it work?
Simply open the directory with Firefox, and launch index.html! (there are some limitations to this tool on Chrome and other webkit browsers such as explained below)

The main idea behind this tool is to provide a complete "clone to go" html interface to create composed pictures such as flyers or promotion materials. Start by putting pictures in your collection, those will appear on thumbnails in the _dotimg interface_. Crop them as will, or apply some effects then put them on your composition to render your picture. You can use presets (image size, disposition, colors, font, ...) to quickly create a series of matching compositions.

### Collection
Your collection stands for all the files that you've added to the browser via the interface

### Settings and presets
(coming soon)

### Composition
(coming soon)

### Preloaded collection
It is possible to add custom pictures to your collection, those pictures will be loaded each time you load the page, thus saving tremendous amount of time working with logos or other type of recurring material.
Simply add pictures in the *presets/collection* directory then push the array in the *presets/collection.js*, it's as simple as that! You can also add custom fonts using the same principle.

## Chrome/Opera/Safari (webkit) issues
Webkit browsers do have security issue with a particular function I am using to display the collection in the "fill section". This is due to the fact the you cannot use a ressource you've loaded into memory as a styled element (using the [toDataURL() method](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toDataURL)). This means that you won't be able to see the which collection item you're going to fill your shape with, I took a screenshot explaining that issue.

This is what it looks like on Firefox (and should look like on any well coded browser)

![Normal display](http://bonjourinternet.top/upload/_imgonff.png "Normal Display")

On webkit browsers

![Webkit display](http://bonjourinternet.top/upload/_img_wkitbug.png "Webkit Display")

## Changelog
* v0.0.1
  * Got rid of normalize.css

## Todo list
* Add the default image size & background color as a variable in the presets
* Create the preset loading feature
* Export feature (save image as .png/.jpg)
* Save the collection in browser memory (localStorage)
* Remove image from the collection
* Add filters (greyscale, blur, ...) to collection items
* Add a colorpicker

## Credits
* Dosis, Oswald, Kurale (fonts) under the [Open Font License (OFL)](http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL)

Because I mainly work on this for fun in my free time, bugfixes and features development are subject to delays.


text:
# Cryptography frequently useful commands

* read .crt files

```bash
openssl x509 -in /path/to/some.crt -text -noout
```

* view the certificate served by server

```bash
openssl s_client -showcerts -connect google.com:443
```

repository: tomklino/cheat-sheets

repo_name: tomklino/cheat-sheets


text:
# barista

_The backend API server for [uwcoffeencode.com](https://uwcoffeencode.com)_

[![Build Status][drone-img]][drone]

## Usage

### Public API

The public API is served at
[api.uwcoffeencode.com](https://api.uwcoffeencode.com).
This is the address that internal and external applications will use to
fetch Coffee 'N Code-related data.

Some information can only be accessed by **authenticated** clients.
To authenticate, a user must perform a `login` mutation:

```graphql
mutation Login($username: String!, $password: String!) {
  login(input: { username: $username, password: $password }) {
    user {
      id
    }
  }
}
```

Only first-party browser clients may authenticate with the API and
read/update private data; third-party browser clients may only make use of
public data.

### Administration

The admin console is served at
[barista.uwcoffeencode.com](https://barista.uwcoffeencode.com). Staff users
(i.e. us) can login and securely manage backend data without direct database
access.

<br />

## Development

### Setup

> Make sure you have [`pyenv`](https://github.com/pyenv/pyenv),
> [`pipenv`](https://pypi.org/project/pipenv/),
> [Docker](https://docs.docker.com/get-docker/), and
> [Docker Compose](https://docs.docker.com/compose/) installed.

1. Clone and enter the repo:

   ```bash
   git clone git@github.com:UWCoffeeNCode/barista && \
   cd barista
   ```

2. Install dependencies:

   ```bash
   # Install dependencies from `Pipfile.lock`:
   pipenv sync
   ```

3. Configure `.env`:

   ```bash
    # Copy env values from example template:
    cp .env.example > .env

    # Edit to use real values:
    vi .env
   ```

### Workflow

To get started, go ahead and do the following:

```bash
# Launch external systems (database, etc.):
docker-compose up -d

# Run database migrations:
python manage.py migrate

# Run the server (development):
python manage.py runserver
```

Some useful commands include:

```bash
# Run the shell (administration):
python manage.py shell
```

[drone]: https://ci.stevenxie.me/UWCoffeeNCode/barista
[drone-img]: https://ci.stevenxie.me/api/badges/UWCoffeeNCode/barista/status.svg

repository: UWCoffeeNCode/barista

repo_name: UWCoffeeNCode/barista


text:
## Proposed changes

Please explain the changes you made. Add pictures or videos to explain them better if appropiate.

## Types of changes

What types of changes does your code introduce?

- [ ] Bugfix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)

## Checklist

Put an x in the boxes that apply. You can also fill these out after creating the PR. This is a reminder of what we should look for before merging this code. I have:

- [ ] Read and follow the [contributing guidelines](https://github.com/shadow-robot/sr_documentation/blob/master/CONTRIBUTING.md).
- [ ] Checked that all tests pass with my changes
- [ ] Added tests (automatic or manual) that prove the fix is effective or that the feature works
- [ ] Added necessary documentation (if appropriate)
- [ ] Added the corresponding license to each file and add the current year of any one that you modified.
- [ ] Tested on real hardware (if appropriate)

branch_name: refs/heads/kinetic-devel


text:
---

title: "Vibration Modes in a T beam"
date: 2018-02-21
tags: [Aerospace Engineering]
header:
  image: "/images/vibrations.jpg"
excerpt: "Engineering Projects, Aerospace Engineering, Data Analysis"

---

# Summary

This report investigates the vibrational response of T-beam structure, which can be regarded as a simplified aircraft fuselage tail-plane model. The first 6 natural frequencies of the structure will be determined. Assigned to us were individual tasks associated with the modelling of predicted mode shapes using theoretical principles. Each of the group members produced estimations of the respective mode shapes and derived a row of the flexibility matrix. The estimation methods were compared against each other to determine the best technique.

## Introduction

Vibration is a topic that applies to a multitude of engineering applications. Developing an understanding through its theoretical and experimental analysis is vital. Across an abundance of industries the failure to mitigate against large energy transfers, with the correspondence of resonant frequencies, can result in the catastrophic failure/degradation of projects. An example of which is the Tacoma Narrows Suspension Bridge, in which wind induced vibrations led to oscillations at its fundamental mode and therefore the collapse of a multi-million dollar project.

This Vibrations lab revolves itself around experimentally testing and analysing the vibrational response of T-beam structure. Accelerometers recorded data over 32 points of the T-beam which was mechanically excited with a hammer. T-beam was approximated as a 6 degree of freedom model to give a basis of theoretical prediction. Each row of the flexibility matrix was calculated and the mass matrix of the T-beam was constructed.  After the accumulation of data, Matlab codes were constructed to both predict and investigate the beams 6 mode shapes, Frequency Response Functions (FRF’s) and 6 natural frequencies.

Comparisons with in this report will be made between the predicted and experimental data. These will be justified using fundamental engineering principles that will help to validate/ invalidate the experimental data that was acquired. These engineering principles include the derivation of the equations of motion, the load sharing approach employed to construct the mass matrix, torsional effects present at the extremities of the beam and the eigenvalue problem used to evaluate the natural frequencies. These concepts will be investigated further in the sections to follow.

## Theory

The vibration of the metal T beam outlined previously can be modeled using a Multiple Degree of Freedom system. Through employing a load sharing approach, with the associated mass distributions across the T beam, the flexibility matrix [a] and the dynamic matrix [D] can be calculated.

## Equations of Motion

The equations of motion are required here to outline model the vibratory response of the T beam. They can be derived through 3 separate methods: Newton’s equation of motion, Lagrange’s method or through the use of the Stiffness and Flexibility influence coefficients. Newton’s method will be outlined with a 2 Degree of Freedom model to exhibit the consecutive stages of the derivation.

Each respective mass can be isolated the forces acting are equated.

For the first mass newton’s second law of motion is applied with the external force f(t) applied.

Likewise for the second mass.

Combining the equations yields the following:

This is the equation of motion. Each matrix can be simplified to give the more commonly  equation.

Where the derivatives of x are the acceleration vector, velocity vector respectively. x is the displacement vector and F is the force vector.

## The Flexibility Matrix [K]

The viscous damping and force vector are set to zero within the T beam analysis. After inserting the mass matrix [M] for the beam, the stiffness matrix [k] must be obtained. The term k(ij) represents the force at point i due to a unit displacement at point j with all other points fixed.  This term is the inverse of the “flexibility influence coefficient”.

[a] ([k]=〖[a]〗^(-1))

A term that eludes to the deflection at point i due to a unit force acting at point j (where the unit force is the only force acting). The flexibility coefficient is therefore calculated.

The technique adopted in calculating the flexibility coefficient varied between students. The most predominantly employed was the beam myosotis table.

## The Mass Matrix [M]

The mass matrix of the T beam was determined through attributing the beam into 6 points of mass, each with its individual degree of freedom. A technique described as the discritisation of a continuous system (or distributed parameter system).

After acquiring the density and respective areas for the beams the mass was assigned into its components necessary to form the matrix. A nodal point is assigned to the joint of the beam but is neglected in the formation of the mass matrix.

The nodal point mass distribution for the T beam is represented in the following two diagrams.

The mass breakdown for the specific T beam in question is as follows:

The mass of beam A was divided into 4 sub-sections, a quarter of the mass was attributed to node 1, 2 and 3.  An eighth of the remaining mass was located at the support point of the cantilever ( m_(0 )) and the other eighth was assigned to the node point 4 (at an intersection with point B).

Likewise beam B was divided into 4 sub-sections.

One half of the mass was attributed to node point 4 (in addition to the contribution from A) and the remaining quarters assigned to nodes 5 & 6 at the extremities.

The overall Mass matrix is given as:

## The Eigenvalue Problem

With the following parameters set to zero:

The equations of motion can be re-written in the form written below, describing a 2nd order ODE.

The steady state solution of which can be expressed in the form:

Where X* represents a complex vector with amplitude and phase.

Plugging back into equation [5] yields.

This can be rearranged into.

Therefore for non-trivial solutions.

An equation with a polynomial in ω^2. Each of the roots of the equation provide the natural frequencies/ eigenvalues.