|
SUKKUR IBA UNIVERSITY Merit-Quality-Excellence DEPARTMENT OF ELECTRICAL ENGINEERING |
|
MPU6050 Sensor: |
|
|
|
Ref |
| Click Here to download datasheet. |
|
Click Here
to purchase online.
|
|
MPU6050 Pin Configuration: |
Pin Number |
Pin Name |
Description |
1 |
Vcc |
For providing power to the module, can be +3V to +5V. Typically +5V is used. |
2 |
Ground |
Used to connect the system to the ground. |
3 |
SerialClock(SCL) |
Used for providing clock pulse for I2C Communication. |
4 |
Serial Data(SDA) |
Used for transferring Data through I2C communication. |
5 |
Auxiliary Serial Data(XDA) |
Used to interface other I2C modules with MPU6050. (Optional) |
6 |
Auxiliary Serial Clock(XCL) |
Used to interface other I2C modules with MPU6050. (Optional) |
7 |
AD0 |
This pin is used when more than one MPU6050 is used on a single MCU. |
8 |
Interrupt (INT) |
Interrupt pin to indicate that data is available for MCU to read. |
|
Discription: |
|
The MPU6050 is a Micro Electro-Mechanical Systems (MEMS). Inside the MPU6050 there are 3-axis Accelerometer
and 3-axis Gyroscope. The parameters related to the motion of a system like acceleration, velocity, orientation,
displacement are measured using the data collected from them. There are also two auxiliary pins. These auxiliary
pins are used to interface external I2C modules. This module can very easily be used with any Arduino plateform by
installing some of the libraries.
|
|
Applications: |
Gyro is used in wide range of fields where position or orientaion of any object needs to be monitored. Some of the common uses are: • Used for IMU measurement • Drones / Quad copters • Self balancing robots • Robotic arm controls • Humanoid robots • Tilt sensor • Orientation / Rotation Detector |
|
Flysky-A8S Receiver: |
| Click Here to download datasheet. |
|
Click Here
to purchase online.
|
|
Flysky-A8S Pin Configuration: |
Pin Name |
Description |
Vcc |
For providing power to the module. |
Ground |
Used to connect the system to the ground. |
Receiver |
Used for receiving the data from the transmitter |
PPM Signal Port |
Output standard PPM signal. |
i-BUS/S.BUS signal port |
Outputs i-BUS/S.BUS signals, up to 18 channels |
|
Discription: |
|
The FS-A8S is a compact 1-way receiver designed for multi-rotor aircraft. It uses the AFHDS 2A (Automatic
Frequency Hopping Digital System) protocol, supports standard PPM output and has i-BUS support for up to
18 channels. As for drone our major concern mostly remains is its components weight. This FS-a8s fits the
specified requirements being only 20x14x5.3mm in size and 1.2gm in weight.
|
|
Flysky Transmitter: |
| Click Here for manual. |
|
Click Here
to purchase online.
|
|
Features: |
|
• Offering good protection against interference while maintaining lower power consumption and
high reliable receiver sensitivity. • Bidirectional Communication Capable of sending and receiving data, each transmitter is capable of receiving data from temperature, altitude and many other types of sensors, servo calibration and i-BUS Support(But in our case, we are only using uni-directional transmission: only to send data from transmitter to receiver). • Each transmitter and receiver has it's own unique ID. Once the transmitter and receiver have been paired, they will only communicate with each other, preventing other systems accidentally connecting to or interfering with the systems operation. |
|
Binding Receiver With Transmitter: |
|
We need to bind the transmitter with receiver when we are powering them for first time. Once they are in bind mode,
we do not need to bind them again until a new code is loaded into the microcontroller. The process of binding is
described below: • Power On the transmitter while holding the bind button. • If the receiver’s LED is flashing this means it is ready for binding. • If binding is successful, you can see an RX symbol appears at the top-right side of your transmitter display. • After successful binding, LED will stop flashing and remains solid. |
|
Coreless DC Motor And Propellers: |
| Click Here to buy online. |
|
Specifications Of Coreless Motors: |
|
• Material: Metal • Operating Voltage: 3.7 VDC • Rated Speed: 4200 RPM • Shaft Dimension: 3 x 0.5mm (L x D) • Body Dimension: 6 x 16mm (D x L) • Total Dimension: 19mm • Cable Length: 13mm |
|
About DC Motors: |
| As mentioned before, the key factor to make a drone successful is to make it light weight and choose the components that can provide more thrust. These motors that we have chosen for our project, meet these requirements. They are efficient in terms of power dissipation and have high RPM. These motors start rotating at 2.5V, but give full RPM at the voltage around 3.7V to 4.2V. |
|
About Propellers: |
| Propellers are essential components of a drone because they provide lifting force against the rotation of motors. One needs to do a deep research before choosing motors and propellers. Even if one buys motors having high RPM but fail to choose compatible propellers, it will be a failure. The propellers that we have chosen were best suited for 6*16mm motors. Buy right propeller and motors from the above mentioned link. |
|
Flight Controller: |
As mentioned earlier, in the beginning we decided to work with NodeMCU, so we didn’t need to make any flight controller. But soon after not succeeding with NodeMCU we decided to make our own flight controller. The components required for making a fight controller are mentioned below. |
|
ATmega328P: |
| Pic Ref |
| Click Here for manual. |
| Click Here to buy online. |
Parameter |
Value |
CPU type |
8-bit AVR |
Performance |
20 MIPS at 20 MHz |
Flash memory |
32 KB |
SRAM |
2 KB |
EEPROM |
1 KB |
Pin count |
28 or 32 pin |
Maximum operating frequency |
20 MHz |
Number of touch channels |
16 |
Hardware QTouch Acquisition |
No |
Maximum I/O pins |
23 |
External interrupts |
2 |
|
Its Applications: |
There are hundreds of applications for ATMEGA328P: • Used in ARDUINO UNO, ARDUINO NANO and ARDUINO MICRO boards. • Industrial control systems. • SMPS and Power Regulation systems. • Digital data processing. • Analog signal measuring and manipulations. • Embedded systems like coffee machine, vending machine. • Motor control systems. • Display units. • Peripheral Interface system. |
|
MOSFET(Si2302): |
| Click Here for manual. |
| Click Here to purchase online. |
For a flight controller we need 4 MOSFETs. As we are using 3.7 V battery, so we need MOSFETs that can operate on this voltage. We have used SI2302 because of its low power loses and Vgs. These MOSFETs start conduction at the voltages greater than 2.5 (Vgs voltage). This means that when we apply the control signal from GPIO pin having the voltage less than 2.5, the MOSFETs will act as an open circuit. But for voltages greater than 2.5 or 3 they will start conduction, and thus motors will start to rotate. As each motor is connected to separate MOSFETs, so we can control individual motor by changing the strength of control signal or voltage at the gate terminal of each MOSFETs. |
|
Some Other Basic Components: |
|
We also require some of the basic components for this project, including: SMD Components • 5V voltage regulator • One push Button • Resistor: One 10K and two 470 ohm • Crystal: One Crystal • lED’s : Two (3.7V) • Capacitor: Three 10uF, one 0.1uf and two 22pF • Male Headers: 14 L-Shape and 6 Stright. • Female Headers: 6 |
|
Battery: |
| Click Here to purchase online. |
For this project we have used 3.7 V LiPo battery because these batteries are light weight and have higher charge density than other batteries available in the market. We have actually designed our circuit that works both on a single battery (3.7 V) and also on two batteries in series(7.4 V). Depending upon our design requirements, we can use any of the options. More details about our designed circuit are available Here! |
|
Total Cost Of The Components: |
Components |
Price (Rs) |
| MPU6050 | 420 |
| Motors & properllers | 1550 |
| FS-a8s Receiver | 1620 |
| Fly-Sky transmitter | 5931 |
| Microcontroller ATmega328p | 240 |
| MOSFETs | 35 |
| Resistors | 150 |
| Headers, push button & LED's | 130 |
| Total cost | 10076 |
| Prev | Next |


Mexpro's outstanding customer service team is here to help you every step of the way!
Email us<EMAIL_ADDRESS>Call us toll free 1-855-MEXPRO1
Cancel My Policy
We understand that life happens and plans change. Cancellations can be done by using our online cancellation form.
Make Changes
If you need to make changes on your Mexico insurance policy, you can do so by simply filling out the online forms.


Let's see the type of triangle you have
Enter the AB of the triangle
Enter the BC of the triangle
Enter the CA of the triangle
submit
refresh


At the symposium this year, there are two options for participating: a retrospective research talk or a prospective research talk. MSU faculty will judge the presentations based on a points system, and a first place prize will be awarded within both of the categories.
Abstracts for presentations are due Friday, January 26 at 11:59 PM. These should be submitted on the registration site when registering as an attendee.
This traditional-style prospective or retrospective presentation will be 12 minutes long with 3 minutes for questions and answers. Presenters will have access to a projector and department computer.


