RY EYES CUP
Rangers star Ryan Kent says Celtic Betfred Cup final will be biggest moment of his career
by Ryan McDonaldRANGERS star Ryan Kent admits next month’s blockbuster Old Firm final will be the biggest moment of his career.
Steven Gerrard’s side lock horns with rivals Celtic at Hampden on December 8 as both sides battle for Betfred Cup glory.
While Neil Lennon’s quadruple treble chasers have dominated Scottish football over the last eight years, Gers haven’t won any major trophies since 2011.
The Light Blues suffered semi-final misery against Aberdeen at Hampden last year but after reaching the final this time around, Kent is desperate to end the club’s trophy drought.

“To lose in the semi-finals last year was a big disappointment.
“To reach a final, it’s no secret how massive that is for the club and for each individual in the team as well.
“Everybody is really excited for that. It will definitely be the biggest moment of my career, to play in that game.
“If I was to come away with silverware, it would be huge.”


Choose an Excel file to upload and import
Data should be in the first sheet, in columns named {% for name in view.column_names %}{{ name }}{% if not forloop.last %}, {% endif %}{% if forloop.revcounter0 == 1 %} and {% endif %}{% endfor %}. The columns don't need to be in that order, and there can be other columns, which will just be ignored.
The column names are read from the first row.
All remaining rows in the first sheet will be added as new items, except that no two records may have the same Description, Donor, Supplier and local Price, so any attempt to import records that would violate that will fail.
If any errors occur, no items will be imported.


Girl, 12, survives croc attack
by Zaida Delos ReyesA 12-YEAR-OLD girl on Friday night survived a crocodile attack in Balabac, Palawan.
Police Regional Office - MIMAROPA spokesman Lt. Col. Aries Faltado identified the victim as Haina Lisa Jose Habi, a student and a resident of Bgy. Catagupan, Balabac town.
The attack happened when the girl was on her way home, with her brother Hashim, at 6:30 p.m. on Friday.
The siblings were crossing a creek in Bgy. Poblacion VI when Haina was snatched by the crocodile.
Hashim immediately jumped to the water and huggled and forcefully pulled Haina until the girl escaped from the crocodile bite.
The victim sustained a wound in the leg. She was brought to the Balabac Rural Health Unit for treatment.


Choose from a dozen widgets and configure them to target your goals
The news and stock widgets allow you to stay up to date. Add a filter on specific keywords so that you can get the news yu care about.
The todo list and goal tracker widgets keep you accountable to your aspirations. Keep track of your appointments in the calendar app.
See what your friends are up to by integrating with your social media. Include a photo feed of those important people in your life
Motivation Dashboard is a work in progress. Please submit your email down below if you would like to get emails about any releases or updates. If you want to be contacted about opportunities to submit ideas or code then please select the contribute option


Law school outlines, by classmates, for classmates.
It seems that you have not submitted an evaluation this semester. Please consider submitting an evaluation for other students. You can still browse evaluations in the meantime.
If this message is an error because you have already submitted an evaluation this semester, please email<EMAIL_ADDRESS>Course
Professor Last Name
Comments
Error
Search
Rate
?
Tell us what you really think. All reviews are anonymous.


Getting to Know Your LDD Repo¶
Overview¶
Assuming a new LDD Github Repo has been generated for you, this section and its subsections will describe the directories, associated files, and and the automated dictionary generation and validate performed automatically by the repo through Github Actions.
The default directory structure and file locations are very important to ensuring the continuous integration built into the repository executes successfully.
LDD Generation and Validation¶
Each LDD Github repo generated from the ldd-template repo will contain Github Actions to do the following:
Generating schemas and schematrons¶
The github action will download and run the latest LDDTool and generate the schemas and schematrons from your Ingest LDD using the expected LDDTool flags.
What does this mean?
The schemas and schematrons in your repository should always be generated using the latest LDDTool and using the configuration that an operational release would expect. It really helps ensure all LDDs are generated the same way and include the same set of files.
Additionally, you should NOT generate and push schemas or schematrons to your repository manually. To minimize inconsistencies across LDDs, all schemas and schematrons posted on Github should be auto-generated by Github, or generated and pushed by EN Operations staff.
What does this NOT mean?
This does not mean you shouldn’t download LDDTool and test locally. Github Actions are great, but can be kind of slow generating the schemas, so I would recommend running LDDTool locally to test before pushing an update to Github per the LDD Update Process.
LDD Validation¶
The github action also downloads Validate Tool, performs basic validation of your schemas and schematrons, and performs regression testing against any tests in the test/
directory of your repo. See LDD Regression Testing for more info on how to populate the test
directory.
Repo Directory Structure¶
Warning
Please do not remove or move the directories unless told it is OK by the descriptions of the directories below.
Below is an example of the default repo layout for the cart namespace. This is an example and the exact layout of the generated repo is subject to change, but the following subsections of this guide will be updated as needed. For the latest layout checkout the ldd-template repo:
├── README.md
├── pds4_versions.txt
├── build/
│ └── development/
│ └── release/
├── docs/
│ └── source/
│ └── Makefile
│ └── examplenamespace.pdf
│ └── make.bat
│ └── requirements.txt
├── logs/
├── src/
│ ├── PDS4_EXAMPLE_IngestLDD.xml
│ └── dependencies/
├── test/
│ ├── No.Data
│ ├── test1_FAIL.xml
│ └── test1_VALID.xml
README.md¶
A template README is included in the repository with minimal information provided. Update anything contained within curly braces ({``
}``).
pds4_versions.txt¶
This text file contains the applicable PDS4 Versions to build against for LDDs in your repo.
For Discipline LDDs, this file is automatically updated after each system build by the PDSEN Operations Team with the newly released PDS4 Information Model.
For Mission LDDs, this file must be manually updated whenever a new PDS4 Information Model version is needed.
Note
Feel free to remove versions that are not applicable or add new versions by adding a newline and the applicable version number. Note: The Github CI/CD only works for PDS4 IM versions <IP_ADDRESS> and later.
build/¶
This directory is where all the schemas, schematrons and other files generated from LDDTool are placed.
development/
- this directory will contain the current development version of the schema. You should always be able to direct someone here if they want to be able to test with the schemas that are currently in development for next build.release/
- this directory will contain all released versions of the LDD from PDS4 Stadard Version <IP_ADDRESS> and later. This directory is maintained for configuration management only. Users should be directed to download from the archival, released version at pds.nasa.gov.
docs/¶
Contains the template documentation (in Markdown) and the necessary build software and configuration for Sphinx to auto-generate the online documentation for this LDD. An overview of the content within this directory:
source/
- contains the template documentation files, in Markdown, used to generate the online documentation for your repo, as well as the Sphinx configuration file, conf.py. The updates needed in that file should be self-documented in your repo, or see the latest version in the ldd-template repo. You will want to update the remaining Markdown documentation files accordingly per your repository and the guidelines from the Stewards’ Handbook.Makefile
- this is used to auto-generate the online documentation using Sphinx. You should not need to touch this.examplenamespace.pdf
- this is the auto-generated PDF from the Markdown documentation under the source/ directory. Once you update theProject
value in your Sphinx configuration file, this filename will change to your LDDs name. Here is where that value comes from in the template repository.make.bat
- similar to theMakefile
, this is used to auto-generate the online documentation using Sphinx. You should not need to touch this.requirements.txt
- this is used to build the software used to auto-generate the online documentation using Sphinx. You should not need to touch this.
logs/¶
Contains the logs from the last attempt to auto-generate the LDDs.
src/¶
This directory is where the IngestLDD and its associated dependencies are located.
PDS4_<NAMESPACE>_IngestLDD.xml
- this file must be located in this directory in order for the continuous integration to work properly. The file name should follow the syntax ofPDS4_NAMESPACE_IngestLDD.xml
whereNAMESPACE
is the shortened namespace for your LDD, e.g.GEOM
,IMG
,MARS2020
.dependencies/
- in the event that your Discipline Dictionary inherits classes from another Discipline Dictionary, this directory will use Github submodules to link to the other repository. If that does not apply to your dictionary, you can remove this directory. If it does, contact the PDS Steward Admins to get help setting this up.
test/¶
Directory containing regression tests for the LDD. See LDD Regression Testing for more details.
Trying It Out¶
Before trying it out on your own repository, it is recommended that you review the LDD Update Process and completing the LDD Update and Build Tutorial
Handling LDD dependencies¶
If your LDD has a dependency on another LDD, you will need to complete the following changes to your repository after it has been created:
Create a new
src/dependencies
directory:mkdir -p src/dependencies
Create a submodule to the LDD is in the dependent repo and set the branch to pull from:
cd src/dependencies git submodule add https://github.com/pds-data-dictionaries/ldd-geom git submodule set-branch --branch main src/dependencies/ldd-geom/
You should now see a
src/dependencies/ldd_geom
directory:$ ls README.md ldd-geom/
Commit and push your changes to a branch and merge.


