text:
This plugin is a geofence service with activity recognition API. It does not use the Geofence API implemented on the platform. Therefore, battery efficiency cannot be guaranteed. Instead, this plugin can provide more accurate and realtime geo-fencing by navigating your location while your app is alive.

[![pub package](https://img.shields.io/pub/v/geofence_service.svg)](https://pub.dev/packages/geofence_service)

## Features

* `Geofence` can have multiple radius.
* `Geofence` can see what activity took place when the device entered the radius.
* `GeofenceService` can perform geo-fencing in real time and catch errors during operation.
* `GeofenceService` can be operated in the background using `WillStartForegroundTask` widget.

**WAIT**: This plugin performs geo-fencing based on a circular geofence. If you want to create a polygon geofence, this [plugin](https://pub.dev/packages/poly_geofence_service) is recommended.

## Getting started

To use this plugin, add `geofence_service` as a [dependency in your pubspec.yaml file](https://flutter.io/platform-plugins/). For example:

```yaml
dependencies:
  geofence_service: ^3.3.1
```

After adding the `geofence_service` plugin to the flutter project, we need to specify the platform-specific permissions and services to use for this plugin to work properly.

### :baby_chick: Android

Since geo-fencing operates based on location, we need to add the following permission to the `AndroidManifest.xml` file. Open the `AndroidManifest.xml` file and specify it between the `<manifest>` and `<application>` tags.

```
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
```

If you want to run the service in the background, add the following permission. If your project supports Android 10, be sure to add the `ACCESS_BACKGROUND_LOCATION` permission.

```
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
```

And specify the service inside the `<application>` tag as follows.

```
<service
    android:name="com.pravera.flutter_foreground_task.service.ForegroundService"
    android:foregroundServiceType="location"
    android:stopWithTask="true" />
```

The biggest feature of this plugin is that it can know user activity while geo-fencing. Please specify the permission usage in `<manifest>` tag.

```
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
```

### :baby_chick: iOS

Like Android platform, geo-fencing is based on location, we need to add the following description. Open the `ios/Runner/Info.plist` file and specify it inside the `<dict>` tag.

```
<key>NSLocationWhenInUseUsageDescription</key>
<string>Used to provide geofence service.</string>
```

If you want to run the service in the background, add the following description.

```
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>Used to provide geofence services in the background.</string>
<key>NSLocationAlwaysUsageDescription</key>
<string>Used to provide geofence services in the background.</string>
<key>UIBackgroundModes</key>
<array>
    <string>fetch</string>
    <string>location</string>
</array>
```

To detect changes in user activity, add the following description.

```
<key>NSMotionUsageDescription</key>
<string>Used to recognize user activity information.</string>
```

## How to use

1. Create a `GeofenceService` instance and set options. `GeofenceService.instance.setup()` provides the following options:
* `interval`: The time interval in milliseconds to check the geofence status. The default is `5000`.
* `accuracy`: Geo-fencing error range in meters. The default is `100`.
* `loiteringDelayMs`: Sets the delay between `GeofenceStatus.ENTER` and `GeofenceStatus.DWELL` in milliseconds. The default is `300000`.
* `statusChangeDelayMs`: Sets the status change delay in milliseconds. `GeofenceStatus.ENTER` and `GeofenceStatus.EXIT` events may be called frequently when the location is near the boundary of the geofence. Use this option to minimize event calls at this time. If the option value is too large, realtime geo-fencing is not possible, so use it carefully. The default is `10000`.
* `useActivityRecognition`: Whether to use the activity recognition API. The default is `true`.
* `allowMockLocations`: Whether to allow mock locations. The default is `false`.
* `printDevLog`: Whether to show the developer log. If this value is set to true, logs for geofence service activities (start, stop, etc.) can be viewed. It does not work in release mode. The default is `false`.
* `geofenceRadiusSortType`: Sets the sort type of the geofence radius. The default is `GeofenceRadiusSortType.DESC`.

```dart
// Create a [GeofenceService] instance and set options.
final _geofenceService = GeofenceService.instance.setup(
    interval: 5000,
    accuracy: 100,
    loiteringDelayMs: 60000,
    statusChangeDelayMs: 10000,
    useActivityRecognition: true,
    allowMockLocations: false,
    printDevLog: false,
    geofenceRadiusSortType: GeofenceRadiusSortType.DESC);
```

2. Create a `Geofence` and `GeofenceRadius` list. `Geofence` and `GeofenceRadius` provides the following parameters:
* `id`: Identifier for `Geofence` and `GeofenceRadius`.
* `data`: Custom data for `Geofence` and `GeofenceRadius`.
* `latitude`: The latitude of geofence center.
* `longitude`: The longitude of geofence center.
* `radius`: The radius of `Geofence`.
* `length`: The length of the radius in meters. The best result should be set between 100 and 150 meters in radius. If Wi-FI is available, it can be set up to 20~40m.

```dart
// Create a [Geofence] list.
final _geofenceList = <Geofence>[
  Geofence(
    id: 'place_1',
    latitude: 35.103422,
    longitude: 129.036023,
    radius: [
      GeofenceRadius(id: 'radius_100m', length: 100),
      GeofenceRadius(id: 'radius_25m', length: 25),
      GeofenceRadius(id: 'radius_250m', length: 250),
      GeofenceRadius(id: 'radius_200m', length: 200),
    ],
  ),
  Geofence(
    id: 'place_2',
    latitude: 35.104971,
    longitude: 129.034851,
    radius: [
      GeofenceRadius(id: 'radius_25m', length: 25),
      GeofenceRadius(id: 'radius_100m', length: 100),
      GeofenceRadius(id: 'radius_200m', length: 200),
    ],
  ),
];
```

3. Register the listener and call `GeofenceService.instance.start()`.

```dart
// This function is to be called when the geofence status is changed.
Future<void> _onGeofenceStatusChanged(
    Geofence geofence,
    GeofenceRadius geofenceRadius,
    GeofenceStatus geofenceStatus,
    Location location) async {
  print('geofence: ${geofence.toMap()}');
  print('geofenceRadius: ${geofenceRadius.toMap()}');
  print('geofenceStatus: ${geofenceStatus.toString()}');
  _geofenceStreamController.sink.add(geofence);
}

// This function is to be called when the activity has changed.
void _onActivityChanged(Activity prevActivity, Activity currActivity) {
  print('prevActivity: ${prevActivity.toJson()}');
  print('currActivity: ${currActivity.toJson()}');
  _activityStreamController.sink.add(currActivity);
}

// This function is to be called when the location has changed.
void _onLocationChanged(Location location) {
  print('location: ${location.toJson()}');
}

// This function is to be called when a location services status change occurs
// since the service was started.
void _onLocationServicesStatusChanged(bool status) {
  print('isLocationServicesEnabled: $status');
}

// This function is used to handle errors that occur in the service.
void _onError(error) {
  final errorCode = getErrorCodesFromError(error);
  if (errorCode == null) {
    print('Undefined error: $error');
    return;
  }

  print('ErrorCode: $errorCode');
}

@override
void initState() {
  super.initState();
  WidgetsBinding.instance?.addPostFrameCallback((_) {
    _geofenceService.addGeofenceStatusChangeListener(_onGeofenceStatusChanged);
    _geofenceService.addLocationChangeListener(_onLocationChanged);
    _geofenceService.addLocationServicesStatusChangeListener(_onLocationServicesStatusChanged);
    _geofenceService.addActivityChangeListener(_onActivityChanged);
    _geofenceService.addStreamErrorListener(_onError);
    _geofenceService.start(_geofenceList).catchError(_onError);
  });
}
```

4. Add `WillStartForegroundTask` widget for background execution on Android platform. `WillStartForegroundTask` provides the following options:
* `onWillStart`: Called to ask if you want to start the foreground task.
* `notificationOptions`: Optional values for notification detail settings.
* `notificationTitle`: The title that will be displayed in the notification.
* `notificationText`: The text that will be displayed in the notification.
* `child`: A child widget that contains the `Scaffold` widget.

```dart
@override
Widget build(BuildContext context) {
  return MaterialApp(
    // A widget used when you want to start a foreground task when trying to minimize or close the app.
    // Declare on top of the [Scaffold] widget.
    home: WillStartForegroundTask(
      onWillStart: () {
        // You can add a foreground task start condition.
        return _geofenceService.isRunningService;
      },
      notificationOptions: NotificationOptions(
        channelId: 'geofence_service_notification_channel',
        channelName: 'Geofence Service Notification',
        channelDescription: 'This notification appears when the geofence service is running in the background.',
        channelImportance: NotificationChannelImportance.LOW,
        priority: NotificationPriority.LOW,
      ),
      notificationTitle: 'Geofence Service is running',
      notificationText: 'Tap to return to the app',
      child: Scaffold(
        appBar: AppBar(
          title: const Text('Geofence Service'),
          centerTitle: true,
        ),
        body: _buildContentView(),
      ),
    ),
  );
}
```

5. To add or remove `Geofence` while the service is running, use the following function:

```text
_geofenceService.addGeofence(Object);
_geofenceService.addGeofenceList(List);
_geofenceService.removeGeofence(Object);
_geofenceService.removeGeofenceList(List);
_geofenceService.removeGeofenceById(String);
_geofenceService.clearGeofenceList();
```

6. If you want to pause or resume the service, use the function below.

```text
_geofenceService.pause();
_geofenceService.resume();
```

7. When you are finished using the service, unregister the listener and call `GeofenceService.instance.stop()`.

```text
_geofenceService.removeGeofenceStatusChangeListener(_onGeofenceStatusChanged);
_geofenceService.removeLocationChangeListener(_onLocationChanged);
_geofenceService.removeLocationServicesStatusChangeListener(_onLocationServicesStatusChanged);
_geofenceService.removeActivityChangeListener(_onActivityChanged);
_geofenceService.removeStreamErrorListener(_onError);
_geofenceService.clearAllListeners();
_geofenceService.stop();
```

**Note**: When calling the stop function, the listener is not removed, but the added geofence is cleared.

## Models

### :chicken: Geofence

A model representing a geofence.

| Property | Description |
|---|---|
| `id` | Identifier for `Geofence`. |
| `data` | Custom data for `Geofence`. |
| `latitude` | The latitude of geofence center. |
| `longitude` | The longitude of geofence center. |
| `radius` | The radius of `Geofence`. |
| `status` | The status of `Geofence`. |
| `timestamp` | The timestamp of `Geofence`. |
| `remainingDistance` | The remaining distance to the destination. |

### :chicken: GeofenceRadius

A model representing the radius of `Geofence`.

| Property | Description |
|---|---|
| `id` | Identifier for `GeofenceRadius`. |
| `data` | Custom data for `GeofenceRadius`. |
| `length` | The length of the radius in meters. |
| `status` | The status of `GeofenceRadius`. |
| `activity` | The user activity when geofence status changes. |
| `speed` | The passing speed when geofence status changes. |
| `timestamp` | The timestamp when geofence status changes. |
| `remainingDistance` | The remaining distance to the radius. |

### :chicken: GeofenceStatus

Defines the type of the geofence status.

| Value | Description |
|---|---|
| `ENTER` | Occurs when entering the geofence radius. |
| `EXIT` | Occurs when exiting the geofence radius. |
| `DWELL` | Occurs when the loitering delay elapses after entering the geofence area. |

### :chicken: Activity

A model representing the user's activity.

| Property | Description |
|---|---|
| `type` | The type of activity recognized. |
| `confidence` | The confidence of activity recognized. |

### :chicken: ActivityType

Defines the type of activity.

| Value | Description |
|---|---|
| `IN_VEHICLE` | The device is in a vehicle, such as a car. |
| `ON_BICYCLE` | The device is on a bicycle. |
| `RUNNING` | The device is on a user who is running. This is a sub-activity of ON_FOOT. |
| `STILL` | The device is still (not moving). |
| `WALKING` | The device is on a user who is walking. This is a sub-activity of ON_FOOT. |
| `UNKNOWN` | Unable to detect the current activity. |

### :chicken: ActivityConfidence

Defines the confidence of activity.

| Value | Description |
|---|---|
| `HIGH` | High accuracy: 75~100 |
| `MEDIUM` | Medium accuracy: 50~75 |
| `LOW` | Low accuracy: 0~50 |

### :chicken: GeofenceRadiusSortType

Defines the sort type of the geofence radius. If you have set multiple radius for one geofence, multiple radius can come in at the same time. At this time, you can control the order in which the radius comes in by referring to the radius meters.

| Value | Description |
|---|---|
| `ASC` | Sort the meters in ascending order. |
| `DESC` | Sort the meters in descending order. |

### :chicken: ErrorCodes

Error codes that may occur in the service.

| Value | Description |
|---|---|
| `ALREADY_STARTED` | Occurs when the service has already been started but the start function is called. |
| `LOCATION_SERVICES_DISABLED` | Occurs when location services are disabled. When this error occurs, you should notify the user and request activation. |
| `LOCATION_PERMISSION_DENIED` | Occurs when location permission is denied. |
| `LOCATION_PERMISSION_PERMANENTLY_DENIED` | Occurs when location permission is permanently denied. In this case, the user must manually allow the permission. |
| `ACTIVITY_RECOGNITION_PERMISSION_DENIED` | Occurs when activity recognition permission is denied. |
| `ACTIVITY_RECOGNITION_PERMISSION_PERMANENTLY_DENIED` | Occurs when activity recognition permission is permanently denied. In this case, the user must manually allow the permission. |

## Support

If you find any bugs or issues while using the plugin, please register an issues on [GitHub](https://github.com/Dev-hwang/geofence_service/issues). You can also contact us at<EMAIL_ADDRESS>


text:
## Changes

* Adds `%mark` in the window `title_format`.
  This shows only the *first* mark (if any).
* XBM icons in window decorations: https://github.com/ashinkarov/i3-extras#icons-in-i3bar
  * icons scaled to window decoration height
  * support `%icon` in the window `title_format` (so you could display the window icon multiple times if you wanted).
* More consistent vertical text centering for window `title_format` (based on font baseline).
* Changes to handling of floating windows:
  * Transient floating windows are shown on the *same* workspace as their parent (and vice-versa).
    This also means moving a window across workspaces also moves the transient parent and/or the floating child windows.
  * Transient floating windows appear above everything *only if* they, their parent or a floating child is focused.
    So a floating dialog for an unfocused window will be shown below a non-floating window that is focused.
    Floating windows are shown in the order of the transient relationship,
    i.e. transient parents are shown before their children.

## Original README

![Logo](docs/logo-30.png) i3: A tiling window manager
=====================================================

[![Build Status](https://github.com/i3/i3/actions/workflows/main.yml/badge.svg)](https://github.com/i3/i3/actions/workflows/main.yml)
[![Issue Stats](https://img.shields.io/github/issues/i3/i3.svg)](https://github.com/i3/i3/issues)
[![Pull Request Stats](https://img.shields.io/github/issues-pr/i3/i3.svg)](https://github.com/i3/i3/pulls)

[![Packages](https://repology.org/badge/latest-versions/i3.svg)](https://repology.org/metapackage/i3/versions)
[![Packages](https://repology.org/badge/tiny-repos/i3.svg)](https://repology.org/metapackage/i3/versions)

i3 is a tiling window manager for X11.

For more information about i3, please see [the project's website](https://i3wm.org/) and [online documentation](https://i3wm.org/docs/).

For information about contributing to i3, please see [CONTRIBUTING.md](.github/CONTRIBUTING.md).

branch_name: refs/heads/master

extension: md

gha_language: C

gha_license_id: NOASSERTION

license_type: permissive


text:
---
layout: post
title: "Controlling Posture of Jumping Articulated Robot for Stable Landing"
featured-img: simulation_motion
---

# What I did

- ***Skill*** : Matlab, Simulink, C

- ***Keywords*** : Feedback linerization, Gain optimization with Greedy Algorithm, Passive decomposition, Robust Passivity-based control

From March 2017 to December 2017, I researched about jumping robot's control at INROL(Interactive & Networed RObotics Lab). While I was working on this project, I focused on control for nonholonomic systems, under-actuated systems, and hybrid system.

My first research objective was to design a control framework for a jumping robot’s stable landing to keep going. To tackle this under-actuated nonlinear system, I implemented partial feedback linearization with precise modeling and time-varying feedback control to utilize angular momentum conservation. Moreover, by considering the practical constraints of jumping, such as joint limits and short flight duration, I suggested optimal control algorithms via the gradient descent method.

Finally, my findings proposed a stable posture control frame that takes into account features of jumping such as the limit of joint angle range or the short duration of a flight.

# Sum up Slides

With this topic, I published a conference paper for the 2018 IEEE Conference on Ubiquitous Robots (UR) and presented it as a spotlight talk at the conference. After this work, I continued further to study passive configuration decomposition and passivity based stabilization control for nonholonomic systems.

After this work, I continued to study a decomposition method and robust/adaptive passivity-based control further to tackle the complicated model easily and robustly.

license: MIT


text:
# Installation

You can have a development working setup using one of the following methods:

* Manual Installation (last tested: 01/11/2019)
* Docker Installation (last tested: June 2017)

Please provide feedback opening a ticket if these instructions are failing.

## Manual Installation

We will assume you are installing every Hypermap Registry component (web application, search engine, RDBMS and task queue) on a single server, but they can be installed on different servers as well.

### Requirements

We are assuming a Ubuntu 16.04.1 LTS development environment, but these instructions can be adapted to any recent Linux distributions.

Install the requirements:

```sh
sudo apt-get update
sudo apt-get install gcc postgresql rabbitmq-server python-virtualenv git python-psycopg2 libjpeg-dev python-dev libxml2-dev libxslt-dev libxslt1-dev libpq-dev libgeos-dev memcached libmemcached-dev
```

### RDBMS

As the database, we recommend to use PostgreSQL, but any RDBMS supported by Django can be used.

Create PostgreSQL database:

```sh
sudo -i -u postgres
psql
CREATE ROLE hypermap WITH SUPERUSER LOGIN PASSWORD 'hypermap';
CREATE DATABASE hypermap WITH OWNER hypermap;
postgres=# \q
```

### Search Engine

Now you need to install a search engine, which can be Solr or Elasticsearch. Both of them require Java.

Install java8:
```sh
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java8-installer
```

Now follow the instrcutions for Solr or Elasticsearch, depending on your scenario.

#### Solr (Recommended)

Install and start Solr, and create the hypermap schema:

```sh
export SOLR_VERSION=7.3.0
cd /opt
sudo wget http://archive.apache.org/dist/lucene/solr/$SOLR_VERSION/solr-$SOLR_VERSION.tgz
sudo tar xzf solr-$SOLR_VERSION.tgz solr-$SOLR_VERSION/bin/install_solr_service.sh --strip-components=2
sudo ./install_solr_service.sh solr-$SOLR_VERSION.tgz
sudo -u solr solr/bin/solr create -c hypermap
# in older version than 7.5.0: sudo -u solr solr/bin/solr config -c hypermap -p 8983 -property update.autoCreateFields -value false
sudo -u solr solr/bin/solr config -c hypermap -p 8983 -action set-user-property -property update.autoCreateFields -value false
```

#### Elasticsearch

Install and start Elasticsearch:

```sh
wget -qO - https://packages.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb https://packages.elastic.co/elasticsearch/2.x/debian stable main" | sudo tee -a /etc/apt/sources.list.d/elasticsearch-2.x.list
sudo apt-get update && sudo apt-get install elasticsearch
sudo sed -i -e 's/#ES_HEAP_SIZE=2g/ES_HEAP_SIZE=1g/' /etc/default/elasticsearch
sudo service elasticsearch start
```

TODO explain how to create a schema in Elasticsearch.

#### Web Application

Install Hypermap, which is a web application based on Django, using a virtual environment.

```sh
cd ~
virtualenv --no-site-packages env
source env/bin/activate
git clone https://github.com/cga-harvard/Hypermap-Registry.git
cd Hypermap-Registry
pip install -r requirements.txt
```

To set the environment variables, create an env_vars and copy and paste the lines below to the end (change the lines according to your configuration)

```sh
export DATABASE_URL=postgres://hypermap:hypermap@localhost:5432/hypermap
export BROKER_URL=amqp://guest:guest@localhost:5672/
export CACHE_URL=memcached://localhost:11211/
export BASE_URL=http://localhost
export ALLOWED_HOSTS=['localhost',]
export REGISTRY_SEARCH_URL=solr+http://localhost:8983
export REGISTRY_CHECK_PERIOD=120
export REGISTRY_SKIP_CELERY=False
export REGISTRY_LIMIT_LAYERS=0
export REGISTRY_INDEX_CACHED_LAYERS_PERIOD=1
export REGISTRY_HARVEST_SERVICES=True
export C_FORCE_ROOT=1
export CELERY_DEFAULT_EXCHANGE=hypermap
```

Source the env_vars file

```
source env_vars
```

Execute migrations, which will generate the schema in the database:

```sh
python manage.py migrate
```

Finally, load fixtures
```sh
python manage.py loaddata hypermap/aggregator/fixtures/catalog_default.json
python manage.py loaddata hypermap/aggregator/fixtures/user.json
```

If using Solr, update the schema:

```sh
python manage.py solr_scheme
```

Run the Django server:

```
python manage.py runserver <IP_ADDRESS>:8000
```

#### Celery and RabbitMQ

Using another shell, start rabbitmq and the Celery process after activating the virtualenv:

```
sudo service rabbitmq-server start
cd HHypermap
celery -A hypermap worker --beat --scheduler django -l info
```

You may need to create a vhost and a user in RabbitMQ. For example, if the value for BROKER_URL is amqp://guest:guest@localhost:5672/

```
sudo rabbitmqctl add_vhost hypermap
sudo rabbitmqctl add_user hypermap hypermap
sudo rabbitmqctl set_user_tags hypermap administrator
sudo rabbitmqctl set_permissions -p hypermap ".*" ".*" ".*"
```

Now if you browse to http://localhost:8000, Hypermap should be up and running.

## Docker Installation

You can have an Hypermap Registry instance up and running using Docker.

Install Docker and Docker Compose:

```
wget https://get.docker.com/builds/Linux/x86_64/docker-latest.tgz
tar -xvzf docker-latest.tgz
sudo mv docker/* /usr/bin/
curl -L https://github.com/docker/compose/releases/download/1.8.0/docker-compose-`uname -s`-`uname -m` > docker-compose
chmod +x docker-compose
sudo mv docker-compose /usr/bin/
sudo usermod -aG docker $(whoami)
```

### Increase virtual memory map area (Linux)

```
sudo sysctl -w vm.max_map_count=262144
```

### Run docker in daemon

```sh
sudo dockerd
```

### Deployment of hhypermap within docker

```sh
git clone https://github.com/cga-harvard/Hypermap-Registry.git
cd Hypermap-Registry
make up
make sync
```
For Ubuntu:
```
make up .
make sync
```
Wait for the instance to be provisioned (about 3/4 minutes).

Then connect to: http://localhost/registry and your instance should be up and running.

You can edit the files with your IDE from your host, as the directory /code on the guest is synced with your host. Make sure to check the ```REGISTRY_SKIP_CELERY``` environment variable is set to False for debugging. If this value is set to False, it is always necessary to restart the celery container executing

```sh
docker-compose restart celery
```

## Running Hypermap in production

When running Hypermap in production it is highly recommended to use a proper web sever (nginx or Apache httpd) in place of the Django server.

You can find a sample configuration for nginx and uwsgi in the config directory (nginx_sample and uwsgi_sample files).

In case you want to automate this, there are ansible script for the deployment in the deploy/ansible directory (which need to be updated).

Here is how you can deploy Hypermap Registry using nginx and uwsgi in Ubuntu 16.04 LTS.

Install requirements:

```sh
sudo apt install nginx supervisor
```

### wsgi configuration

Create a wsgi .ini file to run the Hypermap application, for example /home/ubuntu/hypermap.ini. Copy in it the content from hyperma/config/uwsgi_config and adapt it to your needs. Make sure it correctly works by running:

```sh
/home/ubuntu/env/bin/uwsgi --ini hypermap.ini
```

Now create a service for the wsgi process by adding a file in /etc/systemd/system/hypermap.service like this:

```sh
[Unit]
Description=uWSGI instance to serve Hyermap Registry
After=network.target

[Service]
User=ubuntu
Group=www-data
ExecStart=/home/ubuntu/env/bin/uwsgi --ini /home/ubuntu/hypermap.ini

[Install]
WantedBy=multi-user.target
```

To enable the server to start at server boot:

```sh
sudo systemctl enable hypermap.service
```

### nginx configuration

Now create the nginx configuration file in /etc/nginx/sites-enabled/hypermap using the template in hypermap/config/nginx and restart nginx.

### celery/rabbimq configuration

For Celery we will use supervisor in order to run the celery process and the celerybeat process.

Create a supervisor configuration for the celery process in /etc/supervisor/conf.d/celery.conf:

```sh
[program:celery]
command=/home/ubuntu/Hypermap-Registry/config/celery_start.sh

autostart=true
autorestart=true

user=www-data

stdout_logfile=/tmp/celery.log
redirect_stderr = true
```

Create another supervisor configuration for the celerybeat process in /etc/supervisor/conf.d/celerybeat.conf:

```sh
[program:celerybeat]
command=/home/ubuntu/Hypermap-Registry/config/celerybeat_start.sh

autostart=true
autorestart=true

user=www-data

stdout_logfile=/tmp/celerybeat.log
redirect_stderr = true
```

Now if you restart supervisor (sudo service supervisor restart) you should notice two process running in it:

```sh
sudo supervisorctl
celery                           RUNNING   pid 1717, uptime 0:06:02
celerybeat                       RUNNING   pid 1718, uptime 0:06:02
supervisor>
```

## For developers

### Testing Hypermap Registry

If you want to provide pull requests to Hypermap-Registry, you should make sure that your changes don't break tests before submitting the pull request.

*Unit tests* check the correct functionality of Hypermap workflow when an endpoint is added: some services and their layers are created, then the tests check
 if the correct metadata are harvested and stored in DB and indexed in the search backend.

 To run the unit tests:

```sh
make test-unit
```

*Solr backend tests* check that the Solr search engine implementation works correctly: tests index layers in Solr and test the Hypermap search API is working properly.

```sh
make test-solr
```

*Elasticsearch backend tests* check that the Elasticsearch search engine implementation works correctly: tests index layers in Elasticsearch and test the Hypermap search API is working properly.

```sh
make test-elastic
```

*Selenium Browser tests* emulate the user interaction in Firefox with some basic actions to test the correct functionality of the Django admin site and registry UI. Tests cover the following actions:

 1. admin login (user sessions works as expected)
 2. periodic tasks verifications (automatic periodic tasks are created on startup in order to perform important automatic tasks like check layers, index cached layers on search backend and clean up tasks)
 3. upload endpoint list (file with endpoint list is correctly uploaded and stored in the database, and triggers all harvesting actions like: create endpoints, create services and their layers, index layers in search backend and firsts service checks)
 4. verify creation of endpoint, service and layers
 5. check if the layers created in test are in the search backend url
 6. browser /registry/ (services created are being display to users correctly)
 7. browser service details (check basic service metadata present on the page)
 8. reset service checks (correct functionality should start new check tasks)
 9. create new service checks and verification (trigger the verification tasks and verifies it in service listing page)
 10. browser layers details (check basic service metadata present on the page)
 11. reset layer checks (correct functionality should start new check tasks)
 12. create new layer checks and verification (trigger the verification tasks and verifies it in service layers listing page)
 13. clear index (tests the clean up indice functionality)

To run these tests:

```sh
make test-endtoend-selenium-firefox
```

Selenium and Firefox interaction can be viewed by connecting to VNC protocol, the easiest method is to use Safari.

Just open up Safari and in the URL bar type `vnc://localhost:5900` hit enter and entry `secret` in the password field. Other method is using VNCViever: https://www.realvnc.com/download/viewer/

*CSW-T tests* check the correct functionality of CSW transaction requests.

1. inserts a full XML documents with `request=Transaction` and verifies layers are created correctly. This test use a fixture which can be found here: `data/cswt_insert.xml`
2. verifies the listing by calling  `request=GetRecords` and asserting 10 Layers created.
3. verifies the search by calling `request=GetRecords` and passing a `q` parameter.
4. as that harvesting method also sends the layers to the search backend, a verification is made in order to assert the 10 layers created.

```sh
make - test-csw-transactions
```

To run all tests above in a single command:

```sh
make test
```

#### Style guide enforcement

The modular source code checker for `pep8`, `pyflakes` and `co` runs thanks to `flake8` already installed with the project requirements and can be executed with this command:

```sh
make flake
```

#### Continuos integration

`master` branch is automatically built on https://travis-ci.org/ Travis can be configured in the `.travis.yml` file placed in the project root.

If you want to run tests in your local containers first, execute travis-solo (`pip install travis-solo`) in directory containing .travis.yml configuration file. It’s return code will be 0 in case of success and non-zero in case of failure.

### Translating Hypermap

As a first step, make sure your language files are included in WorldMap. Languages file are in the hypermap/hypermap/locale directory.

If your locale file is not there, you can generate it with the Django makemessages command. For example for Italian:

```
cd ~/hypermap.git
python manage.py makemessages -l it
```

Open the locale file you want to translate, in this case hypermap/hypermap/locale/it/LC_MESSAGES/django.po, and edit the translation strings as needed, for example:

```
#: hypermap/aggregator/templates/aggregator/layer_checks.html:126
#: hypermap/aggregator/templates/aggregator/search.html:11
#: hypermap/aggregator/templates/aggregator/service_checks.html:134
msgid "seconds"
msgstr "secondi"
```

Once you have translated the strings you want, you need to compile them before you see them in the site. For this purpose you can use the Django compilemessages command:

```
python manage.py compilemessages
```

Now if you browse the site you should see your translations correctly in place.

The makemessages and compilemessages needs the GNU gettext toolset to be installed on your computer. For Ubuntu 16.04 LTS this can be done in this way:

```
sudo apt-get install gettext
```

repository: camp-zju/HHypermap

gha_language: JavaScript

gha_license_id: MIT

repo_name: camp-zju/HHypermap


text:
# SMART Health Cards React App

This is a SMART-on-FHIR application built with [React](https://reactjs.org/) that allows a user to log in with Patient Portal credentials and obtain a vaccination record in the form of a SMART Health Card from an electronic health record system's FHIR API. The application was built and tested with the [Cerner Millenium FHIR](https://fhir.cerner.com/) sandbox. It may be used as a template to build apps for verifying and decoding SMART Health Card vaccination records.

## Development Instructions

The following instructions are for developing with the Cerner development environment. However, you can use any FHIR API that supports the $health-cards-issue operation.

You will first need to create an account and register a new SMART-on-FHIR app at https://code.cerner.com. You will need to enter the following options for the app configuration:

- SMART Launch URI: `http://localhost:3000/launch`
- Redirect URI: `http://localhost:3000/app`
- App Type: `Patient`
- Client Type: `Public`
- FHIR Spec: `r4`
- Authorized: `Yes`
- Scopes: Under *Patient Scopes*, choose `Patient` and `Immunization`.

Upon registering an app with the settings above you will be provided with a **Client Id** and FHIR API URL (see **FHIR Spec**). Copy the `.env.sample` file in the project directory to create a new `.env` file and set the environment variables in the file to these values.

Then, in the project directory:

1. Install dependencies by running `npm install`.
2. Start the application in development mode by running `npm start`.
3. Open [http://localhost:3000](http://localhost:3000) to view it in the browser.
4. Login with the username and password of a Cerner sample patient.

repository: vishnuravi/SMART-Health-Card-React

branch_name: refs/heads/main

repo_name: vishnuravi/SMART-Health-Card-React


text:
Vault jumpsuits are the regulation clothing carried by the vault dwellers of [Vault-Tec][vt] [vaults][vault]. They are made of leather, blue with a yellow zipper, and the number of the Vault is on the back of the suit and on the outside of the collar.

[vt]: http://fallout.wikia.com/wiki/Vault-Tec_Corporation
[vault]: http://fallout.wikia.com/wiki/Vault


text:
# Theme Color Styling

__Martin Donath__ a.k.a. __SquidFunc__, the author of the beautiful [MkDocs Material](https://squidfunk.github.io/mkdocs-material/) theme for the famous [MkDocs](https://www.mkdocs.org/) documentation site generator has written a big [Getting Started](https://squidfunk.github.io/mkdocs-material/getting-started/) guide.

I have used this theme and this guide to set up this website with my personal documentation. I was fascinated by the styling section in relation to colors and accents. The big question however was how to achieve the effect of rows of color swatches instead of one long column. I have not figured out how Martin did it on his website. Instead, I have managed to achieve the same by using `<div class="flex-container">` inline in the Markdown document (see the source code of this page in my repo). So, I have included the color sections of the official guide to demo this alternative approach.

## Color palette

A default hue is defined for every primary and accent color on Google's
Material Design [color palette][10], which makes it very easy to change the
overall look of the theme. Just set the primary and accent colors using the
following variables:

``` yaml
theme:
  palette:
    primary: 'indigo'
    accent: 'indigo'
```

Color names are case-insensitive, but must match the names of the Material
Design color palette. Valid values are: `red`, `pink`, `purple`, `deep purple`,
`indigo`, `blue`, `light blue`, `cyan`, `teal`, `green`, `light green`, `lime`,
`yellow`, `amber`, `orange`, `deep orange`, `brown`, `grey`, `blue grey` and
`white`. The last four colors can only be used as a primary color.

If the color is set via this configuration, an additional CSS file that
defines the color palette is automatically included. If you want to keep things
lean, clone the repository and recompile the theme with your custom colors set.

[10]: http://www.materialui.co/colors

## Primary colors

> Default: `indigo`

Click on a tile to change the primary color of the theme:

<button data-md-color-primary="red">Red</button>
<button data-md-color-primary="pink">Pink</button>
<button data-md-color-primary="purple">Purple</button>
<button data-md-color-primary="deep-purple">Deep Purple</button>
<button data-md-color-primary="indigo">Indigo</button>
<button data-md-color-primary="blue">Blue</button>
<button data-md-color-primary="light-blue">Light Blue</button>
<button data-md-color-primary="cyan">Cyan</button>
<button data-md-color-primary="teal">Teal</button>
<button data-md-color-primary="green">Green</button>
<button data-md-color-primary="light-green">Light Green</button>
<button data-md-color-primary="lime">Lime</button>
<button data-md-color-primary="yellow">Yellow</button>
<button data-md-color-primary="amber">Amber</button>
<button data-md-color-primary="orange">Orange</button>
<button data-md-color-primary="deep-orange">Deep Orange</button>
<button data-md-color-primary="brown">Brown</button>
<button data-md-color-primary="grey">Grey</button>
<button data-md-color-primary="blue-grey">Blue Grey</button>
<button data-md-color-primary="white">White</button>

## Accent colors

> Default: `indigo`

Click on a tile to change the accent color of the theme:

<button data-md-color-accent="red">Red</button>
<button data-md-color-accent="pink">Pink</button>
<button data-md-color-accent="purple">Purple</button>
<button data-md-color-accent="deep-purple">Deep Purple</button>
<button data-md-color-accent="indigo">Indigo</button>
<button data-md-color-accent="blue">Blue</button>
<button data-md-color-accent="light-blue">Light Blue</button>
<button data-md-color-accent="cyan">Cyan</button>
<button data-md-color-accent="teal">Teal</button>
<button data-md-color-accent="green">Green</button>
<button data-md-color-accent="light-green">Light Green</button>
<button data-md-color-accent="lime">Lime</button>
<button data-md-color-accent="yellow">Yellow</button>
<button data-md-color-accent="amber">Amber</button>
<button data-md-color-accent="orange">Orange</button>
<button data-md-color-accent="deep-orange">Deep Orange</button>

A default hue is defined for every primary and accent color on Google's Material Design color palette, which makes it very easy to change the overall look of the theme. Just set the primary and accent colors using the following variables:

``` yaml
theme:
  palette:
    primary: 'indigo'
    accent: 'indigo'
```

Color names are case-insensitive, but must match the names of the Material Design color palette. Valid values are: `red`, `pink`, `purple`, `deep purple`, `indigo`, `blue`, `light blue`, `cyan`, `teal`, `green`, `light green`, `lime`, `yellow`, `amber`, `orange`, `deep orange`, `brown`, `grey`, `blue grey` and `white`. The last four colors can only be used as a primary color.

!!! TIP "Compile your own custom color theme"

    If the color is set via this configuration, an additional CSS file that defines the color palette is automatically included. If you want to keep things lean, __clone the repository and recompile the theme with your custom colors set__. See the [guide on customization](http://wiljenumdesign.nl/customization/) for more information.

---

repository: madrus/mdocs

gha_language: CSS

repo_name: madrus/mdocs


text:
+++
# Display name
name = "Katelyn Greene"

# Username (this should match the folder name)
authors = ["admin"]

# Is this the primary user of the site?
superuser = true

# Role/position
role = "PhD Student in Biomedical Engineering"

# Organizations/Affiliations
#   Separate multiple entries with a comma, using the form: `[ {name="Org1", url=""}, {name="Org2", url=""} ]`.
organizations = [ {name = "Center for Injury Biomechanics"}, { name = "Virginia Tech - Wake Forest University School for Biomedical Engineering and Sciences", url = "https://sbes.vt.edu" }  ]

# Short bio (displayed in user profile at end of posts)
bio = "I'm an engineer interested in helping others understand research and inspiring the next generation of young scientists. I specialize in biomechanics, image analysis, and computational modeling."

# Enter email to display Gravatar (if Gravatar enabled in Config)
email = ""

# List (academic) interests or hobbies
interests = [
  "Biomechanics",
  "Data Science",
  "Digital Healthcare"
]

# Organizational groups that you belong to (for People widget)
#   Set this to `[]` or comment out if you are not using People widget.
user_groups = ["Researchers", "Visitors"]

# List qualifications (such as academic degrees)
[[education.courses]]
  course = "BS in Bioengineering"
  institution = "University of California, Berkeley"
  year = 2017

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/widgets/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "#contact" for contact widget.

[[social]]
  icon = "linkedin"
  icon_pack = "fab"
  link = "https://www.linkedin.com/in/katelynagreene/"

#[[social]]
#  icon = "envelope"
#  icon_pack = "fas"
#  link = "#contact"  # For a direct email link, use<EMAIL_ADDRESS>
[[social]]
  icon = "twitter"
  icon_pack = "fab"
  link = "https://twitter.com/KatelynAGreene"

#[[social]]
#  icon = "instagram"
#  icon_pack = "fab"
#  link = "https://www.instagram.com/katelynagreene/"

[[social]]
  icon = "orcid"
  icon_pack = "ai"
  link = "https://orcid.org/0000-0002-4150-3451"

#[[social]]
#  icon = "google-scholar"
#  icon_pack = "ai"
 # link = "https://scholar.google.co.uk/citations?user=sIwtMXoAAAAJ"

[[social]]
  icon = "github"
  icon_pack = "fab"
  link = "https://github.com/KatelynGreene/"

# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
# [[social]]
#   icon = "cv"
#   icon_pack = "ai"
#   link = "files/cv.pdf"

+++

I'm a third year PhD student at Wake Forest University studying the changes in the bone and muscle of astronaut spines with long duration spaceflight. Beyond my engineering studies, I am also a trained science communicator and leader with expertise in organizing K-12 STEM outreach activities. It is my long-term goal to help make science accessible and easy to understand for the broader academic and public community, so that we all can benefit from the advancements made possible by research.

When not in lab, I enjoy rollerblading, hiking, gardening, and pretty much anything else that involves being outside!

repository: cahuparo/KatelynGreeneWebsite

repo_name: cahuparo/KatelynGreeneWebsite


text:
# Change Log

All notable changes to this project will be documented in this file.

## [3.0.0] - 2022-01-04

Thanks to [@jlaramie](https://github.com/jlaramie) for all these changes.

### Breaking

- Changes to array output. See `test/arrays-test.js`.

### Added

- Definition for a generic en-EU language.
- `options.preserveLanguage` to keep language-specific delimiters as well as TRUE/FALSE values
- `options.asClass` - To return `Tokens` instance instead of `Tokens[]`.
- Improved compatibility with other libraries

### Fixed

- [#6](https://github.com/psalaets/excel-formula-tokenizer/issues/6) - Quotes around named ranges with spaces are not
  preserved
- [#8](https://github.com/psalaets/excel-formula-tokenizer/issues/8) - Vertical range separator always being , instead
  of ; in the tokens

## [2.4.0] - 2021-12-27

### Fixed

- Big i18n fix (courtesy of [@jlaramie](https://github.com/jlaramie) in
  [#4](https://github.com/psalaets/excel-formula-tokenizer/pull/4))

## [2.3.1] - 2020-04-29

### Fixed

- Fixed issue with parsing scientific numbers that caused problems with whitespace.

## [2.3.0] - 2017-09-11

### Added

- Support for different languages/locales (not really, it's broken)

## [2.2.0] - 2017-08-30

### Added

- TypeScript support

## [2.0.1] - 2017-04-29

### Fixed

- Range intersection operator is now represented as a single space (was: empty string)

## [2.0.0] - 2017-04-29

### Breaking changes

- Tokenizer function now exported as `tokenize`
- `tokenize()` returns Array of tokens

## [1.0.0] - 2017-04-23

### Added

- Original impl brought over from http://ewbi.blogs.com/develops/2004/12/excel_formula_p.html
- Tests

### Fixed

- Issue with "All cells in row(s)" ranges, e.g. `5:10`

repository: psalaets/excel-formula-tokenizer

repo_name: psalaets/excel-formula-tokenizer


text:
## How to set show and hide widget in pdf with pdf sdk in VBScript using ByteScout Premium Suite

### Continuous learning is a crucial part of computer science and this tutorial shows how to set show and hide widget in pdf with pdf sdk in VBScript

Every ByteScout tool includes simple example VBScript source codes that you can get here or in the folder with installed ByteScout product. ByteScout Premium Suite: the set that includes 12 SDK products from ByteScout including tools and components for PDF, barcodes, spreadsheets, screen video recording. It can set show and hide widget in pdf with pdf sdk in VBScript.

The following code snippet for ByteScout Premium Suite works best when you need to quickly set show and hide widget in pdf with pdf sdk in your VBScript application. Follow the instructions from scratch to work and copy the VBScript code. Enjoy writing a code with ready-to-use sample codes in VBScript.

You can download free trial version of ByteScout Premium Suite from our website with this and other source code samples for VBScript.

## REQUEST FREE TECH SUPPORT

[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20Premium%20Suite%20Question)

or just send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20Premium%20Suite%20Question)

## ON-PREMISE OFFLINE SDK

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)
[Explore SDK Docs](https://bytescout.com/documentation/index.html?utm_source=github-readme)
[Sign Up For Online Training](https://academy.bytescout.com/)

## ON-DEMAND REST WEB API

[Get your API key](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Documentation](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/tree/master/PDF.co%20Web%20API)

## VIDEO REVIEW

[https://www.youtube.com/watch?v=NEwNs2b9YN8](https://www.youtube.com/watch?v=NEwNs2b9YN8)

<!-- code block begin -->

##### ****ShowHideWidget.vbs:**

```
' This example demonstrates how to show/hide a widget in document.

' Create Bytescout.PDF.Document object
Set pdfDocument = CreateObject("Bytescout.PDF.Document")
pdfDocument.RegistrationName = "demo"
pdfDocument.RegistrationKey = "demo"

Set comHelpers = pdfDocument.ComHelpers

' Add page
Set page1 = comHelpers.CreatePage(comHelpers.PAPERFORMAT_A4)
pdfDocument.Pages.Add(page1)

' Create widget that will be shown/hidden
Set editBox1 = comHelpers.CreateEditBox(20, 20, 100, 25, "editBox1")
editBox1.Text = "editBox1"
page1.Annotations.Add(editBox1)

' Create button that will show the widget
Set buttonShow = comHelpers.CreatePushButton(20, 80, 50, 25, "buttonShow")
buttonShow.Caption = "Show"
page1.Annotations.Add(buttonShow)
' Add Show action
Set showAction = comHelpers.CreateHideAction(False)
showAction.Fields.Add(editBox1)
buttonShow.OnActivated = showAction

' Create button that will hide the widget
Set buttonHide = comHelpers.CreatePushButton(100, 80, 50, 25, "buttonHide")
buttonHide.Caption = "Hide"
page1.Annotations.Add(buttonHide)
' Add Hide action
Set hideAction = comHelpers.CreateHideAction(True)
hideAction.Fields.Add(editBox1)
buttonHide.OnActivated = hideAction

' Save document to file
pdfDocument.Save("result.pdf")

' Open document in default PDF viewer app
Set shell = CreateObject("WScript.Shell")
shell.Run "result.pdf", 1, false

```

<!-- code block end -->

url: https://raw.githubusercontent.com/bytescout/ByteScout-SDK-SourceCode/67a20983df78dea26d2a8f25ec98000d3ec81928/Premium Suite/VBScript/Set show and hide widget in pdf with pdf sdk/README.md

repository: bytescout/ByteScout-SDK-SourceCode

gha_language: HTML

repo_name: bytescout/ByteScout-SDK-SourceCode


text:
# 05-Third-Party-APIs-Work-Day-Scheduler

##  Using Third Party APIs to Create a Work Day Planner
The library [Luxon](https://moment.github.io/luxon/) was used to grab the date and times from the third-party API. The purpose of this project is to help a busy client to create a daily planner to create a work schedule. The planner displays the current date at the top of the planner, along with different time blocks from 9AM-5PM, which is color-color to indicate what time is in relative to now (past, present, or future). In addition, the User can write anything in the time block and click on the save button to retrieve the input even after refreshing the page.

## Usage

1) Open the Index.html file with Chrome/Firefox web browsers:
2) The hours in the planner is color-coded based on past(gray), present(coral), future(green) relative to now.
1) Click one of the time blocks and type in anything you want to plan during that hour. Then, click on the "Save" button to have your input saved and see in the future, even after refreshing the page! See [How To Use Demo](How-To-Use.PNG).

## Credits
https://moment.github.io/luxon/
https://stackoverflow.com/questions/36733831/how-to-find-next-textarea-using-jquery
https://www.youtube.com/watch?v=vAuUzEwTbck
https://www.jsdelivr.com/package/npm/luxon

## License

MIT License

Copyright (c) [2020] [Alicia Qiu Cheung]

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.


text:
# STARK Verifier
Below is a brief explamnation about the steps in verification. For more information look at the resources section on the main page.

## Arithmetization
The verifier ensures consistency between the compositional polynomial and the Trace Low Domain Extension using Out of Domain Sampling (OODS).

## Fast Reed-Solomon Interactive Oracle Proof (FRI)
Assuming the prover is honest, the compositional polynomial should be of low degree. To prove so succictly, the prover sends over polynomials in the form: f(x) = g(x^2) + xh(x^2) until a constant is reached. The FRI verifier can randomly sample the commitments and interpolate the next layer of commitments and verify the layers.

f(x)  = g(x^2) + x * h(x^2)

f(-x) = g((-x)^2) - x * h((-x)^2) = g(x^2) - x * h(x^2)

=>
    2g(x^2) = f(x) + f(-x)

    2h(x^2) = (f(x) - f(-x))/x

=> The 2 * interpolation at evalPoint is:

      2 * (g(x^2) + evalPoint * h(x^2)) = f(x) + f(-x) + evalPoint * (f(x) - f(-x)) * xInv.


text:
# NLW#4 - ReactJS Trail - Move it

## :information_source: What is the project ?

Moveit was developed during a RocketSeat event called Next Level Week, where instructor Diego Fernandes teaches how to master tools quickly and efficiently. This week was very intense, with a lot of code and challenges. having as source of studies the Web Development using the technologies ReactJS, TypeScript and the framework NextJS.

## 🧪 Technologies

This project was developed using the following technologies:

## 🔥 Preview

![Deploy with Vercel](https://vercel.com/button)

### ☕ Who to use

Only perform the following steps:

```bash
# Running the program.
$ yarn OR npm install

# Stopping and removing the program.
$ yarn dev OR npn run dev
```

To check if your application is running, just open your browser using `http://localhost:3000`

## :memo: License

This project is under MIT license!

Made with by Luiz Otávio Mendes :wave: [GitHub][github]

[github]: https://github.com/luizhttps
[telegram]: https://t.me/luizotavio_ms
[linkvercel]: https://moveit-nlw4-qj8qjycrl-luizhttps.vercel.app
[nextjs]: https://nextjs.org/
[react]: https://reactjs.org
[typescript]: https://www.typescriptlang.org/

gha_language: TypeScript


text:
LG Animations
==================
The anim.js module of LG uses a modified version of Animax made for LG to add effect functions to the LG prototype.
The Animax object is under $lg.animation and can be used as according to the Animax documentation.

_This whole animation module depends on the css.js module_

The Animation Function
-----------------
_This function depends on the css.js module_
LG has an important animation function which is used internally for animations, `.animate(properties [, callback] [, time])`
The properties parameter should be an object containing the properties or CSS properties to animate and the value of which to animate to.

For example to animate an elements width to 100px: `$lg('#element').animate({ width: '100px' });`
The "from" value will be taken from the elements current value for the property.

Several properties can be defined to animate at once calling the animate function only once.
```javascript
$lg('#element').animate({
	width: '100px',
	padding: '20px',
	top: '50%'
});
```
The animate function optionally takes a callback function to exectue after the animation is complete.
Also optionally a time can be defined to specify the length of the animation; see Animax documentation for more detail.

LG Animation Functions
-------------------------
There are a few basic animations built into LG for the most popular effects.

#### slideDown([speed] [,callback])
_This function depends on the dom.js module_
Slide the element/s down into view. Commonly used for displaying a hidden element.
The first optional parameter defines the speed of the animation, see Animax for more details.

A callback function can also be specified to be executed when the animation is complete.

```javascript
$lg('#button').click(function(){
	$lg('#menu').slideDown('fast');
});
```

#### slideUp([speed] [,callback])
_This function depends on the dom.js module_
Similar to slideDown but hides the element/s by sliding them up. Commonly used for hiding a visible element.

#### fadeOut([speed] [,callback])
Changes the opacity of an element from its current opacity to 0, hiding it from view.

#### fadeIn([speed] [,callback])
Changes the opacity of an element from 0, to simulate fading in, bringing it into view.

LG Function Modifications
--------------------------
The Animation module modifies a few function of the LG prototype.

The hide, show and toggle function now have an optional animation parameter which can either be 'slide' or 'fade'.
This allows you to use the animations for toggling: `$lg('#element').toggle('fade');`

repository: AvacWeb/LG-JS-Frame

repo_name: AvacWeb/LG-JS-Frame


text:
# Dashboard LTI for CalStateTEACH Canvas Users

This Web-based dashboard app gives [CalStateTeach](https://www.calstateteach.net/) users of [Canvas](https://www.canvaslms.com/) a summary view of their data across multiple courses, with links to relevant Canvas pages for reviewing assignment submissions. It also simplifies the process of creating assignments & displays data from other services used by CalStateTEACH. Features include:

* Live summaries of status of student submissions, across multiple courses.
* Direct links to Canvas app's assignment pages, submissions pages, student information & SpeedGrader.
* Simplified creation of Canvas assignments linked to external tools.
* Automated creation of Google Docs populated with Canvas assignment data.
* Periodic background fetching of Canvas data, to maintain responsiveness of the UI.
* LTI administrator's interface for monitoring the configuration & status of the app.

This project is made available as an example of using the [Canvas API](https://canvas.instructure.com/doc/api/index.html) to completely tailor the user experience for Canvas users. The app was demoed for the [February 2018 Canvas CIG online meeting](https://community.canvaslms.com/docs/DOC-16226-february-2018-canvas-cig-zoom-share-agendanotes) & will be discussed in a [session](https://events.bizzabo.com/211400/agenda/session/78382) at [InstructureCon 2019](https://blog.canvaslms.com/news/instructurecon19).

### Dependencies

The Web app uses the [Express](https://expressjs.com/) framework for [Node.js](https://nodejs.org/). [MongoDB](https://www.mongodb.com/) is used as a session database & a store for dashboard user settings. Besides using the Canvas API, the app calls proprietary 3rd party Web services.

### Configuration

Configuration files are in the *config/* folder. Configuration strings retrieved from the runtime environment are specified in the *.env* file.

### Web App Entry Points

The LTI is expected to be entered by an LTI launch request using OAuth, which in production is a POST request from the Canvas app. The launch URL is the route */lti* in the root of the Web app.

There is also a */devlogin* route in the root of the Web app for LTI admins. This route requires a user ID & password to enter & gives access to developer & admin pages.

The project's *routes* & *views* folders contain these subfolders:

* *dash/* for pages accessed by LTI users.
* *dev/* for pages accessed by LTI admins/developers.
 * *root/* for entry points.

## Deployment

In production, the Web app runs on an [Amazon EC2](https://aws.amazon.com/ec2/) instance running Ubuntu.

## Authors

* **Terence Shek** - *Programmer* - [tpshek](https://github.com/tpshek/)

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details


text:
If you like VictoriaMetrics and want to contribute, then we need the following:

- Filing issues and feature requests [here](https://github.com/VictoriaMetrics/VictoriaMetrics/issues).
- Spreading a word about VictoriaMetrics: conference talks, articles, comments, experience sharing with colleagues.
- Updating documentation.

We are open to third-party pull requests provided they follow [KISS design principle](https://en.wikipedia.org/wiki/KISS_principle):

- Prefer simple code and architecture.
- Avoid complex abstractions.
- Avoid magic code and fancy algorithms.
- Avoid [big external dependencies](https://medium.com/@valyala/stripping-dependency-bloat-in-victoriametrics-docker-image-983fb5912b0d).
- Minimize the number of moving parts in the distributed system.
- Avoid automated decisions, which may hurt cluster availability, consistency or performance.

Adhering `KISS` principle simplifies the resulting code and architecture, so it can be reviewed, understood and verified by many people.

repository: VictoriaMetrics/VictoriaMetrics

gha_language: Go

repo_name: VictoriaMetrics/VictoriaMetrics


text:
# Colorful Masonry

![](Art/ColorfulBlocks.png)

**Colorful Masonry** adds brick type blocks in all default dye colors.

They can be created using the newly added **Masonry Oven**.

#### Crafting recipe

![](Art/crafting.jpg)

#### Smelting with the Masonry Oven

![](Art/Smelting.jpg)

- Add Clay and dye to the Masonry Oven to create bricks in any color.

#### Use the **stonecutter** to create slabs, stairs and brick walls.

![](Art/Stonecutter-ColorfulBricks.png)

#### The Masonry Oven also works with hoppers and redstone comparators

![](Art/Redstone-And-Hoppers.png)

## License

Colorful Masonry is licensed under the Apache License 2.0.

repository: sorskoot/ColorfulMasonry

gha_language: Java

repo_name: sorskoot/ColorfulMasonry


text:
### Description
This definition shows you how to add a custom object for an evaporative cooling dowdraft tower to your Honeybee EnergyPlus model.

The file uses an example from the ancient Iranian city of Yadz where these towers were first invented to keep interiors cooler in the hot dry Summer.

This file has been submitted by [chriswmackey](https://github.com/chriswmackey)

[Check out this example on Hydra!](http://hydrashare.github.io/hydra/viewer?owner=chriswmackey&fork=hydra_2&id=Evaporative_Cooling_Tower)
### Tags
HBExampleFiles, Honyebee, EPW, Weather, Climate, Energy, Simulation, Model, Evaporative, Cooling, Downdraft, Wind, Tower, Custom, Object, additionalStrings, Results, .rdd, Result, Data, Dictionary
### Thumbnail
![Screenshot](https://raw.githubusercontent.com/chriswmackey/hydra/master/Evaporative_Cooling_Tower/thumbnail.png)