AThaw simulates pan-Arctic CH 4 (CH 4TKL) and CO 2 (CO 2TKL) release from thermokarst lakes proportional to the amount of newly-thawed carbon that becomes vulnerable to microbial decomposition. The volume of this newly-thawed carbon expands vertically by talik growth in sub-lake sediments and horizontally by increases in the extent to which thermokarst lakes cover the landscape. Here we discuss how these two processes, vertical and horizontal growth, are captured in AThaw and how they compare to other modeling studies and observational evidence.
First, AThaw simulates vertical talik growth rates beneath lakes as a function of atmospheric temperature anomalies, which in turn determine lake bottom temperatures and ultimately drive sub-lake sediment warming. Thaw rates are assumed to depend on soil ice contents, mean ground temperature, depth of the thaw front, and are tuned to reproduce talik deepening simulated by Kessler et al. 16. For instance, AThaw simulates typical talik depth beneath lakes of 11 m (7.8–13.4 m, 68% uncertainty range; 20 m max) in warm permafrost environments (i.e., mean annual soil temperatures close to 0 °C) with mineral soils by the year 2050 under RCP8.5. Our helicopter-borne electromagnetic measurements of sites with comparable climatic and soil conditions (i.e., relatively warm permafrost temperatures between −3 and −1°C) (Supplementary Information) have inferred lake talik growth of 8–15 m in < 50 years (Supplementary Fig. 7). It should be noted that advective heat transport by groundwater can accelerate vertical thaw; maximum reported thaw rates are up to a meter per year 78, 79. When accounting for the effect of ground subsidence in a modeling context, Westermann et al. 79 suggest that several meters of ground ice can be removed in less than a decade. The authors simulated a talik growth of 15 m by 2100 under RCP8.5 for a site characterized by yedoma ice complex in cold, continuous permafrost. In contrast, AThaw simulates 6 m (4–8 m, 68% range) talik depth under comparable climatic conditions by end of the century. Therefore, given modeling and observational evidence, we consider that the thaw rates in sub-lake sediments simulated by AThaw are relatively conservative.
A second key AThaw model assumption concerns simulated thermokarst-lake expansion in a warmer climate. Central to this aspect is the question to which extent newly-formed thermokarst lakes will cover degrading permafrost landscapes in a warmer climate. AThaw assumes that future thermokarst-lake formation will strongly depend on soil conditions (e.g., ice content) and landscape morphology. Therefore, the model assumes different maximum lake formation extents for four different ice-rich soil type distributions in the permafrost region of the Arctic: mineral soil (Orthels and Turbels), organic soils (Histels), undisturbed yedoma, and refrozen thermokarst deposits in the yedoma region (Supplementary Table 1, Supplementary Figs 4 and 5). Orthels, Turbels and Histels follow the Northern Circumpolar Soil Carbon Database (NCSCD) 80, while undisturbed yedoma and refrozen thermokarst deposits in the Pleistocene-aged ice-rich yedoma soil region are distinguished according to Strauss et al. 81 and Walter Anthony et al. 24.
For mineral soils, AThaw assumes that newly-formed lakes can degrade a maximum fraction F TKLmax of 7% (4–9%, 68% range; Supplementary Fig. 4) of the landscape. Given the large-scale dominance of mineral soils in the permafrost region soil carbon inventory (540 Pg C, NCSCD) 80, this soil class contributes significantly to cumulative pan-arctic CH 4TKL (at year 2100, 46% for RCP8.5, 28% for RCP4.5). Organic soils (120 Pg C, NCSCD) 80 are typically richer in ground ice than mineral soils and therefore AThaw assumes a factor two larger potential for the formation of new thermokarst lakes [F TKLmax of 14% (10–17%, 68% range; Supplementary Fig. 4)]. This soil type contributes 17% for RCP8.5 and 14% for RCP4.5 to cumulative pan-arctic CH 4TKL. AThaw explicitly accounts for ice- and organic-rich soils in yedoma regions, separated into undisturbed yedoma landscapes (80 Pg C) 81 and drained lake basins in the yedoma region that subsequently formed permafrost following lake drainage (refrozen thermokarst; 240 Pg C) 24, 81. Given the high ice contents of these yedoma-region soils 81– 83, both soil classes are assigned a high potential for the formation of new thermokarst lakes once rising temperatures have resulted in ground subsidence. Given the high volumetric ice contents of refrozen drained thermokarst lake basins (> 50%) 81, 83 in conjunction with its basin-type geomorphology, which favors water ponding 16, AThaw assumes a maximum F TKLmax of 21% (11–27%, 68% range; Supplementary Fig. 4). Refrozen thermokarst basins in the yedoma region cover only about 4% of the permafrost domain of the Arctic, but they contribute 28% under RCP8.5 (38% under RCP4.5) to cumulative pan-arctic CH 4TKL by 2100. The highest potential for new-lake formation is assumed for unaltered ice-rich yedoma soils, where volumetric segregated ice content is typically 47–53% and high wedge-ice volumes (~40%) further increase permafrost ice concentration 81. Here AThaw assumes a F TKLmax of 33% (16–42%, 68% range; Supplementary Fig. 4). Considering that thermokarst activity in ice-rich regions had degraded about 80% of the landscape in specific regions during the Holocene 24, 81, 84, we consider a factor two reduced lake-forming potential plausible, especially under the assumption of strong future warming. While undisturbed yedoma landscapes constitute our carbon pool with the smallest areal extent (covering 0.41 million km 2, 2% of the permafrost domain) 81, they contribute 9% under RCP8.5 (20% under RCP4.5) to cumulated pan-arctic CH 4TKL by 2100, revealing the importance of carbon release from deep deposits beneath abruptly-formed yedoma thermokarst lakes.
We derived estimates of present-day abrupt-thaw emissions from AThaw and independently from upscaling observations. The estimated emission range from AThaw [20 (7–49) Tg C-CO 2e yr −1] represents the median and 68% uncertainty range for years 2011–2017 (Supplementary Data 1). The observation-based estimate (19–58 Tg C-CO 2e yr −1) was derived by upscaling observed lake carbon fluxes from abrupt-thaw features (Fig. 2b) to the extent of observed gross lake expansion areas (5–15%) among pan-arctic regions during the past 60 years 21. This range of gross lake expansion is comparable to our observation of gross lake-area increase in northern and western Alaska (i.e., 1999–2014, 1.1–1.7% gross lake area increase upscaled to 5–7% assuming similar expansion/formation rates over the past 60 years; Supplementary Table 3, Fig. 3). We acknowledge that present-day emissions associated with abrupt thaw may be conservative since gross lake-area increases in some regions are higher (e.g., > 50% in Quebec 85 and > 23% in West Siberia 86), potentially due to hydrological changes in addition to permafrost thaw.
The formation/expansion of new thermokarst-lake areas and subsequent sub-lake talik growth is not the only mechanism of abrupt permafrost degradation making newly thawed permafrost carbon available for microbial decomposition. Further contribution comes from talik growth of present-day lakes which have not yet formed a deep talik and still store large amounts of labile carbon in sub-lake sediments. For instance, on the Alaska North Slope, Arp et al. 17 demonstrated that a rapid decrease in lake-ice thickness and duration has already led to many shallow lakes transitioning from bed-ice fast lakes underlain by permafrost to floating ice lakes that have started to develop taliks. This talik formation takes place about 70 years before talik formation is projected for the adjacent terrestrial environment by top-down permafrost models in this cold continuous permafrost zone, a feedback process also not accounted for in AThaw or other models of permafrost degradation. These and other non-lake modes of abrupt thaw 13, including coastal and river erosion, thermoerosional gully formation, thaw slumps, collapse of permafrost peat plateaus, and talik formation in upland terrestrial environments, which may occur sooner than predicted by large-scale models when finer resolution soil and vegetation properties are taken into account 49, are not explicitly accounted for in the AThaw model description; hence, we consider our assumed F TKLmax values a conservative estimate of the abrupt thaw extent in the 21st century.


--- layout: newsstory title: THAT'S GOT TWO CUPS OUT OF THE WAY match: FAC Yeltz 1 Gresley 2 ---
Well I suppose it was exciting but we're out of the FA Cup for another year, losing 2-1 to Gresley at The Grove.
The weather played a big part in the game, and we got to half-time 0-0 playing more or less into the gale. Then Lord Bradley scored with an over-the-shoulder volley after their pony-tailed goalie had fumbled a cross. We were all over them for a while, with Matt Gardiner coming close from 40 yards (it was windy) and Rob Elmes hitting the bar with what would have been goal of the century.
The trouble was Gresley are a good team and eventually they equalised and then took the lead in the 87th minute from a couple of corners. Even then we had chances to equalise as the ref played an age of injury time but it wasn't to be.


Template
Home
Samples
Resume
Photography
GC
Contact
{% block content %} {% endblock %}
Icons made by
SimpleIcon
from
www.flaticon.com
is licensed by
CC 3.0 BY
Icons made by
Freepik
from
www.flaticon.com
is licensed by
CC 3.0 BY
Icons made by
Freepik
from
www.flaticon.com
is licensed by
CC 3.0 BY


Utils profiling log structure. More...
Data Fields | |
| int32_t | isEnter |
| int32_t | this_fn |
| int32_t | call_site |
| uint32_t | timestamp |
| uintptr_t | this_fn |
| uintptr_t | call_site |
Utils profiling log structure.
Utils log elements have a predefined structure of four words (to avoid the need of malloc) and are stored in an array of predefined length, elemlog
.
| int32_t utilsProfilingElem::call_site |
Optional: Pointer address of calling function in current context
| uintptr_t utilsProfilingElem::call_site |
Optional: Pointer address of calling function in current context
| int32_t utilsProfilingElem::isEnter |
Indicates either enter or exit
| int32_t utilsProfilingElem::this_fn |
Pointer address of the function in current context
| uintptr_t utilsProfilingElem::this_fn |
Pointer address of the function in current context
| uint32_t utilsProfilingElem::timestamp |
Timestamp of the entry or exit