Namespace Keras.Layers
Classes
Activation
Applies an activation function to an output.
ActivityRegularization
Layer that applies an update to the cost function based input activity.
Add
AlphaDropout
Applies Alpha Dropout to the input. Alpha Dropout is a Dropout that keeps mean and variance of inputs to their original values, in order to ensure the self-normalizing property even after this dropout. Alpha Dropout fits well to Scaled Exponential Linear Units by randomly setting activations to the negative saturation value.
AveragePooling1D
Average pooling for temporal data.
AveragePooling2D
Average pooling operation for spatial data.
AveragePooling3D
Average pooling operation for 3D data (spatial or spatio-temporal).
BaseLayer
BatchNormalization
Batch normalization layer (Ioffe and Szegedy, 2014). Normalize the activations of the previous layer at each batch, i.e.applies a transformation that maintains the mean activation close to 0 and the activation standard deviation close to 1.
Bidirectional
Bidirectional wrapper for RNNs.
Conv1D
1D convolution layer (e.g. temporal convolution). This layer creates a convolution kernel that is convolved with the layer input over a single spatial(or temporal) dimension to produce a tensor of outputs.If use_bias is True, a bias vector is created and added to the outputs.Finally, if activation is not None, it is applied to the outputs as well. When using this layer as the first layer in a model, provide an input_shape argument (tuple of integers or None, does not include the batch axis), e.g. input_shape=(10, 128) for time series sequences of 10 time steps with 128 features per step in data_format="channels_last", or (None, 128) for variable-length sequences with 128 features per step.
Conv2D
2D convolution layer (e.g. spatial convolution over images). This layer creates a convolution kernel that is convolved with the layer input to produce a tensor of outputs.If use_bias is True, a bias vector is created and added to the outputs.Finally, if activation is not None, it is applied to the outputs as well. When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the batch axis), e.g. input_shape=(128, 128, 3) for 128x128 RGB pictures in data_format="channels_last".
Conv2DTranspose
Transposed convolution layer (sometimes called Deconvolution). The need for transposed convolutions generally arises from the desire to use a transformation going in the opposite direction of a normal convolution, i.e., from something that has the shape of the output of some convolution to something that has the shape of its input while maintaining a connectivity pattern that is compatible with said convolution. When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the batch axis), e.g. input_shape=(128, 128, 3) for 128x128 RGB pictures in data_format="channels_last".
Conv3D
3D convolution layer (e.g. spatial convolution over volumes). This layer creates a convolution kernel that is convolved with the layer input to produce a tensor of outputs.If use_bias is True, a bias vector is created and added to the outputs.Finally, if activation is not None, it is applied to the outputs as well. When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the batch axis), e.g. input_shape=(128, 128, 128, 1) for 128x128x128 volumes with a single channel, in data_format="channels_last".
Conv3DTranspose
Transposed convolution layer (sometimes called Deconvolution). The need for transposed convolutions generally arises from the desire to use a transformation going in the opposite direction of a normal convolution, i.e., from something that has the shape of the output of some convolution to something that has the shape of its input while maintaining a connectivity pattern that is compatible with said convolution. When using this layer as the first layer in a model, provide the keyword argument input_shape (tuple of integers, does not include the batch axis), e.g. input_shape=(128, 128, 128, 3) for a 128x128x128 volume with 3 channels if data_format="channels_last".
ConvLSTM2D
Convolutional LSTM. It is similar to an LSTM layer, but the input transformations and recurrent transformations are both convolutional.
ConvLSTM2DCell
Cell class for the ConvLSTM2D layer.
Cropping1D
Cropping layer for 1D input (e.g. temporal sequence). It crops along the time dimension(axis 1).
Cropping2D
Cropping layer for 2D input (e.g. picture). It crops along spatial dimensions, i.e.height and width.
Cropping3D
Cropping layer for 3D data (e.g. spatial or spatio-temporal).
CuDNNGRU
Fast GRU implementation backed by CuDNN. Can only be run on GPU, with the TensorFlow backend.
CuDNNLSTM
Dense
Just your regular densely-connected NN layer. Dense implements the operation: output = activation(dot(input, kernel) + bias) where activation is the element-wise activation function passed as the activation argument, kernel is a weights matrix created by the layer, and bias is a bias vector created by the layer(only applicable if use_bias is True). Note: if the input to the layer has a rank greater than 2, then it is flattened prior to the initial dot product with kernel.
DepthwiseConv2D
Depthwise separable 2D convolution.
Depthwise Separable convolutions consists in performing just the first step in a depthwise spatial convolution(which acts on each input channel separately). The depth_multiplier argument controls how many output channels are generated per input channel in the depthwise step.
Dropout
Applies Dropout to the input. Dropout consists in randomly setting a fraction rate of input units to 0 at each update during training time, which helps prevent overfitting.
ELU
Embedding
Turns positive integers (indexes) into dense vectors of fixed size. eg. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]] This layer can only be used as the first layer in a model.
Flatten
Flattens the input. Does not affect the batch size.
GaussianDropout
Apply multiplicative 1-centered Gaussian noise. As it is a regularization layer, it is only active at training time.
GaussianNoise
Apply additive zero-centered Gaussian noise. This is useful to mitigate overfitting(you could see it as a form of random data augmentation). Gaussian Noise(GS) is a natural choice as corruption process for real valued inputs. As it is a regularization layer, it is only active at training time.
GlobalAveragePooling1D
Global average pooling operation for temporal data.
GlobalAveragePooling2D
Global average pooling operation for spatial data.
GlobalAveragePooling3D
Global Average pooling operation for 3D data.
GlobalMaxPooling1D
Global max pooling operation for temporal data.
GlobalMaxPooling2D
Global max pooling operation for spatial data.
GlobalMaxPooling3D
Global Max pooling operation for 3D data.
GRU
Gated Recurrent Unit - Cho et al. 2014. There are two variants.The default one is based on 1406.1078v3 and has reset gate applied to hidden state before matrix multiplication. The other one is based on original 1406.1078v1 and has the order reversed. The second variant is compatible with CuDNNGRU (GPU-only) and allows inference on CPU.Thus it has separate biases for kernel and recurrent_kernel.Use 'reset_after'=True and recurrent_activation='sigmoid'.
GRUCell
Cell class for the GRU layer.
Input
Input() is used to instantiate a Keras tensor. A Keras tensor is a tensor object from the underlying backend(Theano, TensorFlow or CNTK), which we augment with certain attributes that allow us to build a Keras model just by knowing the inputs and outputs of the model. For instance, if a, b and c are Keras tensors, it becomes possible to do: model = Model(input =[a, b], output = c) The added Keras attributes are: _keras_shape: Integer shape tuple propagated via Keras-side shape inference._keras_history: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Lambda
Wraps arbitrary expression as a Layer object.
LeakyReLU
LocallyConnected1D
Locally-connected layer for 1D inputs. The LocallyConnected1D layer works similarly to the Conv1D layer, except that weights are unshared, that is, a different set of filters is applied at each different patch of the input.
LocallyConnected2D
Locally-connected layer for 2D inputs. The LocallyConnected2D layer works similarly to the Conv2D layer, except that weights are unshared, that is, a different set of filters is applied at each different patch of the input.
LSTM
Long Short-Term Memory layer - Hochreiter 1997.
LSTMCell
Cell class for the LSTM layer.
Masking
Masks a sequence by using a mask value to skip timesteps. If all features for a given sample timestep are equal to mask_value, then the sample timestep will be masked(skipped) in all downstream layers(as long as they support masking). If any downstream layer does not support masking yet receives such an input mask, an exception will be raised.
MaxPooling1D
Max pooling operation for temporal data.
MaxPooling2D
Max pooling operation for spatial data.
MaxPooling3D
Max pooling operation for 3D data (spatial or spatio-temporal).
Merge
Permute
Permutes the dimensions of the input according to a given pattern. Useful for e.g.connecting RNNs and convnets together.
PReLU
ReLU
RepeatVector
Repeats the input n times.
Reshape
Reshapes an output to a certain shape.
RNN
Base class for recurrent layers. This layer supports masking for input data with a variable number of timesteps. To introduce masks to your data, use an Embedding layer with the mask_zero parameter set to True.
You can set RNN layers to be 'stateful', which means that the states computed for the samples in one batch will be reused as initial states for the samples in the next batch. This assumes a one-to-one mapping between samples in different successive batches. To enable statefulness: - specify stateful = True in the layer constructor. - specify a fixed batch size for your model, by passing if sequential model: batch_input_shape = (...) to the first layer in your model. else for functional model with 1 or more Input layers: batch_shape = (...) to all the first layers in your model.This is the expected shape of your inputs including the batch size.It should be a tuple of integers, e.g. (32, 10, 100). - specify shuffle = False when calling fit(). To reset the states of your model, call.reset_states() on either a specific layer, or on your entire model.
You can specify the initial state of RNN layers symbolically by calling them with the keyword argument initial_state. The value of initial_state should be a tensor or list of tensors representing the initial state of the RNN layer. You can specify the initial state of RNN layers numerically by calling reset_states with the keyword argument states.The value of states should be a numpy array or list of numpy arrays representing the initial state of the RNN layer.
You can pass "external" constants to the cell using the constants keyword argument of RNN.__call__ (as well as RNN.call) method. This requires that the cell. Call method accepts the same keyword argument constants. Such constants can be used to condition the cell transformation on additional static inputs (not changing over time), a.k.a. an attention mechanism.
SeparableConv1D
Depthwise separable 1D convolution. Separable convolutions consist in first performing a depthwise spatial convolution(which acts on each input channel separately) followed by a pointwise convolution which mixes together the resulting output channels.The depth_multiplier argument controls how many output channels are generated per input channel in the depthwise step. Intuitively, separable convolutions can be understood as a way to factorize a convolution kernel into two smaller kernels, or as an extreme version of an Inception block.
SeparableConv2D
Depthwise separable 2D convolution. Separable convolutions consist in first performing a depthwise spatial convolution(which acts on each input channel separately) followed by a pointwise convolution which mixes together the resulting output channels.The depth_multiplier argument controls how many output channels are generated per input channel in the depthwise step. Intuitively, separable convolutions can be understood as a way to factorize a convolution kernel into two smaller kernels, or as an extreme version of an Inception block.
SimpleRNN
Fully-connected RNN where the output is to be fed back to input.
SimpleRNNCell
Cell class for SimpleRNN.
Softmax
Softmax activation function.
SpatialDropout1D
Spatial 1D version of Dropout. This version performs the same function as Dropout, however it drops entire 1D feature maps instead of individual elements.If adjacent frames within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease.In this case, SpatialDropout1D will help promote independence between feature maps and should be used instead.
SpatialDropout2D
Spatial 2D version of Dropout. This version performs the same function as Dropout, however it drops entire 2D feature maps instead of individual elements.If adjacent pixels within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease.In this case, SpatialDropout2D will help promote independence between feature maps and should be used instead.
SpatialDropout3D
Spatial 3D version of Dropout. This version performs the same function as Dropout, however it drops entire 3D feature maps instead of individual elements.If adjacent voxels within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease.In this case, SpatialDropout3D will help promote independence between feature maps and should be used instead.
ThresholdedReLU
Thresholded Rectified Linear Unit. It follows: f(x) = x for x > theta, f(x) = 0 otherwise.
TimeDistributed
This wrapper applies a layer to every temporal slice of an input. The input should be at least 3D, and the dimension of index one will be considered to be the temporal dimension. Consider a batch of 32 samples, where each sample is a sequence of 10 vectors of 16 dimensions. The batch input shape of the layer is then (32, 10, 16), and the input_shape, not including the samples dimension, is (10, 16). You can then use TimeDistributed to apply a Dense layer to each of the 10 timesteps, independently:
UpSampling1D
Upsampling layer for 1D inputs. Repeats each temporal step size times along the time axis.
UpSampling2D
Upsampling layer for 2D inputs. Repeats the rows and columns of the data by size[0] and size[1] respectively.
UpSampling3D
Upsampling layer for 3D inputs. Repeats the 1st, 2nd and 3rd dimensions of the data by size[0], size[1] and size[2] respectively.
ZeroPadding1D
Zero-padding layer for 1D input (e.g. temporal sequence).
ZeroPadding2D
Zero-padding layer for 2D input (e.g. picture). This layer can add rows and columns of zeros at the top, bottom, left and right side of an image tensor.
ZeroPadding3D
Zero-padding layer for 3D data (spatial or spatio-temporal).


km.ci: Confidence intervals for the Kaplan-Meier estimator
Computes various confidence intervals for the Kaplan-Meier
estimator, namely: Petos CI, Rothman CI, CI's based on
Greenwoods variance, Thomas and Grunkemeier CI and the
simultaneous confidence bands by Nair and Hall and Wellner.
| Version: |
0.5-2 |
| Depends: |
R (≥ 1.8.0), survival, stats |
| Published: |
2009-08-30 |
| Author: |
Ralf Strobl |
| Maintainer: |
Tobias Verbeke <tobias.verbeke at openanalytics.be> |
| License: |
GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: |
no |
| Materials: |
README |
| In views: |
Survival |
| CRAN checks: |
km.ci results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=km.ci
to link to this page.


I am writing from the city of Cincinnati the state of Ohio the U.S.A. earth somewhere to let you know that you should probably not consider eating some ice cream. If you do, I would create a cone that looks like this:
Sincerely,
Your Friend


HyperSQL 1.9 Release Candidate 5
16 September 2009
This is the RC (release candidate) version of HyperSQL 1.9. Please use this
version in testing and report any issues.
Feedback
We are releasing this RC version only to get feedback, bug reports, reports
about migration from older versions, and related information from our users.
Please do use this RC version in tests as soon as possible, and let us know
of your findings, via direct email, or posting to our user list or forums, or
filing a bug report.
We have fixed tens of reported bugs and issues during the alpha and beta phase.
Thank you all testers!
This version is generally stable. If your tests indicate you can use it for
your application, please let us know. If there are any issues, this is the last
chance to get the issues fixed quickly before the general release, so please
let us know as soon as possible. The database file format will not change for
the general release.
Release plan.
- The GA (General Availability) version will be released later this month.
Features in this RC version and changes from the first alpha
- All errors and minor issues reported by users have been fixed.
- Sources can be compiled with JDK 1.5 or 1.6
- Support for database file encryption
- New features for incremental backup of the .data file allow speedy handling
of huge databases up to 16GB.
- Database files created with Alpha and Beta versions cannot be opened with
this version without manual modification. It is recommended not to use old
Alpha and Beta databases with this version.
- This version persists BLOB and CLOB values. A database file with the extension
.lobs is used for LOB objects. LOB support is now transactional. Operations
on lobs, including modifying the contents of an existing lobs, should work
and can be rolled back. The maximum total size of LOBs is currently 16TB.
Access speed looks very good in our tests.
- This version lacks some minor features of System Tables for SQL stored procedures
and functions. These will be completed for the release..
- This version has been compiled with debug information. The jar size is therefore
much larger than the forthcoming release version. The jar can be used with
JDK 1.6 only.
Differences to version 1.8.0
- There are very many new features in the new version. Most of these do not
affect existing features.
- For use with existing applications, the main differences are as follows:
- Transaction isolation is always enforced - READ COMMITTED and SERIALIZABLE
modes are supported.
- SQL keywords are enforced in some places, therefore some table names or
column names may not be acceptable.
Documentation
- The new Guide is included in the package and is a must-read. It has been
completely rewritten compared to version 1.8.0. The Guide will be enhanced
further for the General Availability release.
Fred Toussi
Maintainer, HSQL Development Group


The Work
I am UX Lead at Bose. I have led projects for global companies, working across timezones, with multicultural teams, collaborating with teams from diverse disciplines to find creative solutions to complex problems.
Previously worked as a UX Lead at Media.Monks, UX Manager at The Cocktail and other roles in companies like Razorfish, Ogilvy and The Chrysler Group