Notes on May 26, 2018
| Date: | May 26, 2018 |
|---|---|
| Last Updated: | Jun 4, 2018 |
| Categories: | |
| Tags: |
Contents
Set-invariant network
Check here to see the article Deep Sets:
Theory
This article discusses about how to build a neural network with order-invariant input set.
Theorem 1: which function could be set invariant:
Such a function $f(\mathbb{X})$ need to be able to be decomposed as such a form:\begin{align} f(\mathbb{X}) = \rho(\sum\limits_{x \in \mathbb{X}} \phi(x)). \end{align}
Since the general form of the layer of neural network is $F(\mathbf{x},~\boldsymbol{\Theta}) = \sigma (\boldsymbol{\Theta}\mathbf{x})$, we could know that according to the above theorem, only when
where $\mathbf{1} = [1,~1,~1,~\ldots,~1]^T$.
The whole network could be described as stacked layers as below. Each layer is set-invariant.
| Network Structure |
|---|
The final revised network layer could be formulated as
$\eqref{fml:sec1:final}$ shows that the trainable parameters are just $\boldsymbol{\Gamma}$ and $\boldsymbol{\beta}$. Denote the input $\mathbf{x}$ is a $K \times M$ matrix which has $K$ samples and output is a $K \times N$ matrix. Then we know that $\boldsymbol{\beta}$ is a bias variable which satisfies $\boldsymbol{\beta} \in \mathbb{R}^{N}$. $\boldsymbol{\Gamma}$ should be a trainable kernel which satisfies $\boldsymbol{\Gamma} \in \mathbb{R}^{M \times N}$. Note that $\boldsymbol{\Gamma}$ needs to be a diagonal matrix.
Extension
Check here to see de Finetti's theorem in Wikipedia.
In fact, I could not understand this part well. But I could give an explanation about how to derive the solution of this part. It is based on de Finetti ’s theorem:
$de~Finetti$’s Theorem: which function could be set invariant:
An exchangeable model $p(\mathbb{X})$ need to satisfy the exchangeable distribution as\begin{align} p(\mathbb{X} | \alpha) = \int \left[ \prod_{m=1}^{M} p(x_m | \theta) \right] p(\theta | \alpha) \mathrm{d} \theta . \end{align}
In this application, we know that:
We use $\langle \cdot \rangle$ to represent the inner product. Due to the exchangeability of the inner product, we could rewrite the model formula as:
Results
Here we show the results. Green means labels that exist but do not appear in ground truth. Brown means that labels appearing in ground truth. Red means wrong prediction. We could know that the results are order-invariant.
| Results |
|---|
Style Transfer
Check here to see the article Universal Style Transfer via Feature Transforms:
Theory
The basic idea is that the correlation (i.e. the Gramian matrix or covariance matrix) between features extracted by deep network could be used to describe the visual style of images. Along this idea, there are 3 models aiming to the same work. In the following part, we would discuss about them respectively.
Previous work: Gramian optimization
This is a previous work. Check here to see the article Image Style Transfer Using Convolutional Neural Networks:
Defining the output of a convolutional network layer as $\mathcal{F}^{(l)}(\mathbf{x})$ where $l$ represents the number of the layer and $\mathbf{x}$ represents the input image. Then the reconstruction process could be defined as
where $\mathbf{x}_0$ is the ground truth, i.e. the image that needs to be reconstructed. We use a white noise image $\boldsymbol{\theta}$ as the input, and optimize it so that it could match the output feature of $\mathbf{x}_0$. Here we call $\eqref{fml:sec2:reconst-cont}$ as the Content Reconstruction.
Check here to see Gramian matrix in Wikipedia.
We use Gramian matrix to describe the style of a image. Denote $\mathcal{G}^{(l)}$ as the Gramian matrix calculated by $\mathcal{F}^{(l)}$, we have the definition as
Gramian matrix is invariable with the location where the element (pixel) exists, so it could integrate the style of the image and omit the content features. Then we would get the idea that such optimization could be used to make the style reconstruction:
Then we could use the following figure to show the whole architecture of this work. In this work, the network has been pre-trained for object detection (or other purpose) and all of its parameters are fixed. We input a content image $\mathbf{x}_c$ and a style image $\mathbf{x}_s$. The style transformation is realized by optimizing the conjugated reconstruction loss $\mathcal{L}$.
| Gramian Optimization Architecture |
|---|
Denote $\boldsymbol{\theta}$ as another input image which needs to be optimized for reconstruction. The $\mathcal{L}$ is defined by two parts:
where $\mathcal{L}_c$ is the content loss which is defined as
where we only use the $L^{\mathrm{th}}$ layer to optimize the content features.
And $\mathcal{L}_s$ is the style loss which is defined by mixing style features from all layers:
where we use $w_l$ to define weights of features from each layer. The weights $w_l$ could be pre-defined and fixed during the optimization.
The final optimization target could be described as reconstructing an image with the content of $\mathbf{x}_c$ and style of $\mathbf{x}_s$.
$\eqref{fml:sec2:final}$ requires us to input an initialized image $\boldsymbol{\theta}$ and optimize the conjugated loss over it. The input image could be a white noise image, the content image or the style image. The author performs the experiments and show that the input would not influence the results greatly.
Previous work: Instance normalization
This is also a previous work. Check here to see the article Arbitrary Style Transfer in Real-time with Adaptive Instance Normalization:
This work is based on modifying instance normalization (IN). We know that the original form of the IN is
where $\gamma$ and $\beta$ are trainable. They are used as scaling factor. Since $\eqref{fml:sec3:in}$ is performed on each instance, we know that if $\mathbf{x}$ is group of $C$ channel images, i.e. a $N \times H \times W \times C$ tensor where $N$ represents the sample number, $H$ is the height, $W$ is the width and $C$ is the channel number, both $\gamma$ and $\beta$ have a size of $N \times C$. The $\mu(\cdot)$ and $\sigma(\cdot)$ are mean function and standard deviation (std) function respectively. Both of the two functions are performed on each channel and each sample individually.
The author think that the style of the image locates in mean and std values. So assuming that we have a content image $\mathbf{x}_c$ and a style image $\mathbf{x}_s$, the IN is modified as
which means we use the mean and std of the style image to replace the the same parameters of the content image. To some extent, if we perform $\hat{\mathrm{IN}}$ on original image, there would not be some significant change. However, in this work it is performed in compressed feature space.
| Instance Normalization Architecture |
|---|
In this figure, we know the basic architecture is auto-encoder. Both the $\mathbf{x}_c$ and $\mathbf{x}_s$ are feed into the encoder. Then in the feature space, the mean and std of the features of $\mathbf{x}_c$ are replaced by that of the features of $\mathbf{x}_s$. Then the changed features are feed into the decoder which would reconstruct a style-transferred image.
Note that we use a pre-trained VGG auto-encoder network, but the parameters of the encoder are fixed. We only train the decoder (whose parameters are denoted as $\boldsymbol{\Theta}_D$) so that it would not only reconstruct the content but also take the style into consideration. The conjugated loss function $\mathcal{L}$ is
We use $E$ to represent the encoder (which is fixed) and $D$ (with parameters as $\boldsymbol{\Theta}_D$) to represent the decoder (which needs to be trained). First we use $\hat{\mathbf{y}}_c$ to represents the adjusted features of $\mathbf{x}_c$,
This part is calculated directly and would not be influenced by training. Then we could define the first part of the loss, i.e. the content loss as
Here we match the features rather than the image because we do not have a image that could be matched. This idea is just like inverse the order of the auto-encoder but the coherence of the encoder and the decoder would not be damaged.
The style loss could be given by Gramian loss, but the author prefers to use the mean and the std.
where we use $E^{(l)}$ to represent the output features of the $l^{\mathrm{th}}$ layer of the VGG encoder network. In fact, we do not need to use all layers’ outputs but just need to select several layers.
The final optimization could be formulated as
After training, we could get the testing results as
This work: Whitening Transformation
In this paper, the author propose two improvements compared to the second previous work:
- Use whitening and coloring transformation to replace the optimization for mean and std.
- Propose a stacked auto-encoder framework to transfer style in different feature spaces.
Compared to the previous works, this work does not need to train networks or optimize for any target. It is totally based on embedding a statistic idea, i.e. the whitening and coloring transformation (WCT) into the deep learning architecture.
| WCT Architecture |
|---|
As is shown in the figure, (a) shows that a basic architecture of auto-encoder which is composed of an encoder and a decoder. This network should be pre-trained and kept fixed in this work. (b) is the core of this work, the author uses the WCT to transform the features produced by the encoder into another style, and use the original decoder to reconstruct the transformed features into the original image domain. (c) is used to improve the performance. Although it is only simply composed of several stacks of (b), it could produce the similar performance of optimizing for style loss from all layers. Since the deeper the features are, the less the details would remain, the original image would be transformed in deep space first, and get the same transformation in the shallow space. By this scheme, the main style would be transformed in deep space and the details would be added in shallow space.
Here we would like to discuss the core, i.e. the WCT in this paper. Denoting one input image as $\mathbf{x}$, then the output of the $l^{\mathrm{th}}$ layer of the encoder could be defined as $E^{(l)}(\mathbf{x})$ corresponded with the inverse transformation $D^{(l)}(E^{(l)}(\mathbf{x}))$. For the features $E^{(l)}(\mathbf{x})$, which has the size of $H \times W \times C$, from any sample, we could reshape it as $C \times HW$, then we could defines the centered features $\mathbf{y}$ as
Check here to see Eigendecomposition of a matrix in Wikipedia.
Note that the $\mathbf{y}$ should be reshaped, i.e. with a size of $C \times HW$. So it is apparent that the covariance matrix of $\mathbf{y}$ is $\mathbf{y}\mathbf{y}^T$. This covariance matrix is a real, symmetric and square matrix. Check the reference and we would know that this kind of matrix should be able to be decomposed of a diagonal eigenvalue matrix $\boldsymbol{\Lambda}$ and the corresponding eigenvector matrix $\mathbf{Q}$. Both of them are $C \times C$ matrix. This decomposition could be described as:
Calculating the decomposition is a trick. We summarize the algorithm of $\eqref{fml:sec2:eigendecomp}$ as follow:
- Solve the equation $\det(\mathbf{y}\mathbf{y}^T - \lambda \mathbf{I})=0$. We should have $C$ solutions. These solutions are eigenvalue which could be used to construct the diagonal eigenvalue matrix $\boldsymbol{\Lambda}$.
- Solve the equation $(\mathbf{y}\mathbf{y}^T - \lambda \mathbf{I})\mathbf{q} = \mathbf{0}$ for each $\lambda$. The corresponding solution, i.e. the vector $\mathbf{q}$ is the eigenvector. Since we have $C$ eigenvalues, here we also have $C$ eigenvectors. Use them to construct the eigenvector matrix $\mathbf{Q}_0$.
- We could make $\mathbf{Q}_0$ orthogonal. Solve $k$ from $k \mathbf{I} = \mathbf{Q}_0\mathbf{Q}_0^T$, then we could adjust the matrix by letting $\mathbf{Q} = \frac{1}{k}\mathbf{Q}_0$. Note that as an orthogonal matrix, $\mathbf{Q}^{-1} = \mathbf{Q}^T$.
Then we could define the whitening transformation as
Hence we could check that
We could know that the whitening transformation converts the features as a form that satisfies $\hat{\mathbf{y}}\hat{\mathbf{y}}^T = \mathbf{I}$. Also, we have the inverse transformation as
This is also named coloring transformation. It is easy to check that both sides equal to each other if we use $\eqref{fml:sec2:whitening}$ to substitute $\hat{\mathbf{y}}$ in $\eqref{fml:sec2:coloring}$.
In the application, we use a content image $\mathbf{x}_c$ and a style image $\mathbf{x}_s$. Then we perform the whitening transformation over $\mathbf{y}_c$ (the features of $\mathbf{x}_c$), and use $\mathbf{y}_s$ (the features of $\mathbf{x}_s$) to perform the coloring transformation. We would embed the style into the content features. This conjugated transformation is defined as WCT which could be formulated as
The $\eqref{fml:sec2:wct}$ is $O(1)$, which means it would be efficient to insert WCT into the auto-encoder.
Results
First we show the results that how the depth of the space influences the results. The following figure shows that although the WCT deeper space could transferring the style effectively, the details are lost. But we could add the details by stacking WCT auto-encoders in different depth.
| How the depth of the space influence the result |
|---|
And we also show the results compared with other works. Note that (c) [15] is from the previous work 2 and (e) [9] is from the previous work 1, which are discussed before.
| Results with comparisons |
|---|
Semi-supervised learning
This is a previous work. Check here to see the article Semi-Supervised Learning for Optical Flow with Generative Adversarial Networks:
Theory
This paper is mainly based on two works. The first one gives a back propagation policy for affine transformation; and the second one proposes the unsupervised learning strategy. This paper improve the effectiveness by introducing the Generative Adversarial Network (GAN) and involving the supervised learning.
Previous work: Differentiable interpolation
In this previous work, the author proposes a differentiable interpolation method so that we could perform back propagation on the parameters of this transform. To know the detail, check here to see Spatial Transformer Networks:
Check here to see Affine transformation in Wikipedia.
Denote $(x_{ij},~y_{ij})$ as a coordinate of a pixel of image $\mathbf{I}$, then we could attach every pixel with a linear affine transformation $\mathbf{W}_{ij}$. The transformed coordinate of this pixel is defined as $(\hat{x}_{ij},~\hat{y}_{ij})$, then the transformation could be formulated as:
If we have known a image $\mathbf{I}(t)$, its next frame $\mathbf{I}(t+1)$ and the linear transformation between two frames, i.e. $\hat{\mathbf{I}}(t+1) = \mathcal{W}(\mathbf{I}(t))$. Then we could inverse the transformation and use $(\mathbf{I}(t+1),~\mathcal{W})$ to deduce $\mathbf{I}_{\mathrm{warp}}(t)$, which could be formulated as
where we define $\mathrm{M}(\cdot)$ as $\max (0,~\cdot)$. If $(u_{ij},~v_{ij})$ are integers, every interpolated pixel is just from another pixel. We could use the following figure to illustrate it:
| Differentiable bilinear interpolation |
|---|
In this figure, we use blue blocks to represent the interpolated pixels and arrows to represent the linear transformation. In the right side, we use yellow blocks to represent the source pixels that are used to deduce the previous frame. There are 4 pixels in this examples, from the image we could know that every pixel in the prediction is taken from another pixel in the source, while a pixel in the source could be used to predict more than one pixel.
Although the author call $\eqref{fml:sec3:biinterp}$ as “bilinear interpolation”, in fact it looks like nearest interpolation more. Only when $(u,~v)$ are not integers could the transformation be called “bilinear”. It would be easy to calculate $\frac{\partial \mathbf{I}_{\mathrm{warp}}(x_{ij},~y_{ij},~t)}{\partial u_{ij}}$. Here we would not talk about it. If you are interested the formulated result, you could check the reference.
Previous work: unsupervised learning
This is another previous work. Check here to see the article Back to Basics: Unsupervised Learning of Optical Flow via Brightness Constancy and Motion Smoothness:
In this application, the transformation parameters discussed above are called “optical flow”, which means for a frame $\mathbf{I}(t)$, we have a flow map $(\mathbf{u},~\mathbf{v})$ in both of the horizontal and vertical directions. Each pixel of the frame $\mathbf{I}$ has two flow mapping parameters $(u,~v)$. The author uses FlowNet Simple to predict the flow map $(\mathbf{u},~\mathbf{v})$.
| FlowNet Simple structure |
|---|
The network accepts the input of two neighbor frames, compresses the image and up-samples feature maps by multiple stages. The features from each stage only have two channels, i.e. the $(\mathbf{u},~\mathbf{v})$. Which means they share the same physical meanings and the up-sampling layers could be viewed as interpolation layers. All features are used to calculate the unsupervised learning loss, which could be formulated as:
where we use $D_l^{Cn}$ to represent the $n^{\textrm{th}}$ channel of the $l^{\textrm{th}}$ layer of the up-sampling features (decoder output). The inputs are two neighbor frames $(\mathbf{I}(t),~\mathbf{I}(t+1))$ and the unsupervised loss function $\mathcal{L}$ for each layer is the same function which could be formulated as
$\ell_{p}$ is the photometric loss which could be also viewed as “warp loss”, because the loss is produced by the error between the frame $\mathbf{I}(t)$ and its predicted frame $\mathbf{I}_{\mathrm{warp}}(t)$.
And the $\ell_{s}$ is the smoothness loss, which is calculated by the directional gradient of the predicted flow maps:
The $\rho_D$ and $\rho_S$ are penalty functions. Both of them are generalized Charbonnier function while the parameters of the function may be different between the two cases. The general form could be formulated as
This work: semi-supervised learning
This work is based on using GAN. As we know, the GAN is composed of a generator network and a discriminator network. In this work, the generator is an auto-encoder which accepts two neighbor frames and outputs the predicted optical flow map. The discriminator is used to identify the warp error of the predicted flow. The network structure is like this:
| Network structure |
|---|
The core theory of the semi-supervised learning is that we use labeled data to train the discriminator $D$ and both labeled and unlabeled data to train the generator $G$. Therefore, the discriminator part is supervised learning while the generator part is unsupervised learning. Since we only use generator to produce the results that we need in application, this method could be reasonable.
The whole optimization could be defined as
The first part is the supervised learning loss, and the second part is the adversarial loss of the GAN network. Therefore, we train the discriminator and generator alternatively by using different targets.
First, we discuss the loss for optimizing the discriminator. Denote the input frames as $\mathbf{I}_t$ and $\mathbf{I}_{t+1}$, the predicted flow (two channels) of the generator could be defined as $\mathbf{g} = G(\mathbf{I}_t,~\mathbf{I}_{t+1})$. The ground truth of the flow of the frame $\mathbf{I}_t$ is $\mathbf{g}_0$, then we could define the warp loss map as
The loss map is also a picture. We use $\mathcal{W}$ to define the affine transformation, thus $\mathbf{y}$ represents the warp loss calculated by ground truth flow and $\hat{\mathbf{y}}$ is the warp loss calculated by predicted flow. This definition is similar to what we have done in $\eqref{fml:sec3:lossphoto}$. Then the discriminator loss could be:
Then let’s discuss the generator loss. It is a combination of the supervised learning and unsupervised learning. For supervised learning, we need to calculate the error between predicted map and the ground truth, i.e.
And the adversarial loss is only related to generated flow, which means
Then when we feed the labeled data to the network, we have the ground truth and use such loss:
When we feed the unlabeled data to the network, we only have the input. So we use such loss:
Results
First we show the numerical results of comparing the proposed method to other methods. The results show that the semi-supervised learning could achieve better performance than both supervised learning and unsupervised learning.
| Numerical comparison to other methods |
|---|
Then we show the illustrated results with comparison to other methods.
| Illustrated comparison to other methods |
|---|
Slides
View the slides here:


| Name | State | Status | Host | Provisioned Space | Used Space | Host CPU | Host Mem | Guest Mem | Notes | Alarm Actions | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| John | Powered On | Normal | Unknown | 100 GB | 100 GB | 550 | 8232 | 5 | Enabled | ||
| Mary | Powered On | Normal | Unknown | 70 GB | 30 GB | 570 | 2323 | 3 | Enabled | ||
| July | Powered On | Normal | Unknown | 30 GB | 73 GB | 580 | 3434 | 1 | Enabled | ||
| John | Powered On | Normal | Unknown | 100 GB | 100 GB | 550 | 8232 | 5 | Enabled | ||
| Mary | Powered On | Normal | Unknown | 70 GB | 30 GB | 570 | 2323 | 3 | Enabled | ||
| July | Powered On | Normal | Unknown | 30 GB | 73 GB | 580 | 3434 | 1 | Enabled |


where \(end value - start value\) is total change, and dividing by start value gives percent change. Note that end value does not have to be bigger than start value, in which case we have a decrease and not an increase. For example, if the number of arrests went down from 61,812 to 60,170, then the total change would be -1,642, which is a 1,642/61,812=0.0266=2.66% decrease (since \(0.0266 \cdot 100=2.66\)). Note that in this case we divided by 61,812 because that was the starting value, and the percent decrease is smaller than the percent increase, because the change of is the same in both cases, while the starting value is different.
in-context


DESIGN SHAMANISM OR HOW TO EMBRACE IRRATIONALITY AND DESIGN FOR SYSTEMIC CHANGE
Authors
Søren Rosenbak
Notes
Describes how the 'irrational' shaman can act as a gateway for design processes.
Field of Study
Concepts
Quotations
References
Methodology


MEXICAN, THE (director: Gore Verbinski; screenwriter: J.H. Wyman; cinematographer: Dariusz Wolski; editor: Craig Wood; cast: Brad Pitt (Jerry Welbach), Julia Roberts (Samantha Barzel), James Gandolfini (Leroy), David Krumholtz (Beck), Gene Hackman (Arnold Margolese-unbilled cameo), Luis Felipe Tovar (Luis), J.K. Simmons (Ted), Bob Balaban (Nayman), Richard Coca (Car Thief), Michael Cerveris (Frank), Sherman Augustus (Black Assassin); Runtime: 123; DreamWorks Picture; 2001)
Reviewed by Dennis Schwartz
This is a slight film as far as subject matter but it is richly endearing as a road movie that is a comedy-drama-romance-thriller rolled into one film, boasting big-time star power in Brad Pitt and Julia Roberts. It mostly roams between being a silly roughhouse crime caper and a film with some intimate moments shared through conversation.
The well-crafted story is about a special 19th century pistol called "The Mexican." It has a rich history attached to it that includes a curse. Screw up gofer, Jerry Welbach (Brad Pitt), is ordered by his milksop crime boss Nayman (Balaban) to bring the pistol back from Mexico, on orders from the big boss Arnold Margolese (Gene Hackman), who is currently in jail but expects to be released soon. He was captured when Jerry crashed into him in a minor traffic accident and Jerry has owed the mob favors ever since. Margolese makes it clear that he must possess this valuable item or else.
Jerry's girlfriend Samantha (Julia Roberts) has just told him that if he doesn't leave LA and go to Las Vegas with her they're through, as she has ambitions of being a croupier, but Jerry deems his life is worth more to him when alive, so he opts to go to the small town in Mexico to bring back the pistol and has been promised if he succeeds this will be his last job for the gang. The quarreling couple, who attend group counseling sessions posing as a married couple, have this intense love-hate relationship, where they are all-loving one moment yet in the next moment are arguing over any little thing. Jerry goes to Mexico as his clothes come streaming down to him in the street, thrown by Samantha from their 2nd floor balcony.
The biggest surprise in this offbeat, not quite Hollywoodish film, is that Pitt and Roberts will be separated for so long onscreen, being together briefly only in the first and last reels, but separated for the entire middle part, as the camera veers back and forth on their separate adventures in Mexico and Las Vegas. This long separation didn't disappoint me, but it might disappoint some who expected to see a more romantic story develop between the two stars.
In the more desolate spots in Mexico, Jerry finds the pistol easily enough in the hands of a drunken Beck (David Krumholtz), who quickly turns it over to him and willingly accompanies him back to LA. But the villagers are celebrating Independence Day, and an accidental shot kills him before he can get into the car. While Jerry is distracted, someone steals his rental car, with all his money, identification, and the pistol.
The film cuts back to Samantha driving to Las Vegas and while stopping off in a rest spot a black gunman assaults Samantha in the ladies' room, but he is shot by another gunman who kidnaps her and tells her his name is Leroy (James Gandolfini, of The Sopranos) and that he is holding her hostage until Jerry returns with the pistol. The chemistry between the soft-spoken but violent thug Leroy and the profane speaking but communicative Samantha, is a comic delight, as they share their love woes, with Samantha so proud of herself that she figured out that Leroy is gay. They further bond as they sympathize over their love woes: of him being a loser in love, with all his previous lovers leaving him, still surprised that anyone would like him, while she confesses she loves Jerry, but can't answer Leroy's question about when enough is enough in a love affair if you love the guy. Leroy will fall in love with a postal worker (Cerveris) on holiday and begins an intense romance that ends tragically.
Meanwhile, back in Mexico, Jerry finds himself looking everywhere for the pistol but he is having difficulty getting around because he can't speak Spanish. He finally recovers the pistol from the car thief and his gang, then loses it again to a corrupt cop, then gets it back again with help from Ted (J.K. Simmons), one of Nayman's dullish agents, whom Jerry considers his best friend in the gang, who talks of retirement soon and thinks like a government worker who has a secure job and will do nothing to mess up his impending retirement plans, willing to follow orders even if he finds them distasteful. Jerry becomes suspicious of why he is down here when he overhears a conversation between him and Nayman.
After the madcap chase through northern Mexico, the unbilled Gene Hackman as the criminal kingpin, explains the true legend of the hand-crafted pistol, which has previously had a number of false stories told about it, and he also puts an exclamation point on why he wants the pistol and why he asked for a bumbler like Jerry to go on this wild chase. The story got a little out of hand and Hackman does his best to clear things up, as he ties up all the loose ends.
Director Gore Verbinski (Mouse Hunt) does a nice job tightening up this rambling story when it needed it and keeping the action flowing, though a few of the comedy scenes, such as the one that opens the film, seemed contrived. Brad Pitt is as loose as a goose playing the part of a jerky small time hood with enough smarts to keep alive through all this adventure and series of betrayals. He successfully plays his part strictly for the comedy. Julia Roberts plays a familiar part to her by now, of someone who doesn't have all her smarts, who is very likable when sticking to her work-type characterization of someone trying to get in touch with her feelings through reading self-help books and having conversations about sensitive topics. Her chemistry is very good with Pitt, but is sensational with Gandolfini, as they provide the film with its main stimulus of comedy, rauchiness, violence, and good conversation. All these characters were well-defined and screenwriter J.H. Wyman deserves much of the credit for that, as he also embellished the story with excellent dialogue and enough plot twists and surprises to keep crime film buffs guessing at what happens next. While cinematographer Dariusz Wolski's location shots of the beautiful mountain town of Real de Catorce were spectacular and made this a very pleasing mainstream film to view.
REVIEWED ON 3/10/2001 GRADE: B
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Grinham, J., Alvarenga,J., Bechthold, M, Aizenberg, J.“Hydrophobic Barrier Layer for Ceramic Indirect Evaporative Cooling Systems” PCT/US2019/54230 PP2018/62/740,221
Grinham, J., Craig, S. Ingber, D. Bechthold, M. “Radiant Cooling Devices and Methods of Forming the Same" PCT/US2018/041473 PP2017/62/530,394
Grinham, J. Fjeldheim, H., Yan, B., Dokka, T. H., Hegli, T., and Malkawi, A.“Zero-carbon Balance: The Case of HouseZero” Building and Environment, in Review.
Grinham, J. Hancock, M., Kumar, K., Bechthold M., Ingber D. E., and Aizenberg, J.“Bioinspired Design for Thin Film Wearable and Building Cooling System.” Journal Bioinspiration and Biomimetics, in Review.
Kharbanda, Chen, Grinham “Early Stage Design LCA Calculation Framework within Grasshopper” Proceedings of the ACLCA 2021 Conference, 2021.
Jensen, A., Norford, L., Grinham, J. “Mass(Ive) Timber: Examining the Thermally Massive Behavior of Mass Timber Construction.”Technology|Architecture + Design 4, no. 2, 2020: 186–99.
Grinham, Jonathan, Craig S., Ingber D. E., and Bechthold M. “Origami Microfluidics for Radiant Cooling with Small Temperature Differences in Buildings.” Applied Energy 277, 2020: 115610.
Seibold, Z., Grinham, J., Geletina, O., Ahanotu, O., Sayegh, A., Weaver, J.,Bechthold, M. “Fluid Equilibrium: Material Computation in Ferrofluidic Castings” Proceedings of the 38th Annual Conference of the Association for Computer Aided Design in Architecture (ACADIA), Mexico City, Mx 2018
Craig, S. and Grinham, J. “Wood Enclosures Engineered as Heat Exchangers” in: “Wood Urbanism: From the Molecular to the Territorial”, K. Moe, J. Hutton, D. Ibañez (Eds.) Actar. 2017
Craig, S. and Grinham, J. "Breathing walls: The design of porous materials for heat exchange and decentralized ventilation", Energy and Buildings, vol. 149, 2017: pp. 246-259.
Mesa, O., Grinham. J., Mhatre, S., Norman, S., Stavric, M., Sayegh, A., and Bechthold, M.: Non-Linear Matters: Auxetic Surfaces.Proceedings of the 37th Annual Conference of the Association for Computer Aided Design in Architecture (ACADIA), Cambridge, Ma, 2017: 392- 403.
Grinham, J. “The Vascularization of Buildings: Micro- to Milli-Scale Flow Systems for Heating and Cooling in the Built Environment” Doctor of Design Dissertation, Harvard University, February 2017
Grinham, J., Blabolil,B., Haak, J., “Harvest Shade Screens: Programming material for optimal energy building skins” Proceedings of 2014 ACADIA Conference, Los Angeles, CA, October 2014: 281-290 RPT.Proceedings of 9th Energy Forum 2014 on Advanced Building Skins, Bressanone, Italy, October 2014
Grinham, J. "Small Digital: A Case Study in Digital Design at Scale" in Cook, C., Ray, T., Burke, J., Zelov, Z., Grinham, J., "Fragment 05: Union Station Bus Terminal" Washington DC, 2014
Frostén, I., Grinham, J., Ku, K., “A Pedagogical Exploration of an Open-Source Architecture Paradigm in the Responsive Design Studio” Proceedings of the 101th ACSA Annual Meeting Conference, 2014 ACSA/AIK International Conference, Seoul, South Korea, June 2014: pp-pp
King, N., Grinham, J., Pender, S., Vroman, R., Clark, C., “Beyond Digital Steroids: A Pedagogical Approach to Foundation Design Education though Design Robotics” Proceedings of the 101th ACSA Annual Meeting Conference, 2014 ACSA/AIK International Conference, Seoul, South Korea, June 2014: pp-pp
King, N., Grinham, J., Saladik, D., Ricks, A., Murphy, M., “Crafting Eclipses: Integrating Computational Design and Automation through Programmed Craft-Based Fabrication in the Developing World” Proceedings of the 101th ACSA Annual Meeting Conference, 2014 ACSA/AIK International Conference, Seoul, South Korea, June 2014: pp-pp
Dunay, R., Wheeler, J., Schubert, R., Grinham, J., “Eclipsis: A Historic Precedent - Digital Fabrication” Proceedings of the 101th ACSA Annual Meeting Conference, March 21-24, San Francisco, 2013.
King, N., and Grinham, J., “Automating Eclipsis: Robotic Fabrication of Optimized Custom Metal Shutter Systems” Proceedings of the Rob|Arch 2012 conference, Vienna, Austria, December 2012: 52-59
Dunay, R., Wheeler, J., Schubert, R., Clark, D., Grinham, J., “LumenHaus and the Eclipsis System: Historical Concept and Modern Technology” JAU: Journal of Asian Urbanism, no. 5 2011: 32-37.
Grinham, J. and Ku, K., “4D Environments and Design: Towards an Appliance Architecture Paradigm” Proceedings of the 100th ACSA Annual Meeting Conference, March 1-4, 2012, Boston, MA. RPT ARCC Spring 2013 Newsletter, Volume 37, Issue 1, Spring, 2013.
Grinham, J., “Appliance Architecture in the Invisible College: a Pedagogical Text”, Masters Thesis Virginia Tech, Blacksburg, 2011.
Grinham, J., Ku, K., Kalantar, N., “a2o: Responsive Mediator” 2A: Architecture and Art, no. 14, 2011: 96-102.
Grinham, J., Ku, K., Kalantar, N., “Interactive ‘Ornament’: the Agents of Responsive Mediators” 2A: Architecture and Art, no. 16, 2010: 86-84.
Back