Shader Integration: Merging Shading Technologies on the
Nintendo Gamecube
By Florian Sauer and
Sigmund Vik
Gamasutra
October 2, 2002
URL: http://www.gamasutra.com/features/20021002/sauer_01.htm
Rendering polygons is not as easy as it used to be, the reason being the vast amount of different rendering techniques, methods and algorithms available. Not only is choosing the right ones a problem, even worse, all that are selected need to work together. This means, one cannot select algorithms just based on their visible results on screen, but one must also have a look at the resources needed. Input and output format and values need to match when one rendering method provides the input for another. Therefore, different techniques need to be integrated, i.e. they must be made compatible. Not only by means of input/output values, but also by means of their resource usage and their general environment. All must be considered and matched. Sometimes however, the selection of one particular rendering method comes with such a heavy resource penalty (i.e. fill rate, transform rate, storage space, cpu-time, etc.) that some other, already selected and implemented methods, need to be simplified and/or revised so that the added method integrates well into the general framework. At some point, one figures, that there are some algorithms, which simply do not work together. In that case, only one may be used, the other one needs to be replaced by a more compatible method.
All those problems hint that a general approach to shading is quite valuable and helps in making the right decisions. The general approach of Star Wars: Rogue Leader on the Nintendo Gamecube is described and the decisions made based on it, are outlined. This includes sketching down most of the shading algorithms, their specific implementations, and noting some technical details; as well as various clever bits and pieces.
The second part of this features introduces the application of the principles introduced to the area of landscape shading/texturing.
Technically many shading methods work on current generation hardware as on
the Nintendo
Gamecube. These methods include (but are not limited to):
For each of those methods, one is guaranteed to find a couple of implementations on various platforms and many references in books and scientific papers. The problem is however, that all those methods are looked at on their own. One has to find a common environment to integrate them. This process is (naturally) not hassle free and leads to certain limitations.
The problems that can arise during integrating (or just using/implementing) different shading methods fall into four different classes: algorithm compatibility, hardware limitations, performance metrics, and memory limitations.
Some shading methods are not compatible. It can be as simple as a self-shadowing pre-render pass producing eight bit z-depth values and a shadow projection method requiring eight bit alpha values. In addition, sometimes one algorithm needs geometry data being preprocessed in a very specific way to be feasible on the target, while another needs a completely different representation of the same data. Worst case here would be allocating twice the storage amount, which is not the best solution at all.
All hardware has its limits. They can be as minor as the maximum number of constant color registers in the texture environment (TEV) and as major as the fact that there is just one destination-alpha (stencil) buffer. However, if one has five shading methods, which all are using one constant color register to combine colors and the hardware supports just four, one has a problem. This can only be resolved in cutting a feature or in clever reuse of the color registers (i.e. making some colors just intensities and therefore end up with three color registers plus four intensity registers (rgba := four intensity values)). The flexible design of the Nintendo Gamecube hardware allows for many tricks like that, where one limited resource is substituted by another one with almost no additional cost. However, if you want to use two shading methods which both are based on a stencil buffer approach, you can’t introduce any tradeoff, since there is just one of it. The rendering need to be done in two passes or some alternative method needs to be used.
Each system has a specific performance metric (and it will never change). Determining which operations are relatively cheap and which are slightly expensive is a basic requirement to figure out what can be done and what will hurt in the large-scale application of a specific method. Luckily, the Nintendo Gamecube is powerful and by being so, allows for many state of the art techniques. Fill rate is not a problem and due to the eight textures that can be applied in one go (i.e. in one render pass), the requirements to the transform unit are not as elaborate as on other architectures. As another advantage, the PowerPC CPU performs well and memory access is very fast. Moreover, when it really should come down to hands-on assembly, one can find a lot of literature and examples due to the wide application of the CPU family in other areas. However, even the tightest assembly loop can’t process infinite amounts of data. If a shading method requires elaborate pre-render passes and pre-computing per frame on the CPU, the amounts of polygons is limited. Also, should complicated shading make it a requirement that there is more than one pre-render pass per object, things can quickly get slow. In that case, it can be beneficial to merge two of those passes into one, if the selected algorithms allow that (and that’s indeed possible when pre-rendering for self-shadowing and projected shadows).
Almost the same goes without much further discussion for memory storage. It is another inherently limited resource. Shading methods that require many additional texture channels and/or pre-render buffers lose against methods that don’t have such requirements.
As outlined before, a common environment can give the required structure to host the different shading methods that are about to be used at once. Of course, it’s quite difficult to plot such an environment beforehand without knowing exactly where the problems are. Therefore, this is an iterative process for the novice. The two major points, which guided Rogue Leader’s shading subsystem are consistent lighting for all geometry and a consistent illumination model.
The fact, that all geometry was lit the same in a consistent way helped tremendously to achieve the required look. By doing so, there was no room for lighting error, which may have been introduced if things where partly pre-lit and party dynamically lit. It’s always very hard to keep things, once they go different ways, consistent. In addition, one directional and one ambient light on the Nintendo Gamecube are guaranteed to be computationally for free. Therefore, that decision does not impose a performance penalty (strictly speaking, as soon as one starts to use more complex shader setups, even more hardware lights come at no performance penalty, because the graphics processor computes light values in parallel to other things).
Because of that approach, color per vertex is only used as pure paint. This means that a model may be textured completely just using intensity textures (grayscale) and color will be applied by painting vertex colors. To compute the material color, both values are multiplied together. The result is then exposed to the lighting calculations.
Local lights are all computed per vertex and are added ‘on-demand’, i.e. if an object intersects with a local light’s bounding sphere, the appropriate lights are fetched and the lighting calculations are enabled.
Equally important to the consistent lighting of all geometry is the usage of a consistent illumination model. Computations for different shaders need to be done in the same consistent manner so the results are comparable and do not depend on specific features (e.g. bump mapping, illumination maps, specularity, etc.) being enabled or not.
Specifically, the classification of lights into global (directional and ambient) and local (point and spot) lights helps with specific shadowing problems. The hardware supports this quite nicely by having two color channels (GX_COLOR0 and GX_COLOR1) that can be routed around independently in the texture environment.
Another strict distinction is helpful. Color computations are separated in material color and light color computations. The first takes place in the models own domain whereas the second one relies on the game’s light database and the shadowing techniques used. In fact, the shading subsystem uses many different methods to compute light values (c.f. Lighting Pipeline).
Figure 1: Basic illumination model.
Figure1 illustrates the basic flow of color values through the texture environment. This flow is the same for all different shaders used (i.e. diffuse shader, phong shader, lambert shader, reflective shader, etc.). Shading is a two-fold problem Technically speaking, shading polygons has to deal with two different problem domains, which are solved at different times during runtime. Those are configuration of the texture environment (shading subsystem) and light collection and selection (lighting pipeline).
Figure 2: Control flow during rendering.
Technically speaking, shading polygons has to deal with two different problem domains, which are solved at different times during runtime: configuration of the texture environment (shading subsystem) and light collection and selection (lighting pipeline) The reason for that distinction and the problem that comes with it are illustrated in Figure 2. It’s quite possible that a specific shader is used for a couple of objects that are rendered sequentially (i.e. a large number of objects of the same kind). This results in the shader only once being translated into a sequence of GX commands, Nintendo’s graphics API, but the local lights for each object of course can be different. All of the objects will very likely be at different world positions and therefore be exposed to different local lights or even no local lights at all. During rendering, the lighting pipeline now has to take care that GX knows about the correct lights and needs to issue the required sequence of commands.
The reason for that distinction and the problem that comes with it are illustrated in figure 2. It’s quite possible that a specific shader is used for a couple of objects that are rendered sequentially (i.e. a large number of objects of the same kind). This results in the shader only once being translated into a sequence of GX commands, Nintendo’s graphics API, but the local lights for each object of course can be different. All of the objects will very likely be at different world positions and therefore be exposed to different local lights or even no local lights at all. During rendering, the lighting pipeline now has to take care that GX knows about the correct lights and needs to issue the required sequence of commands.
To clarify the term shader, Figure 3 shows the data structure that defines one. A shader is a data structure that describes “how to compute colors” for rendering polygons. The term building a shader refers to the process of transforming such a data structure into a stream of GX commands, which configure the hardware to produce the desired output. One should note that during the shader build many features are activated dynamically. For instance, if an object should get tinted a color multiplication is added to the final output color whatever shader was setup before. In addition, layered fog adds another stage at the end of the color computation that blends depending on the pixel’s height in world space and distance from the camera in eye space between a fog color and the original pixel color. Of course, it would be nice, if the complete shader subsystem would be dynamic like that. However, experience shows that many shaders can only be built by hand into an optimal (i.e. least cycle usage) setup.
typedef struct tShader
{
char
mName[16];
// shader name, as in
Maya...
tShaderLimit
mShaderLimit;
// shading limit, i.e.
type...
tShaderFlags
mShaderFlags;
// additional
flags...
tShaderColor
mColor;
//
material color, if used...
tShaderColor
mSpecularColor; //
specular color, if used...
f32
mReflectivity;
// reflectivity
strength...
f32
mEmbossScale;
// emboss
depth...
f32
mMovieFade;
// movie shader
weight...
tShaderDataDescriptor
mDataInfo; // texture info...
}
tShader;
Figure 3: A ‘tShader’ data structure describing how to render polygons.
Mostly the structure’s members describe various properties of a shader (like the material color, the specular color and cosine power for phong shaders, the reflectivity for reflective phong shaders, etc.). The most important member is the mShaderLimit , which describes what kind of shading is actually performed. The term limit illustrates at what point the color computation actually should stop. Roughly, the following shading limits were implemented:
This clearly shows, that an automatic way of generating code to generate shader setups would be very nice, since all the shaders listed above need to be maintained. However, as mentioned above, a couple of features where added in automagically already, like self-shadowing and tinting for example.
typedef struct tConfig
{
//
resources currently allocated...
GXTevStageID
stage; //
current tevstage...
GXTexCoordID
coord; //
current texture coordinate...
GXTexMapID
map;
// current texture
map...
// ...
} tConfig;
void shadingConfig_ResetAllocation(tConfig
*pConfig);
void shadingConfig_Allocate(tConfig *pConfig, s32 stages, s32
coords, s32 maps);
void
shadingConfig_Flush(tConfig *pConfig);
Figure 4: Data structure ‘tConfig’ describing resource allocation.
Since a shader setup is built by various functions, one needs to keep track of various hardware resources. For example, texture environment stages, texture matrices, texture coordinates, texture maps and such need to be allocated in a sequential manner. Some resources require special order requirements; texture coordinates for emboss mapping always need to be generated last. Therefore, infrastructure is needed to deal with the allocation problems. The solution here is another tiny data structure tConfig (c.f. figure 4).
This structure holds information about the resources used during setup. Before any resources are used, the allocation information is reset using the shadingConfig_ResetAllocation(); call. For each tevstage, texture coordinate and etcetera used, a call to shadingConfig_Allocate(); is made, which marks the corresponding resources as being allocated. When one now calls a subroutine that inserts additional GX commands, the tConfig structure is passed along as a parameter. The called function can now have a look at the structure’s members and knows what tevstage, texture coordinate and etcetera to use next. When the shader construction is done, the function shadingConfig_Flush(); is called, which actually passes the number ofresources used to the hardware. Error checking can be preformed here as well.
Figure 5: Shading subsystem client control flow.
The shading subsystem needs to maintain a global GX state as well. This is because the shading subsystem is not the only client to GX. Other parts of the game program will issue GX commands and setup their own rendering methods in specific ways. However, since the shading subsystem has to initialize quite a bit of GX state to work properly, a protocol needs to be introduced to reduce the amount of redundant state changes (c.f. figure 5). The straightforward solution of initializing the complete GX state as needed by the shading subsystem is of course way to slow. A boolean variable keeps track if the shading subsystem has initialized GX for its usage. Every time it is about to be used, a function shading_PreRenderInit(); is called. This function checks the flag. If it’s false GX is initialized and the flag is set to true. The next time some shading needs to be done, the boolean is already true and the setup can be skipped. On the other hand, when other parts of the game program do some ‘hard coded’ GX usage, they need to reset that boolean by calling shading_GxDirty();.
Finally, the shading subsystem keeps books about various default settings for the texture environment. If subsequent shader setups share some settings that are the same, a couple of GX commands can be skipped, since it is in an already known state. If another shader is setup, the function shading_CleanupDirtyState(); cleans the marked dirty state and leaves GX in the expected way behind. Those optimizations helped quite a bit in the end to maintain a reasonable frame rate.
The actual purpose of the so-called lighting pipeline is to deliver light color values per shaded pixel. As mentioned before, all lights are classified into either global or local lights and the methods of computing light color values vary. The results of global lighting can be computed in three different ways: per vertex, per pixel using emboss mapping, and per pixel using bump mapping.
All three of these methods come in two variants one with self-shadowing and one without. When self-shadowing is enabled, the directional component of the global light is not added to the output color value if the pixel to be shaded falls in shadow. The ambient color is the only term that then contributes to the global lighting. The conditional add is facilitated using the two different color channels GX_COLOR0 and GX_COLOR1. The first one carries the directional component of the global light whereas the second one is assigned to all local lights and the ambient term.
Local lights are always computed per vertex using the lighting hardware and are fed into GX_COLOR1. Note that both channels are combined when self-shadowing is not enabled. There is a tiny problem when color per vertex is used for painting and two channels are used. The hardware is not able to feed one set of color per vertex data without sending the same data twice into the graphics processor. Therefore, one needs to decide if the local lights are computed unpainted (which only leads to visible artifacts, if local lights are contributing) or if color per vertex data is sent twice into both color channels, eating up vertex performance. Experience showed that not painting the local lights was quite ok, and nobody really noticed.
The control flow of the lighting pipeline is a bit tricky. The problem here is that at an object’s rendering time all local lights possibly intersecting the object’s bounding sphere, need to be known (c.f. figure 6).
Figure 6: Lighting pipeline, control flow.
This requires the creation of a local light database that holds information about all local lights influencing the visible geometry. The game program needs to add all local lights to the database before any rendering takes place. Care needs to be taken when it comes down to culling lights for visibility against the view frustum. The reason is that the distance attenuation function as used per default by GX has no precise cutoff point and therefore setting up a point light with a 50m radius does not mean that no light will contribute to any polygons starting at any distance > 50m. Light will pop on and off if the lights are collected by software culling assuming a 50m radius. A fludge factor of 2.0f proved to be quite successful here.
Once all visible lights are added, rendering can begin. First, all logical lights are transformed into an array of GXLightObj objects. This array is double (or triple) buffered to let the graphics processor always have a private copy to read from while the CPU is generating the array for the next frame. An array is constructed since each object is likely to receive it’s own set of local lights. Instead of storing many copies of GXLightObj objects in the FIFO using GXLoadLightObjImm(); we instruct the graphics processor to fetch lights indirectly from the constructed array using the faster GXLoadLightObjIdx(); function.
As rendering of an object starts, all intersecting lights are collected (up to a maximum number of eight lights) and loaded from the array. Note that one should remember which lights are loaded to avoid unnecessary loads. The light mask is computed (an eight bit value as sent to GXSetChanCtrl(); ) that describes what lights actually contribute to the lighting calculation in hardware. This mask value is the interface between the shading subsystem and the lighting pipeline. This is because GXSetChanCtrl(); not only specifies what lights are enabled but also how color per vertex is used and what kind of light calculation is performed. Therefore, parameters to this GX call are coming in from the two different subsystems at different times. By storing the light mask value as an easy accessible variable and making sure, that no bogus values are loaded in case of the first shader setup (i.e. when no lights have been collected yet), this problem can be solved.
In the next couple of sections, many of the shading methods used in Star Wars: Rogue Leader are briefly described. Specific aspects on how they integrate in the shading environment are discussed in detail. Additional information can be found in the Nintendo Gamecube SDK.
Figure 7: Illumination mapping.
Illumination maps are used by the artists when they want specific areas to be self-illuminated. Good examples are lights of small windows. Illumination mapping requires an additional texture, which typically is just an intensity texture (one for four bits). Note that strictly speaking, an illumination map could be colored, however, since the white of the illumination map will be multiplied by the texture color of the color map anyways, colored illumination maps can be circumvented. After the light calculation is done, the self-illuminating term is fetched from a texture and simply added to the light color (c.f. figure 7).
Figure 8: Texture used for specular highlights.
Specular highlights are a very important feature visually. The shiny reflection of light on surfaces gives the eye another hint about where in the scene light sources are located and adds to the overall realism. Technically speaking, specular highlights are relatively simple to implement. The light database needs to be able to determine the dominant light direction, which is, in most cases, derived from one of the directional lights (i.e. from the brightest one).
There are two different methods available to implement specular highlights. The lighting hardware can compute a specular term per vertex. This is quick to setup and the results are quite reasonable with highly tessellated geometry, but as always, computing something per pixel always gives results that are more pleasant. Therefore generating texture coordinates per vertex and looking up a specular highlight texture (c.f. figure 8) looks better.
Figure 9: Specular highlights.
The generation of texture coordinates is done in two steps (c.f. section “Texture Coordinate Generation”). First, the normal data is transformed from model into eye space using a texture matrix. Note that this step is common for all geometry and provides the basis for all other shading methods as well. This has the benefit that the interface to the geometry engine (computing skinned meshes, etc.) can be kept fairly simple and interdependencies between both subsystems are reduced. The transformed normals are now transformed again into using the “eye_normal to specular_coords” matrix using the dual transform feature of the hardware. This matrix depends on the cosine power (i.e. size) of the material being rendered and the direction of the light (also in eye space), c.f. code fraction 1 for more details. Since the specular texture is so frequently used, one should consider preloading them into the hardware texture cache permanently.
A mapping method that is quite similar to specular mapping is environment mapping. The surroundings of an object are reflecting from its surface. It’s not feasible with current generation hardware to implement this correctly. This is because a ray tracing approach would be required; which can’t be done in consumer hardware. Instead, a generic view of the scene is used that is rendered by an artist or generated during startup just once. However, this view (consisting of six texture maps, one in each direction) needs to be converted into a spherical environment map. This generated map is used to lookup pixels during runtime. This map needs to be regenerated as soon as the camera orientation is changing. The Nintendo Gamecube SDK contains examples on how to do so.
Figure 10: Environment mapping.
Code fraction 2 shows how to setup the second pass matrix in this case. In addition, some care needs to be taken on how the computed environment color is used and how it interacts with the computed light color for the same pixel (i.e. fragment). A linear interpolation between those two values solves the problem and gives control over how reflective a material is. Note that highly reflective surfaces will get almost no contribution from the computed light color (which is correct, since the surface reflects the incoming light), but since color per vertex painting is done via multiplication in the lighting hardware, the painted colors will be removed. This is an example of bad shader integration, but since the solution to the problem (passing color per vertex values unmodified and multiplying in the texture environment) is a significant performance hit it also introduces other problems. The trade off seems quite reasonable.
Are more subtle but nevertheless important method is bump mapping where a height field mapped onto a surface describes its elevation per pixel without adding geometric data. On the Nintendo Gamecube two different methods are straightforward to implement. Emboss mapping computes light values per pixel. It is not possible to compute “bumped” specular highlights and reflection with this method. “Real” per pixel bump mapping using the indirect texture unit is capable of doing so (c.f. method 5).
The hardware has direct support for emboss mapping. The height field is looked up twice, first with the original set of texture coordinates as generated by the texturing artist. Afterwards with a slightly different set of texture coordinates as generated by the lighting hardware, which shifts the original texture coordinates depending of the direction of the light. Note that the amount of shifting (and therefore the resulting depth impression) comes from the scale of the normal matrix as loaded with GXLoadNrmMtxImm(); . This means that the matrices need to be scaled to the desired values. This does not affect lighting calculation since the normals are renormalized for light computations anyways, but it does mean that one mesh (i.e. set of polygons rendered with one set of matrices) can have only one depth value for emboss mapping and imposes a interdependency between the shading and geometry subsystems. The resulting height values are subtracted and multiplied by the computed light color (c.f. figure 11).
Figure 11: Emboss mapping.
Emboss mapping does not support the computation of specular highlights. However, one can just ignore the emboss map and add non-bumpy specular highlights. Nevertheless, by doing so, the dark edges of the bumpy surface will be removed (due to the adding) and the effect falls apart to some extent (not to mention that the specular highlights by itself ignore the height field completely).
Finally, emboss mapping (as bump mapping) needs binormals to describe the
orientation of
the height field on the surface. Since they need to be
transformed the same way the normals
are transformed this can add a bit
overhead.
Visually better results can be achieved using “real” bump mapping as supported with the indirect texture unit. Using this method the hardware computes a normal per pixel and uses that to lookup different textures including a diffuse light map (containing all directional and ambient lights), an environment map (as described in method 3) and even a specular map. Thereby all those shading effects are computed correctly in a bumped way. However, since the global lights are now fetched from a texture instead of being computed by the lighting hardware, the texture needs to be generated dynamically as soon as the camera orientation and/or the lights change (again, one can find an example on how this is done in the demo section of the Nintendo Gamecube SDK).
In addition, the height field needs to be pre-processed into a “delta U/delta V texture” (which is an intensity/alpha texture with four bit per component) and therefore needs (without further measures) twice as much memory for texture storage than the emboss mapping method described in method 4.
Figure 12: Bump mapping.
The delta-texture is fed into the indirect unit where it is combined with the surface normals, describing the orientation of the bump map. In the last stage of this three-cycle setup, the diffuse light map is looked up and the result is the bumped light color for the global lights. Note that the local lights are still computed per vertex (because they have a location and the normal used as input data does not give this information) and are added later in the texture environment.
Figure 13: Actions in the texture environment and
the
indirect texturing unit during bump mapping.
Since the computation of the perturbed normal is so elaborate, doing more than one lookup with the computation result amortizes the effort slightly. Specular highlights and environment reflections can be looked up in subsequent stages. The lookup of the bumped specularity is a bit tricky, since the coordinates are kept in the indirect unit and passed from stage to stage. However, they are already denormalized and this is what makes it tricky (c.f. code fraction 3). The processes in the texture environment and the indirect texture unit are described in figure 13.
Per-object self-shadowing can be realized quite nicely on the Nintendo Gamecube. The benefit of doing self-shadowing on a per object basis is that one does not need to be concerned so much with precision. Almost all reasonably sized (e.g. in diameter) objects can be represented nicely in an eight-bit Z texture as needed by the algorithm. To figure out if a pixel falls within shadow or not the object is pre-rendered from the viewpoint of the main directional light. “Viewpoint” means, the point that is reached when going backwards in the light direction from the center point of the model in question (note that a directional light by itself does not have a point of origin). This pre-render step is done using an orthogonal projection and the top/down, left/right and near/far planes have to be set in a way that the texture area used for pre-rendering is used to its maximum extend (i.e. deriving this planes from the bounding sphere). After the pre-rendering is complete, the Z buffer is grabbed.
Later, when the object is rendered into the view, each rendered pixels coordinates are projected into texture coordinates of the grabbed Z texture. Using a ramp texture, the distance of each pixel to the imaginary light point is measured and the resulting two values are compared. Depending on the outcome of this test, the rendered fragment either falls into shadow or not. Local lights are passed through a second color channel and added conditionally to the global colors (c.f. figure 14). Yet again, the Nintendo Gamecube SDK contains examples that describe the technical details.
Figure 14: Self shadowing.
A similar technique is projecting shadows. In this case, the shadow is not cast on the object in question itself but onto receiver geometry. Once again, the object is pre-rendered from the imaginary point of light using an orthogonal projection (same as in method 7). However, now one does not grab Z values but the outline of the object in the color buffer. This outline is rendered in a second pass on the receiver geometry (using the receiver geometry itself and compute texture coordinates from its vertices). Strictly speaking, with the texturing capabilities there is no need to render the receiver geometry in a second pass, however, allowing multiple shadows to be cast on one piece of receiving geometry would add much to the complexity of the algorithm. Nevertheless, if the number of shadows is fixed, one should render them in a single go to save on transform time (c.f. figure 15 for more details).
This approach results in a big requirement for the geometry subsystem. It needs to be able to return chunks of geometry. Of course, one just needs to re-render those polygons that are affected by the shadow outline. Fast methods of constructing these chunks are an important requirement.
Figure 15: Projected shadows.
During the second render pass, one has two options to shade the fragments:
darkening the pixels that fall in shadow, or re-rendering the pixels as
described by the receivers material properties omitting global directional
light.
It is worth noting that the pre-render passes for the projected
shadows can be easily combined with the pre-rendering passes required for
self-shadowing. This is because both render the object from the same virtual
point of light. Instead of rendering one depth map and another outline just the
depth map is rendered and grabbed. Nothing changes for the self-shadowing
technique. However, the during rendering the projected shadows onto the receiver
geometry the actual Z values are fetched and compared against 0xff, which
represents the far clipping plane during the pre-render pass for self-shadowing.
If the fetched depth is < 0xff the receiver geometry falls into shadow
otherwise it is exposed to light.
Projected Reflections are very similar to projected shadows (c.f. figure 16). A receiving piece of geometry is re-rendered here as well. In this case, the object is pre-rendered from an imaginary viewpoint, which the object would be looked at if the camera would be mirrored at the reflective plane. In this case, however, it is important that a perspective projection is used to project the geometry onto the receiving geometry.
If the reflective geometry is intersecting the mirroring plane (as it could be the case with water being the reflective element in a scene), pixels falling underneath that plane must be carefully cut-off. Outputting an alpha of zero for those pixels (using the same techniques as described in method 10, layered fog) and configuring GX to skip alpha = 0 pixels does the job.
Figure 16: Projected reflections.
To compute layered fog (e.g. fog, which changes its intensity not only based on the distance to the camera but also on the height in world space) one needs to compute/lookup an intensity value, which describes how much a pixel is fogged. To do so, a texture coordinate generation is setup that transforms vertices back from eye into world space using the dual transform feature. It’s nice that one can actually use exactly the same matrix (e.g. GX_PNMTX0) to do the first part of the texture coordinate transformation. The second matrix multiply maps the Y component onto a ramp texture. Scaling and transformation have to be carefully adjusted to map the wanted gradient of world Y coordinates onto the U [0, …, 1] range. In the same manner eye Z is mapped into V [0, …, 1], c.f. figure 17 and code fraction 4 for more details.
Figure 17: Layered Fog.
Note that one could use a color texture instead of an intensity texture to get results that are even more advanced.
There is a drawback generating layered fog like this. It only works right as long as the camera is reasonably outside the fog volume. As soon as it dives deeply into it and looks up, the un-fogged polygons higher up are still visible. However, that can be compensated with figuring out how much the camera is in fog (height wise) and then fog everything, i.e. dynamically adjusting the fog ceiling.
For some surfaces banding is a problem. Especially sky textures with their subtle color gradients suffer when the frame buffer is configured using a destination alpha buffer that is required by so many rendering methods (only six bits are stored per component to allow for an additional six bit alpha channel). The built in hardware dither helps already, however, the results could be better. Adding a repetitive pattern to the outputted pixels fools the human eye into not recognizing the banding as much as before. The pattern just needs to be a “four x four” pixel texture that contains biased positive and negative offsets that are added to the outputted pixels. Additional control can be given, when the dither pattern is multiplied by a factor before adding and therefore adjustment of the dither strength is possible. The only problem here is that the dither pattern must be screen-space aligned. Each vertex must be transformed into screen space aligned texture coordinates. A trick similar to the one used in method 10 (layered fog) helps here (c.f. figure 18). The incoming vertices are transformed into eye space using the regular model to eye matrix and using the dual transform feature the dither pattern is aligned onto the screen.
Figure 18: Custom dithering.
Many of the sketched shading methods require pre-rendering objects. This suggests that pre-rendering has to become an integral component of the game program and measures need to be taken to ensure proper resource usage for both processing time and texture storage. The first thing is that pre-render passes should be combined when possible (c.f. method 7 and method 8). This is quite an obvious gain both in time and in storage.
In addition, storage should be organized in pools that provide a fixed number of slots to be rendered into. Before pre-rendering starts, all objects that require it have to be gathered, sorted by distance from the camera and then get slots assigned (the first couple of slots can even have a slightly bigger texture size). If the pool runs out of slots, pre-rendering stops and some object will loose their respective properties (like self shadowing).
The last and most important thing is that shading and geometric information have to be strictly separated. It must be possible to render an object fully lit, with all texturing features, etc. and to the same extent it must be easy to render just raw, fully lit polygons of the same geometry. This is because many pre-render passes just need the outline or depth values. Sending more data into the graphics processor, like texture coordinates or colors will just slow the process down. It also must be possible to render objects from different viewpoints. Unfortunately, this is only possible with the construction of different sets of matrices that all need to be computed by the CPU. Storage organization of these matrices is important. In addition, one does not need to forget that rendering the same geometry with the same set of matrices does not mean that those matrices need to be recomputed.
Figure 19: Texture coordinate generation.
A couple of shading methods are using the fragments orientation (i.e. normal data) as a basis and it is a common step to transform the model space normals into eye space first. Therefore, it is a good idea to split all texture coordinate generations into two passes. The first pass is shared between all methods and the math needs to be revised to operate on the proper eye space normals (c.f. figure 19).
A unique and very interesting feature of the Nintendo Gamecube is the indirect texture unit. It is capable of modifying/generating texture coordinates per pixel and therefore allows for a wide variation of effects. Rippled decals, heat effects and shockwaves are common uses. When it is used together with grabbing the frame buffer, the results are impressive. Figure 20 illustrates the control flow when rendering shockwaves. The problem here is that texture coordinates for the shockwave geometry needs to be computed. One more time, the dual transform feature of the texturing hardware helps. The model coordinates are transformed into eye space and then projected onto the screen using the same matrix as loaded with GXSetProjection(); . The output is rendered back into the frame buffer. The point of grabbing the frame buffer must be determined carefully since it can not be truly the very last thing since this would affect all overlays and score displays as well.
Figure 20: Indirect texturing example.
Merging different shading algorithms does not come without any effort, however, the balanced architecture of the Nintendo Gamecube supports a wide variety of methods that combined together make the visual difference.
To summarize: Care must be taken while combining algorithms, shader should be constructed out of components or parts, and separation of global and local lights helps a great deal. Consistent lighting during runtime is a big step forward. Make all geometry lit dynamically during runtime and use color per vertex just for painting, not pre-lighting. Per pixel methods usually give better results, however, they are more expensive. Geometry and shading should be strictly separated.
The landscape in Rogue Leader™ is height-map based, and uniformly divided into smaller render-units called meta-tiles (c.f. figure 21). One meta-tile covers 128x128 meters, and all triangles belonging to a meta-tile must use the same shader. This restriction is enforced to simplify and improve the triangle stripping of the landscape (on the Nintendo GameCube™, as most other modern graphics pipelines, efficient triangle stripping is important to obtain high performance). When deciding the size of the meta-tiles, local lighting also has to be considered. Since the Nintendo GameCube™ has a limited number of hardware lights (eight), large meta-tiles imply “fewer lights per area”. In addition, the larger the meta-tiles, the greater the chance to draw too much geometry with lighting enabled when it’s not necessary (which is not good – enabling hardware lights certainly do not come for free).
Figure 21: Landscape split up in metatiles and their LOD
values.
When the landscape engine was programmed, the geometry part was implemented before the landscape shaders (c.f. figure 22). This meant that during the working phase for the landscape geometry, it was hard to see how high polygon-count was needed to make the results look sufficiently detailed and complex. As the shaders started to get in place, it became clear that the complexity of the geometry could be reduced without sacrificing the complexity in visual appearance (in the final game, a typical landscape view uses about 14k triangles). This experience shows the importance of a balance between the complexity in geometry, and the shaders applied to that geometry.
Figure 22: Geometry vs. shading.
A texture layer is defined to be an affinely transformed repeated texture image. This implies that one texture image can give rise to several texture layers. Texture layers are applied to the landscape by vertically projecting them onto the surface; which is ok since the surface is a height-map, so any vertical line only intersects the surface once. Besides being easy to implement on both the tools and engine side, this approach is also memory efficient, since the texture coordinates do not need to be stored/loaded, but are derived directly from the position of the vertices (c.f. figure 23).
Figure 23: Texture coordinate generation.
The actual texturing of the landscape is done by blending/mixing several texture layers together across the surface. This multi-texturing approach eliminates the need for transition textures, and gives a varied look from a relatively few high-detail texture images. Since the scaling of a texture layer can be non-uniform, this approach can also help to combat the texture stretching which is common in height-map based landscapes in areas with steep slopes. According to the gradient of the height-map surface, one can apply texture layers that are scaled down in roughly that direction.
The work of specifying how the texture layers should be blended together was done in the in-house level design program called L3DEdit. This tool has features for managing texture layers, as well as blending them together. More technically, for each texture layer, L3DEdit maintains a corresponding gray-scale image which says how much of that texture layer should be present. These gray-scale images are called mix-maps, and the sum of all corresponding pixels from all mix-maps should always be one (or 255, if you like). L3DEdit can preview the blended landscape on the texture artist’s workstation, and allows for interactive changes to the mix-maps.
Figure 24: Mixing three texture layers.
For performance and memory reasons, on the Nintendo GameCube™ a meta-tile is not allowed to use more than three different texture layers blended together. In the data conversion each meta-tile that has non-trivial blending, is assigned a 32x32 pixels texture image that contains the mix-map information for that meta-tile. For meta-tiles that blend two or three texture layers, we store this information in four bits (I4) and eight bits (IA4) mix-map textures, accordingly. Duplicate mix-map texture tiles are ignored to preserve memory. To avoid seams between adjacent meta-tiles due to bi-linear texture filtering, only 31x31 unique pixels are used for each meta-tile – the last pixel rows are copied from the next, adjacent meta-tiles. To implement the texture layer blending on the Nintendo GameCube™, the texture environment is then set up to compute
mIT0 + (1-mI)T1
for blending two texture layers, and
mIT0 + mAT1 + (1-mI-mA)T2
for blending three texture layers (c.f. figure 24 for the most complicated case).
The self-shadowing of the height-map surface is pre-computed as a shadow table in the data conversion. It turned out that doing ground-sun line segment intersections with the landscape in real-time was too expensive; even when the results were sparsely updated and cached. The shadow table stores the ground-sun intersection result for 256 different sun positions for each height-map vertex (in the game in-between values are interpolated). On a meta-tile basis, series of 256 intersection results is efficiently encoded for in a state-change array, and the number of state-changes is stored using a simple form of static Huffman encoding. The size of the shadow table is of course very dependent on how the sun is moving. In most levels, the shadow table is small (150-300k), but in some level where the sun is raising the table is >800k. In the game engine, meta-tile shadow information is decoded when it’s needed, and cached together with other vertex data. To get softer shadows a nine point/tap filter is applied to the shadow values (c.f. figure 25).
Figure 25: Landscape self shadowing.
This filter smoothes the shadow values, and can be efficiently implemented using only four additions and two shifts (by reusing previously computed columns for adjacent vertices). These shadow values are then sent to the texture environment as a color per vertex. The polygon interpolated shadow value is then multiplied with the global light color.
Together with the texture layers, additional effect maps are used to further enhance the detail/depth impression: emboss style bump-mapping, far-distance detail map, and a cloud map. The emboss style bump mapping is only used for up-close meta-tiles. A color per vertex value describes how to fade the map in/out over distance (these values are the level of detail morphing values from the height-map geometry computation). The far-distance detail map is used to break up repeated texturing far away, and it’s faded out close to the camera. This fade is done similar to how the emboss map is fading. The cloud map is used to give the impression of clouds casting moving shadows on the ground. It’s also just a vertically projected map, but this time with an animated translation.
At first the height-map tiles were drawn in front to back order, but since this resulted in a lot of shader changes, it turned out that it was far more efficient to first sort the meta-tiles in shader order (and within one set of meta-tiles using the same shader, sort front to back).
A trick that is worth mentioning is how to avoid sending the same bi-normals and tangents for emboss mapping repeatedly to the transform unit (XF) of the graphics processor. It turns out that if these vectors are not present in the vertex format, XF will provide the previously transformed bi-normal and tangent, which reside in internal registers. Thus, if a dummy triangle is drawn with the bi-normal and tangent immediately before the landscape is drawn, then there is no need to send the same vectors over again for the rest of the height-map triangles. This means that only one vertex format is needed for the entire landscape, and it saves memory, transfer bandwidth and most importantly transform performance.
The landscape in Rogue Leader uses a multi-texturing approach that is implemented with a specialized set of shaders for blending/mixing texture layers. For efficient processing, the landscape if divided into manageable render-units. This is also important for utilizing the local lighting hardware support. To obtain high performance, it’s important to achieve efficient triangle stripping, and minimize the number of shader changes.
void shadingMath_ComputeSpecularPostMtx(mt32 *pOut, v32 *ldir_viewspace, f32 size)
{
f32 scale, dotp, r, tweak;
v32 vaxis, vhalf;
q32 q;
// convert input...
assert(size >= 0.0f && size <= 1.0f);
size = mathClampMinMax(size, 0.0f, 1.0f);
tweak = (PHONG_MAX - PHONG_MIN)*size + PHONG_MIN;
// check for singular point...
dotp = -ldir_viewspace->z;
if (dotp <= -1.0f)
{
mathMatSetScale(pOut, 0.0f);
return;
}
// The obtained half-angle vector directs an opposite side...
if (dotp >= 1.0f)
{
// Looking exactly with the light...
mathMatInit(pOut);
}
else
{
vhalf.x = -ldir_viewspace->x;
vhalf.y = -ldir_viewspace->y;
vhalf.z = -ldir_viewspace->z + 1.0f;
mathVecNormalize(&vhalf);
r = facos(-vhalf.z);
vaxis.x = -vhalf.y;
vaxis.y = vhalf.x;
vaxis.z = 0.0f;
mathQuatMakeRad(&q, &vaxis, r);
mathQuatToMatrix(pOut, &q);
};
scale = 2.0f * tweak + 1.5f;
mathMatAddScale(pOut, scale);
pOut->m[RD_U][RD_T] =
pOut->m[RD_V][RD_T] = 0.5f;
// setup w to be always one...
pOut->m[RD_W][RD_X] =
pOut->m[RD_W][RD_Y] =
pOut->m[RD_W][RD_Z] = 0.0f;
pOut->m[RD_W][RD_T] = 1.0f;
}
void shadingMath_ComputeSphereLookupPostMtx(mt32 *pOut, f32 nrm_scale, bool bBinormal)
{
mathMatSetScale(pOut, nrm_scale * 0.5f);
pOut->m[RD_V][RD_Y] *= -1.0f;
pOut->m[RD_U][RD_T] =
pOut->m[RD_V][RD_T] = bBinormal ? 0.0f : 0.5f;
// setup w to be always 1.0f -> i.e. 'disable' w divide...
pOut->m[RD_W][RD_Z] = 0.0f;
pOut->m[RD_W][RD_T] = 1.0f;
}
Code Listing 3: Correcting texture coordinates for bumped specular
lookups.
// compute fancy mtx...
shadingMath_ComputeSpecularPostMtx(&m, shadingLightGroup_GetPhongDirEye(), cosinePower);
// get correction factor...
f = (f32)gpSG->GetEnvMapSize() / (f32)GXGetTexObjWidth(pSpecMap);
// need to 'undo' lightmap lookup...
m.m[RD_X][RD_RIGHT] += -0.5f * f;
m.m[RD_Y][RD_UP] += 0.5f * f;
m.m[RD_X][RD_T] += -0.5f * f;
m.m[RD_Y][RD_T] += -0.5f * f;
GXLoadTexMtxImm(m.m, GX_PT_SPECULAR_FROM_NORM, GX_MTX3x4);
static u8 _fogFunction(tLayeredFog *pFog, f32 x, f32 y)
{
f32 v;
assert(pFog);
assert(x >= 0.0f && x < pFog->rampWidth);
assert(y >= 0.0f && y < pFog->rampHeight);
assert(pFog->inFogFactor >= 0.0f && pFog->inFogFactor <= 1.0f);
x /= pFog->rampWidth - 1.0f;
y /= pFog->rampHeight - 1.0f;
// height...
v = x * x;
v = v * (1.0f - pFog->inFogFactor) + pFog->inFogFactor;
// distance...
v *= y * y;
v *= 255.0f;
return ((u8)mathClampMax(v, pFog->currentSettings.maxIntensity));
}
Copyright © 2003 CMP Media Inc. All rights reserved.


DAYANANDA SAGAR COLLEGE OF ENGINEERING
DEPARTMENT RATING FORM
BRANCH
AERONAUTICAL ENGINEERING
AUTOMOBILE ENGINEERING
BIOTECHNOLOGY
CHEMICAL ENGINEERING
COMPUTER SCIENCE AND ENGINEERING
CIVIL ENGINEERING
CONSTRUCTION TECHNOLOGY & MANAGEMENT
ELECTRICAL AND ELECTRONICS ENGINEREING
ELECTRONICS & COMMUNICATION ENGINEERING
INDUSTRIAL ENGINEERING & MANAGEMENT
INFORMATION SCIENCE & ENGINEERING
ELECTRONICS AND INSTRUMENTATION ENGINEERING
MECHANICAL ENGINEERING
MEDICAL ELECTRONICS
TELECOMMUNICATION ENGINEERING
YEAR
SEMESTER
ODD
EVEN
submit


-
iPhone 6 Tracks Users By Default, And It's Tricky To Opt Out: Here's How ...
www.businessinsider.com
Step by step.
-
EU Privacy Watchdogs Give Google Guidelines To Change Privacy Practices
www.businessinsider.com
They want to know exactly what Google uses its user data for.
-
A Girl Jumped Out Of A Plane To Show How Much She Wants An Internship At ...
www.businessinsider.com
The internship pays $100,000.
-
10 Things In Tech You Need To Know Today
www.businessinsider.com
Apple opens up about bendgate, Marc Andreessen has a warn for startups, and what it's like being addicted to "Clash of Clans."
-
Top Apple Execs Sold $143 Million Of Their Stock Right Before AAPL Dropped
www.businessinsider.com
Some of the big names at Apple have sold off stock in a series of planned sales.
-
8 Enterprise Startups Founded By Ex-Salesforce Employees
www.businessinsider.com
We’ve put together 8 of the more interesting startups launched by ex-Salesforce.com employees through the years.
-
If Your Phone Got Screwed Up By The iOS 8 Update, There's a New Update ...
www.businessinsider.com
Apple released a new update to iOS 8 called iOS...
-
China's iPhone 6 Black Market Is Falling Apart
www.businessinsider.com
iPhones are becoming less valuable by the minute.
-
Disney's Deal With Dish Network Reveals Why Cable Companies Are Terrified ...
www.businessinsider.com
“They’re in denial about the implications of what they’re doing.”
-
A Former iPhone Engineer Thinks Apple Is 'Terrible' At Using The Data It ...
www.businessinsider.com
A former Apple employee doesn't believe the company will make good use of the information its watch will collect about you.
-
Civilians With Drones Lead Charge In Search-And-Rescue Efforts
www.businessinsider.com
VIDEO: Civilians utilize aerial drones to assist in finding people who have gone missing.
-
Every Entrepreneur Should Read This Guide From A Facebook Co-Founder
www.businessinsider.com
It's not as easy as the media and Hollywood make it look, says Dustin Moskovitz.
-
The most important chart about the American economy you'll see this year
www.vox.com
Economic growth used to mean rising incomes for all families, but in the early years of the most recent recovery the typical household actually saw ...
-
The Secret Goldman Sachs Tapes
www.bloombergview.com
The public doesn't seem to understand just how dysfunctional our financial regulatory system is, Michael Lewis writes. That may change today with a ...
-
This Chart Shows The Major Problems Bill Gross Was Having At PIMCO Before ...
www.businessinsider.com
The bond king's throne is at risk.
-
China Is Finally Doing Something About Its Ghost Cities
www.businessinsider.com
China will more strictly police the expansion of cities to stop the spread of highly developed but sparsely populated cities or districts known as ...
-
HIRING BILL GROSS JUST MADE JANUS SHAREHOLDERS $830 MILLION
www.businessinsider.com
Janus shares are surging after news Bill Gross is joining the firm.
-
BILL GROSS LEAVES PIMCO - JOINING JANUS CAPITAL
www.businessinsider.com
Bill Gross has left PIMCO for Janus Capital...
-
QATAR SHEIKH: Failure To Get Rid Of Both Assad And ISIS Will Repeat The ...
www.businessinsider.com
The U.S.-led fight against Islamic State militancy will not succeed as long as Syrian President Bashar al-Assad remains in power.
-
GDP GROWTH REVISED UP TO 4.6%
www.businessinsider.com
The third estimate for Q2 GDP is expected to show economic growth of 4.6% during the quarter.
-
US Airstrikes Are Pressuring Al Qaeda's Syria Group To Rejoin ISIS
www.businessinsider.com
The strikes are having an unintended consequence.
-
This Man Escaped North Korea By Biking For 12 Days Straight Through China
www.businessinsider.com
Now, he's singing at Harvard.
-
Study Finds That Up To Half Of Antibiotics Fail Due To 'Superbugs'
www.businessinsider.com
They studied 22 years of data.
-
Ukraine Prime Minister: Putin Is Using Winter As A Weapon
www.businessinsider.com
He says Russia wants Ukraine to "freeze."
-
5 Things The Most Productive People Do Every Day
www.businessinsider.com
VIDEO: Learn to balance and prioritize your tasks.
-
MICHAEL LEWIS: The 'Ray Rice Video' Of Wall Street Has Arrived
www.businessinsider.com
Secret recordings provide a look inside The New York Fed.
-
Chief Exec Of Italian Bank UniCredit: Sanctions Are Hurting Europe More ...
www.businessinsider.com
The sanctions are restricting Russian companies access to Europe.
-
World Health Organization: Experimental Ebola Vaccine Doses Will Be Ready ...
www.businessinsider.com
This could turn the tide on Ebola.