Test::Float Namespace Reference
Testing domain floats. More...
Namespaces | |
| namespace | Arithmetic |
Tests for arithmetic constraints | |
| namespace | Basic |
Tests for basic setup | |
| namespace | Channel |
Tests for channel constraints | |
| namespace | Dom |
Tests for domain constraints | |
| namespace | Linear |
Tests for linear constraints | |
| namespace | MiniModelLin |
Tests for minimal modeling constraints (linear) | |
| namespace | Rel |
Tests for relation constraints | |
| namespace | Transcendental |
Tests for transcendental constraints | |
| namespace | Trigonometric |
Tests for trigonometric constraints | |
Classes | |
| class | Assignment |
| Base class for assignments More... | |
| class | CpltAssignment |
| Generate all assignments. More... | |
| class | ExtAssignment |
| Generate all assignments except the last variable and complete it to get a solution. More... | |
| class | RandomAssignment |
| Generate random selection of assignments. More... | |
| class | TestSpace |
| Space for executing tests. More... | |
| class | Test |
| Base class for tests with float constraints More... | |
| class | FloatRelTypes |
| Iterator for float relation types. More... | |
Enumerations | |
| enum | MaybeType { MT_FALSE = 0, MT_TRUE, MT_MAYBE } |
Type for comparisons and solutions. More... | |
| enum | AssignmentType { CPLT_ASSIGNMENT = 0, RANDOM_ASSIGNMENT, EXTEND_ASSIGNMENT } |
Assignment possible types. More... | |
Functions | |
| Gecode::FloatNum | randFValDown (Gecode::FloatNum l, Gecode::FloatNum u) |
| Gecode::FloatNum | randFValUp (Gecode::FloatNum l, Gecode::FloatNum u) |
| MaybeType | operator& (MaybeType a, MaybeType b) |
| Three-valued conjunction of MaybeType. |
Detailed Description
Testing domain floats.
Enumeration Type Documentation
Assignment possible types.
Function Documentation
| Gecode::FloatNum Test::Float::randFValDown | ( | Gecode::FloatNum | l, | |
| Gecode::FloatNum | u | |||
| ) |
| Gecode::FloatNum Test::Float::randFValUp | ( | Gecode::FloatNum | l, | |
| Gecode::FloatNum | u | |||
| ) |


|
|
| Name |
Nayanajith Priyasad |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94764863458 |
| Ratings |
|
|
|
|
| Name |
Dulmi Shanika |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94778454494 |
| Ratings |
|
|
|
|
| Name |
Viraj Nawarathne |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94784868768 |
| Ratings |
|
|
|
|
| Name |
Ravisha Sathru |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94712357364 |
| Ratings |
|
|
|
|
| Name |
Samitha Nishan |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94724567987 |
| Ratings |
|
|
|
|
| Name |
Ravi Madushan |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94776757846 |
| Ratings |
|
|
|
|
| Name |
Praneeth Deemantha |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94714387677 |
| Ratings |
|
|
|
|
| Name |
Hasaranga Pathirana |
| Email |
<EMAIL_ADDRESS>|
| Phone |
+94778728546 |
| Ratings |
|
|


The Bloom Date
The Bloom Date
HOME
My Profile
Logout
Set up Your Profile
Choose Your Country
Nigeria
Ghana
South Africa
Choose Your State
Bayelsa
Delta
Lagos
Choose Your Tribe
Ijaw
Yoruba
Hausa
Fulani
Choose Your Gender
Female
Male
Choose Your State of Residence
Bayelsa
Lagos
Abia
Kano
How did you hear about The Bloom Date
Facebook
Instagram
Whatsapp
Ad on my phone
Tv
Other
I agree to the
terms
and conditions.
Back
Next
Finish


FOOMATIC-COMPILEDB
Section: User Commands (1)Updated: 2001-05-07
Index Return to Main Contents
NAME
foomatic-compiledb - Compile the Foomatic printer/driver databaseSYNOPSIS
foomatic-compiledb [ -t type ] [ -f ] [ -j n ] [ driver ... ]DESCRIPTION
foomatic-compiledb generates all PPD files or Foomatic combo XML files for all possible printer/driver combos, or only for a selected range of drivers. It generally should not be necessary except for people who want to generate a set of Foomatic data files for distribution. For configuring single printers foomatic-ppdfile(1) and especially foomatic-configure(1) will automagically compute just what they need.Options
- -t type
-
Output file type, either ppd or xml.
- -f
-
Force: Write into the destination directory even if it already exists.
- -j n
-
n = number of work processes to run
- driver ...
-
only generate data files for these driver(s)
SEE ALSO
foomatic-ppdfile(1),foomatic-configure(1)EXIT STATUS
foomatic-compiledb returns 0 unless something unexpected happens.AUTHORS
Manfred Wassmann<EMAIL_ADDRESS>and Till Kamppeter<EMAIL_ADDRESS>for the foomatic project using output from the associated binary.BUGS
Existing files are always conserved instead of older files being overwritten. So deleting the destination directory (rm -rf dir) and calling foomatic-compiledb without the -f option is recommended.Please post bug reports on
http://lists.freestandards.org/mailman/listinfo/printing-foomatic
Index
This document was created by man2html, using the manual pages.
Time: 05:29:03 GMT, December 24, 2015


The following sample is a demonstration of how to call WebHelp Context-Sensitively from a web page. Any information found this sample may also be found in the RoboHelp documentation and I would highly suggest reading the documentation regarding the WebHelp API call before trying to implement context-sensitive help within your application or web site.
The examples contained in this document show only one of the many possible ways to link to a WebHelp system.


{% trans %} Development on the Sunbird project has halted and its final release was on March 30, 2010. We've been proud to host Sunbird add-ons on this site but as the project is no longer maintained we have disabled our support for the add-ons. {% endtrans %}
{% trans tb_url="https://www.mozilla.org/en-US/thunderbird/", lightning_url="https://addons.mozilla.org/thunderbird/addon/2313/" %} We recommend upgrading to Thunderbird and Lightning. {% endtrans %}


Enter a 16-byte encrypted message and a key in hex format to decrypt the message using the AES algorithm. Key sizes up to 256-bit are supported.


|
src/app/admin/cancel/cancel-detail/cancel-detail.component.ts
|
component
|
CancelDetailComponent
|
0 %
(0/6)
|
|
src/app/admin/cancel/cancel.component.ts
|
component
|
CancelComponent
|
0 %
(0/6)
|
|
src/app/admin/main/main.component.ts
|
component
|
MainComponent
|
0 %
(0/6)
|
|
src/app/admin/manage/admin-manage/admin-manage.component.ts
|
component
|
AdminManageComponent
|
0 %
(0/8)
|
|
src/app/admin/manage/manage.component.ts
|
component
|
ManageComponent
|
0 %
(0/3)
|
|
src/app/admin/manage/section-manage/section-manage.component.ts
|
component
|
SectionManageComponent
|
0 %
(0/11)
|
|
src/app/admin/punish/punish.component.ts
|
component
|
PunishComponent
|
0 %
(0/6)
|
|
src/app/admin/report/report-detail/give-punish/give-punish.component.ts
|
component
|
GivePunishComponent
|
0 %
(0/8)
|
|
src/app/admin/report/report-detail/report-detail.component.ts
|
component
|
ReportDetailComponent
|
0 %
(0/8)
|
|
src/app/admin/report/report.component.ts
|
component
|
ReportComponent
|
0 %
(0/6)
|
|
src/app/admin/shared/component/navbar/navbar.component.ts
|
component
|
NavbarComponent
|
0 %
(0/3)
|
|
src/app/app.component.ts
|
component
|
AppComponent
|
0 %
(0/2)
|
|
src/app/dev/dev.component.ts
|
component
|
DevComponent
|
0 %
(0/5)
|
|
src/app/main/main-dashboard/main-dashboard.component.ts
|
component
|
MainDashboardComponent
|
0 %
(0/14)
|
|
src/app/main/main.component.ts
|
component
|
MainComponent
|
0 %
(0/3)
|
|
src/app/mypage/booking-item/booking-item.component.ts
|
component
|
BookingItemComponent
|
0 %
(0/15)
|
|
src/app/mypage/mypage.component.ts
|
component
|
MypageComponent
|
0 %
(0/7)
|
|
src/app/report/report.component.ts
|
component
|
ReportComponent
|
0 %
(0/13)
|
|
src/app/shared/component/footer/footer.component.ts
|
component
|
FooterComponent
|
0 %
(0/3)
|
|
src/app/shared/component/navbar/navbar.component.ts
|
component
|
NavbarComponent
|
0 %
(0/9)
|
|
src/app/shared/component/usage-graph/usage-graph.component.ts
|
component
|
UsageGraphComponent
|
0 %
(0/20)
|
|
src/app/shared/guard/admin.guard.ts
|
injectable
|
AdminGuard
|
0 %
(0/2)
|
|
src/app/shared/guard/login.guard.ts
|
injectable
|
LoginGuard
|
0 %
(0/2)
|
|
src/app/shared/http/admin.service.ts
|
injectable
|
AdminService
|
0 %
(0/6)
|
|
src/app/shared/http/booking.service.ts
|
injectable
|
BookingService
|
0 %
(0/9)
|
|
src/app/shared/http/login.service.ts
|
injectable
|
LoginService
|
0 %
(0/3)
|
|
src/app/shared/http/punish.service.ts
|
injectable
|
PunishService
|
0 %
(0/4)
|
|
src/app/shared/http/report.service.ts
|
injectable
|
ReportService
|
0 %
(0/5)
|
|
src/app/shared/http/section.service.ts
|
injectable
|
SectionService
|
0 %
(0/7)
|
|
src/app/shared/service/global.service.ts
|
injectable
|
GlobalService
|
0 %
(0/3)
|