Matthew Eichler Coder & DevOps Engineer
Amazon Web Services, Docker, Ruby/Rails, React/React Native, Clojure/ClojureScript
Fulfilling the role of DevOps for FireEye's global intelligence applications which allow both Security Analysts internally and Customers externally to be fully informed about the latest Cyber threats and indicators. Supporting various international and distributed teams which include both Developers and Analyst end users. Assisting in maintenance, improvement and security of these systems including moving towards a Cloud Native architecture. Depending on the projects, teams may use Scrum or Kanban. Since the role was started during the first COVID-19 lockdown, work is done 100% remotely with virtual meetings.
A product start-up for reverse mortgages in the Netherlands following a "growth hacking" model. Fulfilled the role of Full Stack Developer plus coordinated all Developer Operations including release management and continuous deployment in the Amazon cloud.
A green field application to modernize and further automate the modem refurbishing factory process when the devices (ADSL and VDSL) come back from Tele2 customers that have cancelled their subscriptions. The application uses the latest Network Management Services tools and workflow framework and is built with the collaboration of the NMS team.
Full Stack Web Developer for the platform solutions group Sping working on the next generation applications for Kolibrie HRM including job, employee, payroll, contract and partner management. The flexible team consisted of up to ten members including two developers working remotely in Portugal.
Senior Developer for the Reisbalans portal which enabled organizations and their employees to order and manage mobility cards with multiple transportation services such as OV Chipkaart, leased/shared autos, fuel, bicycle/eBike rentals and parking. Employees can manage the various trips and transactions as well as submit expenses to their employers. The later is also supported by a mobile app. The portal also included support for Mobiliteitsfabriek customer service and automated invoicing of organizations. The objective was to assist the team in Amersfoort to take over the project from the Zilverline team in Amsterdam which consisted of 7 Developers with a Product Owner.
Senior Ruby/Rails Developer for the Fuga Royalty accounting system which calculates royalty statements for worldwide labels with catalogs in various media including digital download and streaming formats such as iTunes, Spotify, Pandora amd Amazon Prime. The Scrum Team includes three senior Ruby Developers plus a Product Owner.
Web Developer (React and Rails) for the start-up. Beginning with a green field, was instrumental in establishing an Agile process using TDD, BDD, CI, CD and Scrum. Product is ReelMetrics, a cloud datamart with browser reporting for electronic gaming machines in the casino business. System Integration includes Pentaho BI server, Okta SSO, Community Charting Components (visualizations). Web team included up to 5 developers; also filled in the roles of Team Leader and Scrum Master.
A combination Ruby and Java Developer on a large team and long running project to modernize and improve integration of source code control, software configuration, packaging and deployment of ASML's key products. This is an Agile team using TDD, BDD, CI, CD and Scrum. System Integration includes Atlassian SDK, git, Gradle, Artifactory and Jenkins.
Provided best practices mentoring for this online learning start-up focused on professionals in Corporate Finance.
Developer for the next generation traffic and parking enforcement systems prototype using license plate recognition cameras. This prototype eventually became the current production system used for traffic enforcement at the Rijksmuseum tunnel.
Developer with an agile, Scrum Rails team to build the entire system supporting the workflow for SYNTRA to administer and support their vocational training centers in Flanders including the approval, inspection, accreditation and financing/subsidizing processes. The project is entirely in the Flemish language.
E-learning start-up redefining education in the Netherlands. The original goal was an online study help system for Dutch university students of math and finance, but the company has since pivoted to a completely different audience and product.
Developer on payments Scrum team. The payments engine is the principal source of revenue for this company and supported Spil Games portals all over the world for many combinations of games, languages, currencies and local payment methods.
PHP and Zend Framework web frontend and backend services development for this health care products provider including patient dossier tracking and order systems
Java enterprise, Oracle, Ruby applications development and maintenance including 4Sight integration (Fortis Bank Netherlands was merged with ABN AMRO in July 2010).
GIDS (static data menagement) project, Euronext Mifid Reporting project, Eurex Repo Trade Connector project, Global Clearance Reporting project (Fortis Bank Netherlands merged with ABN Amro in July 2010)
Agile Java enterprise projects including Nationale Autokaart, Rabobank Minitix and MeetingPoint Marketing/Data Warehouse projects
Agile Java enterprise project for the financial start-up Cashferium including development of web services/interfaces, data model and ORM mapping. Cashferium has since gone bankrupt.
Developed web services to third party vendor for publishing travel package details to Vrij Uit principally using Java, Oracle Objects and Oracle XDB


nips nips2010 nips2010-59 nips2010-59-reference knowledge-graph by maker-knowledge-mining
Source: pdf
Author: Yuanqing Lin, Zhang Tong, Shenghuo Zhu, Kai Yu
Abstract: This paper proposes a principled extension of the traditional single-layer ﬂat sparse coding scheme, where a two-layer coding scheme is derived based on theoretical analysis of nonlinear functional approximation that extends recent results for local coordinate coding. The two-layer approach can be easily generalized to deeper structures in a hierarchical multiple-layer manner. Empirically, it is shown that the deep coding approach yields improved performance in benchmark datasets.
[1] http://yann.lecun.com/exdb/mnist/.
[2] Samy Bengio, Fernando Pereira, Yoram Singer, and Dennis Strelow. Group sparse coding. In NIPS’ 09, 2009.
[3] D P. Bertsekas. Projected newton methods for optimization problems with simple constraints. SIAM J. Control Optim., 20(2):221–246, 1982.
[4] Dimitri P. Bertsekas. Nonlinear programming. Athena Scientiﬁc, 2003.
[5] David Bradley and J. Andrew (Drew) Bagnell. Differentiable sparse coding. In Proceedings of Neural Information Processing Systems 22, December 2008.
[6] M. Everingham, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The PASCAL Visual Object Classes Challenge 2007 (VOC2007) Results. http://www.pascalnetwork.org/challenges/VOC/voc2007/workshop/index.html.
[7] Mark Everingham. Overview and results of the classiﬁcation challenge. The PASCAL Visual Object Classes Challenge Workshop at ICCV, 2009.
[8] G. E. Hinton and R. R. Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504 – 507, July 2006. 8
[9] Honglak Lee, Alexis Battle, Rajat Raina, and Andrew Y. Ng. Efﬁcient sparse coding algorithms. In Proceedings of the Neural Information Processing Systems (NIPS) 19, 2007.
[10] Michael S. Lewicki and Terrence J. Sejnowski. Learning overcomplete representations. Neural Computation, 12:337–365, 2000.
[11] J. Mairal, F. Bach, J. Ponce, G. Sapiro, and A. Zisserman. Supervised dictionary learning. In NIPS’ 08, 2008.
[12] B.A. Olshausen and D.J. Field. Emergence of simple-cell receptive ﬁeld properties by learning a sparse code for nature images. Nature, 381:607–609, 1996.
[13] Rajat Raina, Alexis Battle, Honglak Lee, Benjamin Packer, and Andrew Y. Ng. Self-taught learning: Transfer learning from unlabeled data. International Conference on Machine Learning, 2007.
[14] Marc Aurelio Ranzato, Y-Lan Boureau, and Yann LeCun. Sparse feature learning for deep belief networks. In NIPS’ 07, 2007.
[15] Jianchao Yang, Kai Yu, Yihong Gong, and Thomas Huang. Linear spatial pyramid matching using sparse coding for image classiﬁcation. In IEEE Conference on Computer Vision and Pattern Recognition, 2009.
[16] Kai Yu and Tong Zhang. Improved local coordinate coding using local tangents. In ICML’ 09, 2010.
[17] Kai Yu, Tong Zhang, and Yihong Gong. Nonlinear learning using local coordinate coding. In NIPS’ 09, 2009. 9