ClassyLoupe
Zooming images, the fun way!
Introduction
ClassyLoupe is a jQuery plugin written by Marius Stanciu - Sergiu, a plugin that gives you the ability to add zoom on hover ability for your photos with single line of code.
With ClassyLoupe you have the ability to control the zoom level and loupe size via mouse scroll which gives you the opportunity to enlarge areas that you might be interested in.
License
This jQuery plugin is distributed under the MIT license. Enjoy!Setup
First you need to include the jQuery library, since ClassyLoupe is a plugin. You can download it from the jQuery website or link it directly from the Google CDN. Also, you'll need the jquery.mousewheel and jquery.easing plugins, and those files are already in the package ready to be included.

Secondly, you need to include the jQuery ClassyLoupe javascript and the css file into your page. You can do it by adding the code below to your page.
 <link rel="stylesheet" type="text/css" href="css/jquery.classyloupe.min.css" />
Next, you implement the actual image(s) that will be magnified/zoomed by the Loupe. The structure is as simple as it can get.

As the last step, you trigger the ClassyLoupe() function on the element you just created. In this case, we trigger the function on the image with the class louped.
$('.louped').ClassyLoupe({ maxSize: 600, loupeToggleSpeed: 'fast' });
Options
-
Parameters
- shape - the shape of the loupe, can be circle, rounded or square, default is circle
- glossy - if the loupe is glossy or not, can be true or false, default is true
- shadow - if the loupe will have a drop-shadow effect, can be true or false, default is true
- trigger - the mouse event that will trigger the loupe effect, default is mouseenter
- roundedCorners - does the loupe have rounded corners (if square shape), default is 10
- size - loupe size, width and height, default is 200
- minSize - minimul loupe size, default is 150
- maxSize - maximum loupe size, default is 250
- resize - can be true or false, default is true
- sizeSnap - , default is 10
- canZoom - can be true or false, default is true
- zoom - , default is 100
- minZoom - , default is 50
- maxZoom - , default is 200
- zoomSnap - , default is 5
- overlay - can be true or false, default is true
- overlayOpacity - , default is 0.5
- overlayClassName -
Example
$('#loupe2').ClassyLoupe({ overlayClassName: 'overlay_img', shape: 'rounded', size: 160, minSize: 200, maxSize: 400, sizeSnap: 25, canZoom: false });
$('#loupe5').ClassyLoupe({ size: 160, overlay: false, shape: 'rounded', canZoom: false, resize: false });


Running a model
An online queue is used to coordinate the task of formulating and solving mathematical programs. Users submit parameters to the queue which creates a new 'job'. A pool of 'workers' monitor this queue for new jobs. If a worker is available (i.e. it is not currently processing a job) it will pick the job off the queue and then formulate and solve a mathematical program using the inputs provided. The worker then posts the optimisation model's results back to the queue, and marks the job as 'finished'. Results can then be accessed by the user.
This notebook describes how to submit a case file parameters and retrieve results from the queue.
Imports and authentication
import os
import json
import requests
import xmltodict
import pandas as pd
import IPython.display as display
First specify the base URL for API calls.
# Base URL endpoint for the Dispatch API
base_url = 'http://nemde-api-host:8080/api/v1/'
Load case file
Case files contain parameters used by the NEMDE when determining dispatch targets for generators and loads. The API uses selected inputs from these case files when formulating a mathematical program that approximates the NEMDE's operation (see the parameter reference page for a description of the inputs used).
Each case file is identified by a case ID, e.g.<PHONE_NUMBER>1
, which has the following format:
{year}{month}{day}{interval_id}
Interval IDs range from 001-288 and are used to identify each 5 minute interval within a 24 hour period.
As each trading day begins at 4.00am, the case ID<PHONE_NUMBER>1
corresponds to the trading interval which starts at 2020-11-01 04:00:00
and ends at 2020-11-01 04:05:00
. When NEMDE is run at approximately 04:00:00
it produces dispatch targets that generators and loads should meet at 04:05:00
. The following table illustrates the mapping between case IDs and the start and end times for selected dispatch intervals.
| Case ID | Interval start | Interval end |
|---|---|---|
|<PHONE_NUMBER>1 | 2020-11-01 04:00:00 | 2020-11-01 04:05:00 |
|<PHONE_NUMBER>2 | 2020-11-01 04:05:00 | 2020-11-01 04:10:00 |
|<PHONE_NUMBER>3 | 2020-11-01 04:10:00 | 2020-11-01 04:15:00 |
| ... | ... | ... |
|<PHONE_NUMBER>7 | 2020-11-02 03:50:00 | 2020-11-02 03:55:00 |
|<PHONE_NUMBER>8 | 2020-11-02 03:55:00 | 2020-11-02 04:00:00 |
The following function loads a case file in XML format and converts it to a Python dictionary.
def convert_casefile(path_to_file):
"""Load a historical NEMDE case file and convert it to a dict"""
# Read case file contents
with open(path_to_file, 'r') as f:
casefile = f.read()
# Force these nodes to always return lists
force_list = ('Trade', 'TradeTypePriceStructure',)
return xmltodict.parse(casefile, force_list=force_list)
casefile = convert_casefile('../../data/NEMSPDOutputs_2021040100100.loaded')
Case file components
Case files describe the state of the system at the start of a dispatch interval, and also include forecasts for demand and intermittent generation at the end of the interval. A nested data structure, in this case a Python dictionary, organises data into logical components.
Those familiar with NEMDE case files in XML format may recognise the following data structure. In fact, the dictionary is obtained by converting a NEMDE case file in XML format to a Python dictionary. See this tutorial to learn how to convert your own NEMDE XML files into a format that can be consumed by the Dispatch API.
At the dictionary's root there is a single key, NEMSPDCaseFile
:
casefile.keys()
odict_keys(['NEMSPDCaseFile'])
The dictionary can be traversed by 'getting' the value for a given key, in this case NEMSPDCaseFile
, and looking at its constituent components. Here we can see there are three nested keys:
casefile.get('NEMSPDCaseFile').keys()
odict_keys(['NemSpdInputs', 'NemSpdOutputs', 'SolutionAnalysis'])
| Key | Description |
|---|---|
| NemSpdInputs | Parameters describing the system's state |
| NemSpdOutputs | NEMDE solution for each trader (generator / load), generic constraint, interconnector, and region |
| SolutionAnalysis | Price setting results |
While NEMDE case files provide a convenient data structure describing parameters used to set dispatch targets, there are a limitations associated with their design. For instance, some parameters are duplicated, while others may be ignored. Users seeking to modify case files should consult the parameter reference page to see which parameters can be meaningfully modified when using the Dispatch API.
Submitting a job
For now let's run the case file without modifying any of its components. The body of the request is simply a dictionary with "casefile"
as the key, and the case file dictionay as its corresponding value:
body = {"casefile": casefile}
A POST request is submitted to https://dispatch.envector.com/api/v1/jobs/create
The response contains information pertaining to the newly created job, including a job ID which will be used when querying results once they become available.
def submit_casefile(base_url, casefile):
"""Submit case file to the job queue"""
# Construct request body and URL
body = {'casefile': casefile}
url = base_url + 'jobs/create'
# Send job to queue and return job meta data
response = requests.post(url=url, json=body)
return response.json()
# Submit job and inspect meta data
job_info = submit_casefile(base_url=base_url, casefile=casefile)
job_info
{'job_id': '77b379d4-26e6-401b-8152-ca2e5482c658',
'created_at': '2021-08-07T13:38:20.741817Z',
'enqueued_at': '2021-08-07T13:38:20.884427Z',
'timeout': 180,
'status': 'queued',
'label': None}
A pool of workers monitor the queue to which the job is posted. If a worker is available it will formulate and run the optimisation model using the inputs provided. Results are then posted back to the queue for retrieval by the user.
The following URLs become available once a job has been submitted, allowing users to check the job's status, examine job results, or delete the job:
| URL | Description |
|---|---|
http://nemde-api-host/api/v1/jobs/{job_id}/status |
Get job status |
http://nemde-api-host/api/v1/jobs/{job_id}/results |
Get job results |
http://nemde-api-host/api/v1/jobs/{job_id}/delete |
Delete job |
For example, if the job ID is 04c66262-6144-444d-98bf-00c21cb955dd
, the URL to get the job's status would be:
http://nemde-api-host/api/v1/jobs/04c66262-6144-444d-98bf-00c21cb955dd/status
Let's check the job's status.
def check_job_status(base_url, job_id):
"""Check job status given a job ID"""
url = base_url + f'jobs/{job_id}/status'
return requests.get(url=url).json()
# Check job status
job_id = job_info.get('job_id')
check_job_status(base_url=base_url, job_id=job_id)
{'job_id': '77b379d4-26e6-401b-8152-ca2e5482c658',
'status': 'started',
'created_at': '2021-08-07T13:38:20.741817',
'enqueued_at': '2021-08-07T13:38:20.884427',
'started_at': '2021-08-07T13:38:21.221078',
'ended_at': None,
'timeout': 180,
'label': None}
We can see a worker has started to process the job. It typically takes 30s for a worker to complete a job once started. After waiting a short period we can check the status again.
check_job_status(base_url=base_url, job_id=job_id)
{'job_id': '77b379d4-26e6-401b-8152-ca2e5482c658',
'status': 'finished',
'created_at': '2021-08-07T13:38:20.741817',
'enqueued_at': '2021-08-07T13:38:20.884427',
'started_at': '2021-08-07T13:38:21.386579',
'ended_at': '2021-08-07T13:39:12.951867',
'timeout': 180,
'label': None}
Retrieving results
Once the job has finished we can access its results.
def get_job_results(base_url, job_id):
"""Extract job results from the queue"""
url = base_url + f'jobs/{job_id}/results'
response = requests.get(url=url)
return response.json()
# Get job results from the queue
results = get_job_results(base_url=base_url, job_id=job_id)
Note: completed jobs are only retained in the queue for 2 hours, at which point the job (and results) are deleted.
The value corresponding to the results
key contains the solution reported by the worker. Let's use Pandas to examine the output.
region_solution = results.get('results').get('output').get('RegionSolution')
# Convert to markdown to display results
region_solution_md = pd.DataFrame(region_solution).to_markdown(index=False)
display.Markdown(region_solution_md)
| @RegionID | @CaseID | @Intervention | @EnergyPrice | @DispatchedGeneration | @DispatchedLoad | @FixedDemand | @NetExport | @SurplusGeneration | @R6Dispatch | @R60Dispatch | @R5Dispatch | @R5RegDispatch | @L6Dispatch | @L60Dispatch | @L5Dispatch | @L5RegDispatch | @ClearedDemand |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| NSW1 |<PHONE_NUMBER>1 | 0 | 38.2172 | 5127.54 | 200 | 6330.79 | -1403.26 | 0 | 261 | 251 | 141 | 88 | 91 | 142 | 67 | 33 | 6576.14 |
| QLD1 |<PHONE_NUMBER>1 | 0 | 32.25 | 6278.72 | 0 | 5322.13 | 956.591 | 0 | 75 | 53 | 107.915 | 23.2 | 0 | 0 | 0 | 59.875 | 5362.13 |
| SA1 |<PHONE_NUMBER>1 | 0 | 37.2465 | 810.756 | 10 | 1065.3 | -264.539 | 0 | 142.829 | 77.5837 | 121 | 54.8 | 137 | 69 | 86 | 57.125 | 1077.47 |
| TAS1 |<PHONE_NUMBER>1 | 0 | 31.7702 | 1224.95 | 0 | 991.98 | 232.971 | 0 | 33 | 82.2457 | 0 | 49 | 56.166 | 152.495 | 50 | 50 | 996.513 |
| VIC1 |<PHONE_NUMBER>1 | 0 | 34.4678 | 4729.57 | 0 | 4134.2 | 595.377 | 0 | 105 | 153 | 98 | 5 | 25 | 31 | 52.5805 | 10 | 4159.28 |
interconnector_solution = results.get('results').get('output').get('InterconnectorSolution')
# Convert to markdown to display results
interconnector_solution_md = pd.DataFrame(interconnector_solution).to_markdown(index=False)
display.Markdown(interconnector_solution_md)
| @InterconnectorID | @CaseID | @Intervention | @Flow | @Losses | @Deficit |
|---|---|---|---|---|---|
| N-Q-MNSP1 |<PHONE_NUMBER>1 | 0 | -97 | 5.32865 | 0 |
| NSW1-QLD1 |<PHONE_NUMBER>1 | 0 | -819.585 | 65.3249 | 0 |
| T-V-MNSP1 |<PHONE_NUMBER>1 | 0 | 228.438 | 4.53231 | 0 |
| V-S-MNSP1 |<PHONE_NUMBER>1 | 0 | 63 | 0.102114 | 0 |
| V-SA |<PHONE_NUMBER>1 | 0 | 203.717 | 8.27106 | 0 |
| VIC1-NSW1 |<PHONE_NUMBER>1 | 0 | 532.012 | 24.9029 | 0 |
trader_solution = results.get('results').get('output').get('TraderSolution')
# Convert to markdown to display results
trader_solution_md = pd.DataFrame(trader_solution).head().to_markdown(index=False)
display.Markdown(trader_solution_md)
| @TraderID | @CaseID | @Intervention | @EnergyTarget | @R6Target | @R60Target | @R5Target | @R5RegTarget | @L6Target | @L60Target | @L5Target | @L5RegTarget | @R6Violation | @R60Violation | @R5Violation | @R5RegViolation | @L6Violation | @L60Violation | @L5Violation | @L5RegViolation | @RampUpRate | @RampDnRate | @FSTargetMode |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| AGLHAL |<PHONE_NUMBER>1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 720 | 720 | 0 |
| AGLSOM |<PHONE_NUMBER>1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 480 | 480 | 0 |
| ANGAST1 |<PHONE_NUMBER>1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 840 | 840 | nan |
| APD01 |<PHONE_NUMBER>1 | 0 | 0 | 31 | 90 | 45 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | nan | nan | nan |
| ARWF1 |<PHONE_NUMBER>1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1200 | 600 | nan |
Summary
This tutorial demonstrates the basic functionality of the Dispatch API. Two key components have been introduced: the ability to interact with historical case files, and methods that facilitate interaction with an online queue. Future tutorials will discuss how to modify case files, perform scenario analyses, and also introduce more advanced workflows using additional Dispatch API features.