Event handlers are functions that must be defined before the Cloudy bootstrap.
#!/usr/bin/env bash
...
#
# Define all event handlers here.
#
# Begin Cloudy Bootstrap
s="${BASH_SOURCE[0]}";while ...
To see the available events recursively search codebase for event_dispatch "
.
If you define this function before the bootstrap it will be called once the minimum bootstrap has been called. To see an example of this you can look to the tests
path in cloudy_installer.sh.
Imagine a custom event like showing info. Let's call the event show_info
. You Cloudy script will fire or trigger the event with a line like this:
event_dispatch "show_info" "do" "re" "mi"
local trigger_result=$?
How might another script respond to this event?
function on_show_info() {
local do=$1
local re=$2
local mi=$3
...
}
You can register custom callbacks using event_listen
. See below...
additional_bootstrap
filesIn some cases you will need to add your listeners in a custom bootstrap file which is registered in your configuration as additional_bootstrap
. They are sourced after all configuration has been loaded. The contents of such file could look like this:
#!/usr/bin/env bash
function here_we_go() {
debug "$FUNCNAME;\$FUNCNAME"
}
event_listen "boot" "here_we_go"


---
layout: post
title: Reindeer, Rabbit, Santa
date: '2013-12-24T07:30:00+01:00'
categories:
- Ello Mobile
- Illustration
- Klare Lijn — Ligne Claire
picture_url: https://film-Storyboards.tumblr.com/post/71004389223/reindeer-rabbit-santa
---
Rough and Illustration for Ello Mobile Season Greetings Newsletter.


{% extends "base/__normal.html" %} {% block title %}ERROR!{% endblock %} {% block content %}
Please do not try to do things you're not supposed to.