Overrated or Nah
Overrated or Nah is a culture site dedicated to answering the age-old question: Is this overrated, or nah? Places to eat, the latest tech, fashion trends, cities around the world, we want to know if you feeling some type of way.
Simply click one of the three options (Overrated, Underrated, or IDK) to cast your votes. We keep track of all the data and let you know what's hot.
To see the most up-to-date power rankings, click "Rankings" above.
Overrated or Nah was founded by Aaron Tian, Matia Mearns, Juan Pablo Quintero, Brette Connolly, and Chahat Chadha and built with huge help from William Holley IV.
We are currently based out of New York City, though we’re looking to represent the whole world. To learn more about who we are and some frequently asked questions about Overrated Or Nah, see "About Us" above.
To start, click "Play" above!


Implements interfaces:
An adapter class for Zend_Http_Client based on the curl extension.
Curl requires libcurl. See for full requirements the PHP manual: http://php.net/curl
Located in /Http/Client/Adapter/Curl.php (line 48)
Stream for storing output
Parameters array
What host/port are we connected to?
The curl session handle
List of cURL options that should never be overwritten
Response gotten from server
Adapter constructor
Config is set using setConfig()
Close the connection to the server
Initialize curl
Retrieve the array of all configuration options
Get cUrl Handle
Return read response from server
Header reader function for CURL
Set the configuration array for the adapter
Direct setter for cURL adapter related options.
Set output stream for the response
Send request to the remote server
Documentation generated on Wed, 25 Aug 2010 03:43:41 +0400 by phpDocumentor 1.4.2


---
layout: post
title: How to force all your outgoing DNS queries to go through a pihole
categories: [privacy,security,pihole,network,dns]
tags: [Linux,network,privacy]
status: publish
type: post
published: true
comments: true
meta:
_edit_last: '1'
---
The Pi-hole
I've been having great success with my pi-hole. For those unaware of what pi-hole is, it is a DNS black-hole tailored to run on the rasperry pi.
The way it works is, you set it up as the upstream DNS in your DHCP server (which is usually your router) and then when clients ask for an IP address the router also tells them to use the pi-hole as their upstream DNS.
So what happens now, is when a machine on your network asks for a domain like "google.com" the pi-hole receives it checks it against its list of malicious and tracker domains and then happily forwards it up to the real upstream DNS server (in my case CloudFlare)
However, when a website tries to pull down some file like "https://someadnetwork.biz/tracker.js", the pihole will receive the DNS lookup for `someadnetwork.biz`, recognize it as a tracking domain and just pretend it cannot find it.
This will result in a significant reduction in ads you see on most websites and a snappier experience as the amount of traffic is reduced. In my case, I saw a rate of 14% of all DNS queries being blocked by my pi-hole. 14%!
The Problem
When you have good quality standard computer hardware, things work out just as outlined above. Proper network devices will honor the settings given to them by the DHCP server and use your pi-hole as their upstream DNS allowing it to filter their DNS requests.
Unfortunately in the ad-revenue-driven world of subsidized devices from Amazon and Google (to name two of many), the cost of the device is heavily subsidized by the manufacturer by means of collecting, storing and selling the ever-living-sh*t out of everthing
they can. Sadly I am forced to have a few of these devices running on my network and I keep them pretty isolated, however I was noticing that I was still receiving ads on these devices and seeing some strange outbound traffic from them. I realized they were
not playing nice, totally disregarding my configured upstream DNS and instead were using their own company's DNS (<IP_ADDRESS> in Google's case). This is one way these companies manage to transparently track more and more of what you do and have it cost them very little.
Google DNS servers store and track every request made to them and you can bet they are cross referenced back to your device and accounts
The Solution (mostly)
There are other ways, but the easiest way is to use a firewall (in my case iptables) I have a Netlink router running the tomato firmware. With this tool we can break down what we want to:
- All outgoing DNS requests (port 53) from any hosts (other than the pi-hole) should be redirected to the pi-hole.
- All outgoing DNS requests (port 53) coming from the pi-hole should be allowed.
Assuming your pi-hole's IP address is for example <IP_ADDRESS>, what I ended up with is something like this.
iptables -t nat -A POSTROUTING -j MASQUERADE
iptables -t nat -I PREROUTING -i br+ ! -s <IP_ADDRESS> -p tcp --dport 53 -j DNAT --to <IP_ADDRESS>:53
iptables -t nat -I PREROUTING -i br+ ! -s <IP_ADDRESS> -p udp --dport 53 -j DNAT --to <IP_ADDRESS>:53
Notes:
-i br+
apply to all bridged traffic (this may be different if your router's nic card are named differently?)
-p tcp and -p udp
apply to tcp and udp
! -s <IP_ADDRESS>
apply to all ips except for <IP_ADDRESS>
To make this work on Tomato go to Administration > Scripts > Firewall and paste the above 3 lines (with the ip updated) and hit save.
After doing this, my pi-hole went from blocking 14% of all DNS requests to about 24% (a ludicrous amount in my professional opinion). Success! Even more of my devices stopped firing ads at me at this point. However, there is one final gotcha...
Unsolved problem 1
Some companies have figured out that if they don't have their tracking stuff on a distinguishable hostname and instead for example, just in a sub-path that they can get around this specific mechanism of blocking requests.
 How is this? Under the guise of an "enhanced experience", Silk renders "content"
(read as: webpages with pre-embedded tracking and ads) on the AWS backend servers and sends it all to you as one big chunk, so your browser never actually makes a DNS request to the tracking site.
Summary
In summary, with an afternoon of tinkering and about 50 bucks you too can make your home network safer and more pleasant to use for everyone behind it. For example: My wife noticed immediately that her phone stopped getting ads and was quicker. This
exercise is beneficial but also helped me to really grok just how much unwanted traffic was going on with my network. So get yourself a pi and get on it.


Now that you’ve learned the basics of React, the official React documentation is a great resource to use to reinforce your newly acquired skills.
The Main Concepts section of the official documentation is a great series of articles that cover the basics of React. If you’re in the mood for a step-by-step tutorial, be sure to check out the Intro to React tutorial.
Once you’re feeling confident with the basics of React development, you can extend your knowledge by reviewing the following topics listed under the “Advanced Guides” section of the official documentation:
The rest of the topics listed under the Advanced Guides section can safely be ignored for now. Just remember that when you encounter an issue or need to solve a problem that you haven’t solved yet, the official documentation is a great resource!


The brokerage has many the following important roles vital for the stability of a running algorithm:
Brokerages often have their own ticker styles, order class names, and event names. Many of the methods in the brokerage implementation may simply be converting from the brokerage object format into LEAN format. You should plan accordingly to write neat code.
The brokerage must implement the following interfaces:
class MyBrokerage : Brokerage, IDataQueueHandler, IDataQueueUniverseProvider { ... }


A startup with 5000 total shares is split among the CEO, employees, VC, and angel investors. If you purchased 400 shares from the CEO, you would own 8% of the company (the purple slice above).


steal.generate(path, where, data) -> undefined
{String}
the folder to get templates from
{String}
where to put the results of the rendered templates
{Object}
data to render the templates with. If force is true, it will overwrite everything
{undefined}
The Generate plugin makes building code generators crazy easy. StealJS comes with its own app generator. JavaScriptMVC has more complex generators.
Steal Generators
app
Creates an application structure, build and clean scripts.
JavaScriptMVC Generators
app
Creates a JavaScriptMVC application structure.
controller
Creates a $.Controller and test files.
Cookbook.Recipes
, the generator will createcookbook/recipes.js
.model
Creates a jQuery.Model and test files.
Cookbook.Models.Recipe
, the generator will createcookbook/models/recipe.js
.page
Creates a page that loads steal.js and an application.
plugin
Use plugin to create a file and folder structure for basic jQuery plugins.
scaffold
Creates the controllers, models, and fixtures used to provide basic CRUD functionality..
The Generator Function
Renders a folders contents with EJS and data and then copies it to another folder.


My Favorite things
These are some of my favorite things
People
Here are some of my favorite people:
Mom
Giancarlo
ice cream
These are some of favorite flavors in order:
chocolate
dulce de leche
Thanks for reading about me!


Translations¶
The easiest way to support Translations is to create multiple Encyclopaedias for each language in your game.
However, this alone won’t change the labels used on the screens. By default these are all in English.
Modifying an Encyclopaedia’s labels can be done using the Labels object. Every Encyclopaedia is created with a default one that can be replaced.
To customize the labels, create a new Labels object, rewrite the labels inside it, and assign the object to your Encyclopaedia.
The following attributes are available:
percentage_label (str): Placed next to the percentage unlocked number
page_label (str): Placed before the entry page displayed
page_separator_label (str): Placed in-between the current page number and the total page number
sort_number_label (str): Label for Number Sorting
sort_alphabetical_label (str): Label for Alphabetical sorting
sort_reverse_alphabetical_label (str): Label for Reverse Alphabetical sorting
sort_subject_label (str): Label for Subject sorting
sort_unread_label (str): Label for Unread sorting
unread_entry_label (str): Default for the tag next to unread entries
locked_entry_label (str): Default for a “Locked Entry” button
# English
en_encyclopaedia = Encyclopaedia()
# French
fr_encyclopaedia = Encyclopaedia()
fr_labels = Labels(fr_encyclopaedia)
fr_labels.sort_alphabetical_label = "De A à Z"
fr_encyclopaedia.labels = fr_labels


The tuple/range.h
header defines an algorithm that extracts a range of elements from a tuple.
#include <chaos/preprocessor/tuple/range.h>
The CHAOS_PP_TUPLE_RANGE
macro extracts the range of elements specified by its first two arguments from its third argument.
CHAOS_PP_TUPLE_RANGE
(i, len, tuple)
The zero-based index of the first element to be extracted.
Valid values range from 0
to
- 1.
CHAOS_PP_TUPLE_SIZE
(tuple)
The number of elements to be extracted.
Valid values range from 0
to
- i.
CHAOS_PP_TUPLE_SIZE
(tuple)
The tuple from which elements are to be extracted.
This macro expands to a tuple containing len elements from tuple starting at the i-th element of tuple. Consequently, tuple must contain the entire range specified by i and len.
The efficiency of the algorithm's use of the recursion backend can be described in terms of the number of recursion steps required to complete the algorithm. The asymptotic upper and lower bounds are Θα, where i is i and l is len.
The efficiency of the algorithm's use of the recursion backend can be described in terms of the total depth of recursion steps required to complete the algorithm. The asymptotic upper and lower bounds are Θβ, where i is i and l is len.
This macro operates on the nil tuple representation used by the core tuple operations defined in <chaos/preprocessor/tuple/core.h>
.
Specifically, ()
is a one-element tuple, not a zero-element tuple.
This macro uses bypass semantics.
If bypass semantics are already in effect, CHAOS_PP_TUPLE_RANGE_BYPASS
must be used instead.
CHAOS_PP_DROP
CHAOS_PP_RANGE
CHAOS_PP_SEQ_DROP
CHAOS_PP_SEQ_RANGE
CHAOS_PP_SEQ_TAKE
CHAOS_PP_TAKE
CHAOS_PP_TUPLE_DROP
CHAOS_PP_TUPLE_TAKE
#include<chaos/preprocessor/config.h>
#include<chaos/preprocessor/tuple/range.h>
#ifCHAOS_PP_VARIADICS
CHAOS_PP_TUPLE_RANGE
(2, 5, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)) // (2, 3, 4, 5, 6) #endif
The CHAOS_PP_TUPLE_RANGE_ID
macro indirectly expands to CHAOS_PP_TUPLE_RANGE
.
CHAOS_PP_TUPLE_RANGE_ID
()
This macro effectively allows CHAOS_PP_TUPLE_RANGE
to pass through itself without becoming disabled.
The CHAOS_PP_TUPLE_RANGE_
macro expands to a λ expression representing CHAOS_PP_TUPLE_RANGE
.
CHAOS_PP_TUPLE_RANGE_
This macro is a shorthand form of the following λ binding:
The CHAOS_PP_TUPLE_RANGE_BYPASS
macro behaves identically to CHAOS_PP_TUPLE_RANGE
except that it is parametized by the bypass recursion state.
CHAOS_PP_TUPLE_RANGE_BYPASS
(s, i, len, tuple)
The current bypass recursion state.
The zero-based index of the first element to be extracted.
Valid values range from 0
to
- 1.
CHAOS_PP_TUPLE_SIZE
(tuple)
The number of elements to be extracted.
Valid values range from 0
to
- i.
CHAOS_PP_TUPLE_SIZE
(tuple)
The tuple from which elements are to be extracted.
If bypass semantics are already in effect, this macro must be used instead of CHAOS_PP_TUPLE_RANGE
.
The CHAOS_PP_TUPLE_RANGE_BYPASS_ID
macro indirectly expands to CHAOS_PP_TUPLE_RANGE_BYPASS
.
CHAOS_PP_TUPLE_RANGE_BYPASS_ID
()
This macro effectively allows CHAOS_PP_TUPLE_RANGE_BYPASS
to pass through itself without becoming disabled.
The CHAOS_PP_TUPLE_RANGE_BYPASS_
macro expands to a λ expression representing CHAOS_PP_TUPLE_RANGE_BYPASS
.
CHAOS_PP_TUPLE_RANGE_BYPASS_
This macro is a shorthand form of the following λ binding:


public interface DifferenceConstants
| Modifier and Type | Field and Description |
|---|---|
static Difference |
ATTR_NAME_NOT_FOUND
Comparing 2 elements and one has an attribute the other does not
|
static int |
ATTR_NAME_NOT_FOUND_ID
Comparing 2 elements and one has an attribute the other does not
|
static Difference |
ATTR_SEQUENCE
Comparing 2 attribute lists with the same attributes in different sequence
|
static int |
ATTR_SEQUENCE_ID
Comparing 2 attribute lists with the same attributes in different sequence
|
static Difference |
ATTR_VALUE
Comparing 2 attributes with the same name but different values
|
static Difference |
ATTR_VALUE_EXPLICITLY_SPECIFIED
Comparing an implied attribute value against an explicit value
|
static int |
ATTR_VALUE_EXPLICITLY_SPECIFIED_ID
Comparing an implied attribute value against an explicit value
|
static int |
ATTR_VALUE_ID
Comparing 2 attributes with the same name but different values
|
static Difference |
CDATA_VALUE
Comparing 2 CDATA sections with different values
|
static int |
CDATA_VALUE_ID
Comparing 2 CDATA sections with different values
|
static Difference |
CHILD_NODE_NOT_FOUND
Comparing 2 nodes and one holds more childnodes than can be
matched against child nodes of the other.
|
static int |
CHILD_NODE_NOT_FOUND_ID
Comparing 2 nodes and one holds more childnodes than can be
matched against child nodes of the other.
|
static Difference |
CHILD_NODELIST_LENGTH
Comparing 2 nodes with different numbers of children
|
static int |
CHILD_NODELIST_LENGTH_ID
Comparing 2 nodes with different numbers of children
|
static Difference |
CHILD_NODELIST_SEQUENCE
Comparing 2 nodes with children whose nodes are in different sequence
|
static int |
CHILD_NODELIST_SEQUENCE_ID
Comparing 2 nodes with children whose nodes are in different sequence
|
static Difference |
COMMENT_VALUE
Comparing 2 comments with different values
|
static int |
COMMENT_VALUE_ID
Comparing 2 comments with different values
|
static Difference |
DOCTYPE_NAME
Comparing 2 document types with different names
|
static int |
DOCTYPE_NAME_ID
Comparing 2 document types with different names
|
static Difference |
DOCTYPE_PUBLIC_ID
Comparing 2 document types with different public identifiers
|
static int |
DOCTYPE_PUBLIC_ID_ID
Comparing 2 document types with different public identifiers
|
static Difference |
DOCTYPE_SYSTEM_ID
Comparing 2 document types with different system identifiers
|
static int |
DOCTYPE_SYSTEM_ID_ID
Comparing 2 document types with different system identifiers
|
static Difference |
ELEMENT_NUM_ATTRIBUTES
Comparing 2 elements with different number of attributes
|
static int |
ELEMENT_NUM_ATTRIBUTES_ID
Comparing 2 elements with different number of attributes
|
static Difference |
ELEMENT_TAG_NAME
Comparing 2 elements with different tag names
|
static int |
ELEMENT_TAG_NAME_ID
Comparing 2 elements with different tag names
|
static Difference |
HAS_CHILD_NODES
Comparing 2 nodes but only one has any children
|
static int |
HAS_CHILD_NODES_ID
Comparing 2 nodes but only one has any children
|
static Difference |
HAS_DOCTYPE_DECLARATION
Comparing 2 Documents only one of which has a doctype
|
static int |
HAS_DOCTYPE_DECLARATION_ID
Comparing 2 Documents only one of which has a doctype
|
static Difference |
NAMESPACE_PREFIX
Comparing 2 nodes with different namespace prefixes
|
static int |
NAMESPACE_PREFIX_ID
Comparing 2 nodes with different namespace prefixes
|
static Difference |
NAMESPACE_URI
Comparing 2 nodes with different namespace URIs
|
static int |
NAMESPACE_URI_ID
Comparing 2 nodes with different namespace URIs
|
static Difference |
NO_NAMESPACE_SCHEMA_LOCATION
Comparing 2 nodes with different xsi:noNamespaceSchemaLocation
attributes, potentially only one of the two provides such an
attribute at all.
|
static int |
NO_NAMESPACE_SCHEMA_LOCATION_ID
Comparing 2 nodes with different xsi:noNamespaceSchemaLocation
attributes, potentially only one of the two provides such an
attribute at all.
|
static Difference |
NODE_TYPE
Comparing 2 nodes with different node types
|
static int |
NODE_TYPE_ID
Comparing 2 nodes with different node types
|
static Difference |
PROCESSING_INSTRUCTION_DATA
Comparing 2 processing instructions with different instructions
|
static int |
PROCESSING_INSTRUCTION_DATA_ID
Comparing 2 processing instructions with different instructions
|
static Difference |
PROCESSING_INSTRUCTION_TARGET
Comparing 2 processing instructions with different targets
|
static int |
PROCESSING_INSTRUCTION_TARGET_ID
Comparing 2 processing instructions with different targets
|
static Difference |
SCHEMA_LOCATION
Comparing 2 nodes with different xsi:schemaLocation
attributes, potentially only one of the two provides such an
attribute at all.
|
static int |
SCHEMA_LOCATION_ID
Comparing 2 nodes with different xsi:schemaLocation
attributes, potentially only one of the two provides such an
attribute at all.
|
static Difference |
TEXT_VALUE
Comparing 2 different text values
|
static int |
TEXT_VALUE_ID
Comparing 2 different text values
|
static final int ATTR_VALUE_EXPLICITLY_SPECIFIED_ID
static final int ATTR_NAME_NOT_FOUND_ID
static final int ATTR_VALUE_ID
static final int ATTR_SEQUENCE_ID
static final int CDATA_VALUE_ID
static final int COMMENT_VALUE_ID
static final int DOCTYPE_NAME_ID
static final int DOCTYPE_PUBLIC_ID_ID
static final int DOCTYPE_SYSTEM_ID_ID
static final int ELEMENT_TAG_NAME_ID
static final int ELEMENT_NUM_ATTRIBUTES_ID
static final int PROCESSING_INSTRUCTION_TARGET_ID
static final int PROCESSING_INSTRUCTION_DATA_ID
static final int TEXT_VALUE_ID
static final int NAMESPACE_PREFIX_ID
static final int NAMESPACE_URI_ID
static final int NODE_TYPE_ID
static final int HAS_CHILD_NODES_ID
static final int CHILD_NODELIST_LENGTH_ID
static final int CHILD_NODELIST_SEQUENCE_ID
static final int HAS_DOCTYPE_DECLARATION_ID
static final int CHILD_NODE_NOT_FOUND_ID
static final int SCHEMA_LOCATION_ID
static final int NO_NAMESPACE_SCHEMA_LOCATION_ID
static final Difference ATTR_VALUE_EXPLICITLY_SPECIFIED
static final Difference ATTR_NAME_NOT_FOUND
static final Difference ATTR_VALUE
static final Difference ATTR_SEQUENCE
static final Difference CDATA_VALUE
static final Difference COMMENT_VALUE
static final Difference DOCTYPE_NAME
static final Difference DOCTYPE_PUBLIC_ID
static final Difference DOCTYPE_SYSTEM_ID
static final Difference ELEMENT_TAG_NAME
static final Difference ELEMENT_NUM_ATTRIBUTES
static final Difference PROCESSING_INSTRUCTION_TARGET
static final Difference PROCESSING_INSTRUCTION_DATA
static final Difference TEXT_VALUE
static final Difference NAMESPACE_PREFIX
static final Difference NAMESPACE_URI
static final Difference NODE_TYPE
static final Difference HAS_CHILD_NODES
static final Difference CHILD_NODELIST_LENGTH
static final Difference CHILD_NODELIST_SEQUENCE
static final Difference HAS_DOCTYPE_DECLARATION
static final Difference CHILD_NODE_NOT_FOUND
static final Difference SCHEMA_LOCATION
static final Difference NO_NAMESPACE_SCHEMA_LOCATION


maps.Rmd
Reads are expressed as % relative to total eukaryotes. The taxa shown are below the level selected. For example if you select division, the different classes within this division will be shown (see Fig. 3).
Crosses indicate samples for which the selected taxonomic group is absent.
The map panel offers 2 different views:
Dominant taxon: The color of the circles represent the dominant taxon. If you click on the circle the contribution of the taxonomic group selected is provided with some information on the sample (Fig. 1)
Pie chart: The different taxon at the next rank are represented. Click on the pie chart will provide the % contribution of each group below the taxonomic level selected (Fig. 2)
Reads are expressed as % relative to total eukaryotes. The taxa shown are below the level selected. For example if you select division, the different classes within this division will be shown.
Crosses indicate samples for which the selected taxonomic group is absent.
The total number of stations with and without the taxon present are indicated above the map (Fig. 3, red rectangle). The size of the circle can be changed by moving the cursor above the map. This is expressed as % of total eukaryotic reads.