{% extends "app/layout.html" %} {% block content %} {% load crispy_forms_tags %} {% crispy RangeDateForm RangeDateForm.helper %}
Django is a free web framework for building great Web sites and Web applications using HTML, CSS and JavaScript.
Django gives you a powerful, patterns-based way to build dynamic websites that enables a clean separation of concerns and gives you full control over markup for enjoyable, agile development.
The Python Package Index is a repository of software for the Python programming language.
You can easily publish to Microsoft Azure using Python Tools for Visual Studio. Find out how you can host your application using a free trial today.


Home
Vermont :: Locate The Law
Constitution
Vermont Constitution
(Vermont Legislature)
Colonial Charters, Grants and Related Documents: Vermont
(Yale Avalon Project)
includes three documents including the 1777 and 1786 constitutions
Executive
Administrative Procedures Act/Rules
(Vermont State Archives)
administrative compilation and register not available online
Adminsitrative Rules Weekly Notice Page
(Vermont State Archives)
includes links to notices
Vermont Governor
Vermont Governor Executive Orders
Vermont Attorney General
Vermont Attorney General Opinions
Vermont Secretary of State
- includes databases
Vermont Elections and Campaign Finance Division
Judicial
Vermont Supreme Court Opinions
(Vermont Department of Libraries)
Vol. 161 (July 1993-
Vermont Supreme Court Opinions
(FindLaw)
1997-
Vermont Environmental Court Opinions
(Vermont Department of Libraries)
1995, 1999-
Vermont Workers' Compensation Decisions
(Vermont Department of Libraries)
1995-
Vermont Labor Relations Board Decisions
(Vermont Department of Libraries)
May 1995-
Vermont Professional Responsibility Board Decisions
(Vermont Department of Libraries)
U.S. Court of Appeals, 2d Circuit Opinions
(FindLaw)
1995-
U.S. District Court, District of Vermont
- includes local rules (PDF) and opinions
U.S. Bankruptcy Court, District of Vermont Opinions
- since November 1999, in PDF; No. 85-96 (October 7, 1995-
Vermont Court Rules
Vermont State Courts
(Vermont Judiciary)
Legislative
Vermont Statutes Online
- includes a list of statutes by title
Vermont Statutes
(Michie)
Vermont Public Acts and Resolves
1993/1994-
Vermont Bills
1993/1994-
Vermont Legislature
- composed of the Senate and House of Representatives
Frequently Asked Questions
(Vermont Legislature)


Fair Information Practices
Fair information
Practices
Refund Policy
Your account will be credited when we receive payment from your financial institution. If the transaction completes successfully and is honored by your financial institution you can still apply for a refund within 7 days of the transaction completing. Please be advised however that reversing out an online payment will remove that payment from your rental payment history and could result in late fees or the violation of the terms of your lease.
Contacting Us
If you have any questions about this policy, please contact L'Enfant Apartments LLC. Contact details
here
This document was updated January 25, 2017


NetworkKit Framework
A lightweight iOS, Mac, watchOS and tvOS framework that makes networking and parsing super simple. Uses the open-sourced JSONHelper with functional parsing. For networking the library supports basic GET, POST, DELETE HTTP requests.
github


Wordpress and other CMS's already use the power of the database to drive web page content. appGoo is different in the fact that it delivers the raw capability for you to scaffold on your own logic of generating content from within the database. You do not inherit all the overhead and potential bloat of a full-blown CMS, you can choose one of appGoo's application development components, or develop your own to meet your specific requirements.
The PostgreSQL database does not require much tuning until the usage requirements become significant. Therefore it is easy to achieve delivery of complex web pages in milliseconds without the need for specialist tuning skills.
PostgreSQL is fast at serving data. Really fast. Users love speed. The webpage can be static - like this page - but appGoo really shines when significant data manipulation and manipulation of the page content needs to occur. As all processing occurs within the database itself, it is ACID and it is highly efficient. appGoo is primarily designed for applications as opposed to web sites - but excels at web sites too. appGoo loves data at speed, and that is what applications require. Data inserts, updates and deletes can all occur as part of a single ACID transaction that includes the generation of the resulting web page. Analytics with realtime data aggregation and presentation through modern javascript libraries like D3.js are also an ideal use of appGoo that gives users snappy pages that encourages deep and engaging use.
Engineers have put considerable thought and sophistication into the design of databases - PostgreSQL is no exception. The database that serves web content will naturally scale with the usage of your application - without you having to change anything - until the requirements and usage become significant. This allows you to concentrate on the design of your web site or application.
When massive scale is required you can utilise the standard features of PostgreSQL - replication & clustering as well as add-ons that you can deploy for sharding and other massive performance capabilities.
Refer to the PostgreSQL documentation for further details. The result is that you have a high powered data workhorse to serve the needs of your application allowing you to efficiently build, prototype & deliver powerful applications.
Its not just serving up web pages to users that appGoo can be used for. API requests can also be processed through appGoo and data either inserted, updated, deleted and/or retrieved as a result of the call. appGoo can cater for thousands of APIs all the while serving pages to users. Being an ACID compliant database, the success of the API call will be referentially enforced by the successful completion of the function call within the database. Less complexity for you to cater for in your code, and high performing APIs as a result.
The application code and the related data all co-exist within the database - backups, replication & high availability clusters ensure that both the data and application are recoverable. Both the application version and the data will be in sync due to this co-existence, therefore the complexity of incremental code updates and corresponding data updates is simplified.
The end result is simplicity - allowing you to concentrate on designing & developing your application.
As web requests can be completed within milliseconds and concurrent scale is a core capability of the database - hundreds and thousands of requests can be served in a second. Whilst it depends upon the nature of the web site or application, it is possible to support thousands of users through an AWS T2.small (1 vCPU, 2GB RAM) at about US$0.02 per hour or less than US$15 per month. Even less for development instances which only need a T2.micro
This is low cost computing. Even larger scale applications with realtime aggregation can support tens or hundreds of users with 4 CPUs and 8GB RAM. The larger the ram, the larger the database cache that is possible to achieve even faster processing where possible.
appGoo can be deployed on the same server as the database resulting in the database being locked away from the outside world and Apache hardened to only permit genuine requests - thus resulting in an extremely simple cost effective architecture that is highly secure and easy to establish and maintain. Focus on the application design and build, not the peripheral deployment challenges of other development architectures.


Home
For Men
For Women
My Profile
CSS transforms are not supported in your browser
CSS transitions are not supported in your browser
Sorry, only modern browsers.
Ratings
by Likes
Latest
by updated date
Recomended
by our designers


This is an Oxford Visual Geometry Group computer vision practical, authored by Andrea Vedaldi and Andrew Zisserman (Release 2018a).
The goal of object category detection is to identify and localize objects of a given type in an image. Examples applications include detecting pedestrian, cars, or traffic signs in street scenes, objects of interest such as tools or animals in web images, or particular features in medical image. Given a target class, such as people, a detector receives as input an image and produces as output zero, one, or more bounding boxes around each occurrence of the object class in the image. The key challenge is that the detector needs to find objects regardless of their location and scale in the image, as well as pose and other variation factors, such as clothing, illumination, occlusions, etc.
This practical explores basic techniques in visual object detection, focusing on image based models. The appearance of image patches containing objects is learned using statistical analysis. Then, in order to detect objects in an image, the statistical model is applied to image windows extracted at all possible scales and locations, in order to identify which ones, if any, contain the object.
In more detail, the practical explores the following topics: (i) using HOG features to describe image regions, (ii) building a HOG-based sliding-window detector to localize objects in images; (iii) working with multiple scales and multiple object occurrences; (iv) using a linear support vector machine to learn the appearance of objects; (v) evaluating an object detector in term of average precision; (vi) learning an object detector using hard negative mining.
Read and understand the requirements and installation instructions. The download links for this practical are:
After the installation is complete, open and edit the script exercise1.m
in the MATLAB editor. The script contains commented code and a description for all steps of this exercise, relative to Part I of this document. You can cut and paste this code into the MATLAB window to run it, and will need to modify it as you go through the session. Other files exercise2.m
, exercise3.m
, and exercise4.m
are given for Part II, III, and IV.
Each part contains several Questions and Tasks to be answered/completed before proceeding further in the practical.
Part I--IV use as running example the problem of street sign detection, using the data from the German Traffic Sign Detection Benchmark. This data consists of a number of example traffic images, as well as a number of larger test images containing one or more traffic signs at different sizes and locations. It also comes with ground truth annotation, i.e. with specified bounding boxes and sign labels for each sign occurrence, which is required to evaluate the quality of the detector.
In this part we will build a basic sliding-window object detector based on HOG features. Follow the steps below:
The MATLAB m-file loadData.m
loads the data for the practical into memory. The function loadData(targetClass)
takes a targetClass
argument specifying the object class of interest. Open the example1.m
file, select the following part of the code, and execute it in MATLAB (right button > Evaluate selection
or Shift+F7
).
% Load the training and testing data (trainImages, trainBoxes, ...)
% The functio takes the ID of the type of traffic sign we want to recognize
% 1 is the 30 km/h speed limit
loadData(1) ;
This loads into the current workspace the following variables:
trainImages
: a list of train image names.trainBoxes
: a $4\times N$ array of object bounding boxes, in the form $[x_\text{min},y_\text{min},x_\text{max},y_\text{max}]$.trainBoxImages
: for each bounding box, the name of the image containing it.trainBoxLabels
: for each bounding box, the object label. It is one of the index in targetClass
.trainBoxPatches
: a $64 \times 64 \times 3 \times N$ array of image patches, one for each training object. Patches are in RGB format.An analogous set of variables testImages
, testBoxes
, and so on are provided for the test data. Familiarise yourself with the contents of these variables.
Question: why is there a
trainImages
and atrainBoxImages
variables?
Select now the part of the code related to section 1.1 and execute it. This will create an image visualizing both the complete list of object training examples and their average.
Question: what can you deduce about the object variability from the average image?
Question: most boxes extend slightly around the object extent. Why do you think this may be valuable in learning a detector?
Object detectors usually work on top of a layer of low-level features. In this case, we use HOG (Histogram of Oriented Gradients) features. In order to learn a model of the object, we start by extracting features from the image patches corresponding to the available training examples. This is done by the following for
loop:
hogCellSize = 8 ;
trainHog = {} ;
for i = 1:size(trainBoxPatches,4)
trainHog{i} = vl_hog(trainBoxPatches(:,:,:,i), hogCellSize) ;
end
trainHog = cat(4, trainHog{:}) ;
HOG is computed by the VLFeat function vl_hog
(doc). This function takes as parameter the size in pixels of each HOG cell hogCellSize
. It also takes a RGB image, represented in MATLAB as a $w \times h \times 3$ array (extracted as a slice of trainBoxPatches
). The output is a $w/\mathtt{hogCellSize} \times h/\mathtt{hogCellSize} \times 31$ dimensional array. One such array is extracted for each example image end eventually these are concatenated in a 4D array along the fourth dimension.
A very basic object model can be obtained by averaging the features of the example objects. This is done by:
w = mean(trainHog, 4) ;
The model can be visualized by rendering w
as if it was a HOG feature array. This can be done using the render
option of vl_hog
:
figure(2) ; clf ;
imagesc(vl_hog('render', w)) ;
Spend some time to study this plot and make sure you understand what is visualized.
Question: Can you make sense of the resulting plot?
The model is matched to a test image by: (i) extracting the HOG features of the image and (ii) convolving the model over the resulting feature map:
im = imread('data/signs-sample-image.jpg') ;
im = im2single(im) ;
hog = vl_hog(im, hogCellSize) ;
scores = vl_nnconv(hog, w, []) ;
The first two lines read a sample image and conver it to single format. The third line computes the HOG features of the image using the vl_hog
seen above. The fourth line convolves the HOG map hog
with the model w
. It uses the function vl_nnconv
1 and returns a scores
map.
Task: Work out the dimension of the
scores
arrays. Then, check your result with the dimension of the array computed by MATLAB.Question: Visualize the image
im
and thescores
array using the provided example code. Does the result match your expectations?
Now that the model has been applied to the image, we have a response map scores
. To extract a detection from this, we (i) find the maximum response and (ii) compute the bounding box of the image patch containing the corresponding HOG features. The maximum is found by:
[best, bestIndex] = max(scores(:)) ;
Note that bestIndex
is a linear index in the range $[1, M]$ where $M$ is the number of possible filter locations. We convert this into a subscript $(h_x,h_y)$ using MATLAB ind2sub
function:
[hy, hx] = ind2sub(size(scores), bestIndex) ;
$(h_x,h_y)$ are in units of HOG cells. We convert this into pixel coordinates as follows:
x = (hx - 1) * hogCellSize + 1 ;
y = (hy - 1) * hogCellSize + 1 ;
Question: Why are we subtracting -1 and summing +1? Which pixel $(x,y)$ of the HOG cell $(h_x,h_y)$ is found?
The size of the model template in number of HOG cell can be computed in several way; one is simply:
modelWidth = size(trainHog, 2) ;
modelHeight = size(trainHog, 1) ;
Now we have enough information to compute the bounding box as follows:
detection = [
x - 0.5 ;
y - 0.5 ;
x + hogCellSize * modelWidth - 0.5 ;
y + hogCellSize * modelHeight - 0.5 ;] ;
Note: the bounding box encloses exactly all the pixel of the HOG template. In MATLAB, pixel centers have integer coordinates and pixel borders are at a distance $\pm1/2$.
Question: Use the example code to plot the image and overlay the bounding box of the detected object. Did it work as expected?
In this second part, we will: (i) extend the detector to search objects at multiple scales and (ii) learn a better model using a support vector machine. Let's start by loading the data as needed:
setup ;
targetClass = 'mandatory' ;
loadData(targetClass) ;
The mandatory
target class is simply the union of all mandatory traffic signs.
Objects exist in images at sizes different from one of the learned template. In order to find objects of all sizes, we scale the image up and down and search for the object over and over again.
The set of searched scales is defined as follows:
% Scale space configuraiton
minScale = -1 ;
maxScale = 3 ;
numOctaveSubdivisions = 3 ;
scales = 2.^linspace(...
minScale,...
maxScale,...
numOctaveSubdivisions*(maxScale-minScale+1)) ;
Given the model w
, as determined in Part I, we use the function detectAtMultipleScales
in order to search for the object at multiple scales:
detection = detectAtMultipleScales(im, w, hogCellSize, scales) ;
Note that the function generates a figure as it runs, so prepare a new figure before running it using the figure
command if you do not want your current figure to be deleted.
Question: Open and study the
detectAtMultipleScales
function. Convince yourself that it is the same code as before, but operated after rescaling the image a number of times.Question: Visualize the resulting detection using the supplied example code. Did it work? If not, can you make sense of the errors?
Question: Look at the array of
scores
maps generated bydetectAtMultipleScales
using the example code. Do they make sense? Is there anything wrong?
The model learned so far is too weak to work well. It is now time to use an SVM to learn a better one. In order to do so, we need to prepare suitable data. We already have positive examples (features extracted from object patches):
% Collect positive training data
pos = trainHog ;
Ino order to collect negative examples (features extracted from non-object patches), we loop through a number of training images and sample patches uniformly:
Task: Identify the code that extract these patches in
example2.m
and make sure you understand it.Question: How many negative examples are we collecting?
Now that we have the data, we can learn an SVM model. To this end we will use the vl_svmtrain
function. This function requires the data to be in a $D \times N$ matrix, where $D$ are the feature dimensions and $N$ the number of training points. This is done by:
% Pack the data into a matrix with one datum per column
x = cat(4, pos, neg) ;
x = reshape(x, [], numPos + numNeg) ;
We also need a vector of binary labels, +1 for positive points and -1 for negative ones:
% Create a vector of binary labels
y = [ones(1, size(pos,4)) -ones(1, size(neg,4))] ;
Finally, we need to set the parameter $\lambda$ of the SVM solver. For reasons that will become clearer later, we use instead the equivalent $C$ parameter:
numPos = size(pos,4) ;
numNeg = size(neg,4) ;
C = 10 ;
lambda = 1 / (C * (numPos + numNeg)) ;
Learning the SVM is then a one-liner:
% Learn the SVM using an SVM solver
w = vl_svmtrain(x,y,lambda,'epsilon',0.01,'verbose') ;
Question: Visualize the learned model
w
using the supplied code. Does it differ from the naive model learned before? How?
Use the detectAtMultipleScales
seen above to evaluate the new SVM-based model.
Question: Does the learned model perform better than the naive average?
Task: Try different images. Does this detector work all the times? If not, what types of mistakes do you see? Are these mistakes reasonable?
Detecting at multiple scales is insufficient: we must also allow for more than one object occurrence in the image. In order to to so, the package include a suitalbe detect
function. This function is similar to detectAtMultipleScales
, but it returns the top 1000 detector responses rather than just the top one:
% Compute detections
[detections, scores] = detect(im, w, hogCellSize, scales) ;
Task: Open and study
detect.m
. Make sure that you understand how it works.Question: Why do we want to return so many responses? In practice, it is unlikely that more than a handful of object occurrences may be contained in any given image...
A single object occurrence generates multiple detector responses at nearby image locations and scales. In order to eliminate these redundant detections, we use a non-maximum suppression algorithm. This is implemented by the boxsuppress.m
MATLAB m-file. The algorithm is simple: start from the highest-scoring detection, then remove any other detection whose overlap[^overlap] is greater than a threshold. The function returns a boolean vector keep
of detections to preserve:
% Non-maximum suppression
keep = boxsuppress(detections, scores, 0.25) ;
detections = detections(:, keep) ;
scores = scores(keep) ;
For efficiency, after non-maximum suppression we keep just ten responses (as we do not expect more than a few objects in any image):
% Further keep only top detections
detections = detections(:, 1:10) ;
scores = scores(1:10) ;
We are now going to look at properly evaluating our detector. We use the PASCAL VOC criterion, computing Average Precision (AP). Consider a test image containing a number of ground truth object occurrences $(g_1,\dots,g_m)$ and a list $(b_1,s_1),\dots,(b_n,s_n)$ of candidate detections $b_i$ with score $s_i$. The following algorithm converts this data into a list of labels and scores $(s_i,y_i)$ that can be used to compute a precision-recall curve, for example using VLFeat vl_pr
function. The algorithm, implemented by evalDetections.m
, is as follows:
The overlap metric used to compare a candidate detection to a ground truth bounding box is defined as the ratio of the area of the intersection over the area of the union of the two bounding boxes:
Questions:
- Why are ground truth detections removed after being matched?
- What happens if an object is detected twice?
- Can you explain why unassigned ground-truth objects are added to the list of candidates with $-\infty$ score?
In order to apply this algorithm, we first need to find the ground truth bounding boxes in the test image:
% Find all the objects in the target image
s = find(strcmp(testImages{1}, testBoxImages)) ;
gtBoxes = testBoxes(:, s) ;
Then evalDetections
can be used:
% No example is considered difficult
gtDifficult = false(1, numel(s)) ;
% PASCAL-like evaluation
matches = evalDetections(...
gtBoxes, gtDifficult, ...
detections, scores) ;
The gtDifficult
flags can be used to mark some ground truth object occurrence as difficult and hence ignored in the evaluation. This is used in the PASCAL VOC challenge, but not here (i.e. no object occurrence is considered difficult).
evalDetections
returns a matches
structure with several fields. We focus here on matches.detBoxFlags
: this contains a +1 for each detection that was found to be correct and -1 otherwise. We use this to visualize the detection errors:
% Visualization
figure(1) ; clf ;
imagesc(im) ; axis equal ; hold on ;
vl_plotbox(detections(:, matches.detBoxFlags==+1), 'g', 'linewidth', 2) ;
vl_plotbox(detections(:, matches.detBoxFlags==-1), 'r', 'linewidth', 2) ;
vl_plotbox(gtBoxes, 'b', 'linewidth', 1) ;
axis off ;
Task: Use the supplied example code to evaluate the detector on one image. Look carefully at the output and convince yourself that it makes sense.
Now Plot the PR curve:
figure(2) ; clf ;
vl_pr(matches.labels, matches.scores) ;
Question: There are a large number of errors in each image. Should you worry? In what manner is the PR curve affected? How would you eliminate the vast majority of those in a practice?
Evaluation is typically done on multiple images rather than just one. This is implemented by the evalModel.m
m-file.
Task: Open
evalModel.m
and make sure you understand the main steps of the evaluation procedure.
Use the supplied example code to run the evaluation on the entiere test set:
matches = evaluateModel(testImages, testBoxes, testBoxImages, ...
w, hogCellSize, scales) ;
Note: The function processes an image per time, visualizing the results as it progresses. The PR curve is the result of the accumulation of the detections obtained thus far.
Task: Open the
evaluateModel.m
file in MATLAB and add a breakpoint right at the end of the for loop. Now run the evaluation code again and look at each image individually (usedbcont
to go to the next image). Check out the correct and incorrect matches in each image and their ranking and the effect of this in the cumulative precision-recall curve.
This part explores more advanced learning methods. So far, the SVM has been learned using a small and randomly sampled number of negative examples. However, in principle, every single patch that does not contain the object can be considered as a negative sample. These are of course too many to be used in practice; unfortunately, random sampling is ineffective as the most interesting (confusing) negative samples are a very small and special subset of all the possible ones.
Hard negative mining is a simple technique that allows finding a small set of key negative examples. The idea is simple: we start by training a model without any negatives at all (in this case the solver learns a 1-class SVM), and then we alternate between evaluating the model on the training data to find erroneous responses and adding the corresponding examples to the training set.
Use the supplied code in example4.m
to run hard negative mining. The code repeats SVM training, as seen above, a number of times, progressively increasing the size of the neg
array containing the negative samples. This is updated using the output of:
[matches, moreNeg] = ...
evaluateModel(...
vl_colsubset(trainImages', schedule(t), 'beginning'), ...
trainBoxes, trainBoxImages, ...
w, hogCellSize, scales) ;
Here moreNeg
contains the HOG features of the top (highest scoring and hence most confusing) image patches in the supplied training images.
Task: Examine
evaluateModel.m
again to understand how hard negatives are extracted.Question: What is the purpose of the construct
vl_colsubset(trainImages', schedule(t), 'beginning')
? Why do you think we visit more negative images in later iterations?
The next step is to fuse the new negative set with the old one:
% Add negatives
neg = cat(4, neg, moreNeg) ;
Note that hard negative mining could select the same negatives at different iterations; the following code squashes these duplicates:
% Remove negative duplicates
z = reshape(neg, [], size(neg,4)) ;
[~,keep] = unique(z','stable','rows') ;
neg = neg(:,:,:,keep) ;
Once hard negative mining and training are done, we are ready to evaluate the model on the test data (note that the model is evaluated on the training data for mining). As before:
evaluateModel(...
testImages, testBoxes, testBoxImages, ...
w, hogCellSize, scales) ;
Skip on fast track
In this last part, you will learn your own object detector. To this end, open and look at exercise5.m
. You will need to prepare the following data:
data/myPositives
containing files image1.jpeg
, image2.jpeg
, ..., each containing a single cropped occurence of the target object. These crops can be of any size, but should be roughly square.data/myNegatives
containing images image1.jpeg
, image2.jpeg
, ..., that do not contain the target object at all.data/myTestImage.jpeg
containing the target object. This should not be one of the training images.Run the code in example5.m
to check that your training data looks right.
Task: Understand the limitations of this simple detector and choose a target object that has a good chance of being learnable.
Hint: Note in particular that object instances must be similar and roughly aligned. If your object is not symmetric, consider choosing instances that face a particular direction (e.g. left-facing horse head).
Use the code supplied in example5.m
to learn an SVM model for your object using hard negative mining as in Stage 4.1.
Use the code supplied in example5.m
to evaluate the SVM model on a test image and visualize the result as in Stage 2.1.
Task: Make sure you get sensible results. Go back to step 5.1 if needed and adjust your data.
Hint: For debugging purposes, try using one of your training images as test. Does it work at least in this case?
The basic detectors you have learned so far are not invariant to effects such as object deformations, out-of-plane rotations, and partial occlusions that affect most natural objects. Handling these effects requires additional sophistications, including using deformable templates, and a mixture of multiple templates.
In particular, many objects in nature are symmetric and, as such, their images appear flipped when the objects are seen from the left or the right direction (consider for example a face). This can be handled by a pair of symmetric HOG templates. In this part we will explore this option.
Task: Using the procedure above, train a HOG template
w
for a symmetric object facing in one specific direction. For example, train a left-facing horse head detector.Task: Collect test images containing the object facing in both directions. Run your detector and convince yourself that it works well only for the direction it was trained for.
HOG features have a well defined structure that makes it possible to predict how the features transform when the underlying image is flipped. The transformation is in fact a simple permutation of the HOG elements. For a given spatial cell, HOG has 31 dimensions. The following code permutes the dimension to flip the cell around the vertical axis:
perm = vl_hog('permutation') ;
hog_flipped = hog(perm) ;
Note that this permutation applies to a single HOG cell. However, the template is a $H \times W \times 31$ dimensional array of HOG cells.
Task: Given a
hog
array of dimension $H \times W \times 31$, write MATLAB code to obtain the flipped feature arrayhog_flipped
.
Hint: Recall that the first dimension spans the vertical axis, the second dimension the horizontal axis, and the third dimension feature channels. perm
should be applied to the last dimension. Do you need to permute anything else?
Now let us apply flipping to the model trained earlier:
Task: Let
w
be the model you trained before. Use the procedure to flip HOG to generatew_flipped
. Then visualize bothw
andw_flipped
as done in Sect. 1.3. Convince yourself that flipping was successful.
We have now two models, w
and w_flipped
, one for each view of the object.
Task: Run both models in turn on the same image, obtaining two list of bounding boxes. Find a way to merge the two lists and visualise the top detections. Convince yourself that you can now detect objects facing either way.
Hint: Recall how redundant detections can be removed using non-maximum suppression.
Congratulations: This concludes the practical!
This is part of the MatConvNet toolbox for convolutional neural networks. Nevertheless, there is no neural network discussed here. ↩


Gives a short text, like this one, with more information on a command. Note that the file (nagios config directory)/nagclicfg.md must exist for this to work.
It should also give some usage examples, like this:
/> explain explain
Gives a short text, like this one, with more information on a command.
It should also give some usage examples, like this:
(stopping here, documentation can get to be so recursive...;)
Takes a file or a directory as argument and adds any new objects it finds in there. Obviously the file or directory is expected to contain valid Nagios object definitions.
/> import /var/cache/nagios3/objects.cache
/command/check-host-alive: already defined.
/command/check-mysql: added.
... and so on.
Takes a file or a directory as argument and adds or replaces any objects it finds in there. Obviously the file or directory is expected to contain valid Nagios object definitions.
/> replace /var/log/nagios/objects.cache `
/command/check-host-alive: replaced.
/command/check-mysql: added.
... and so on.
Prints a tree of your Nagios configuration, leaving out most of the details. Still, it gets to be a fairly long list!
/> tree
(long list of command definitions and sensitive data omitted)...
servicegroup
+-- DNS
| +-- members -> dns,Check DNS
+-- all
timeperiod
+-- 24x7
+-- never
+-- nonworkhours
+-- workhours
hostextinfo
+-- centos_machines
| +-- hostgroup_name -> centos_machines
+-- debian-machines
| +-- hostgroup_name -> debian-machines
+-- phones
| +-- hostgroup_name -> phones
/>
Takes two arguments: the field to add and its value.
If the field is multi-value, this works identically to set.
If the field already exists this will do nothing and generate a warning.
/host/linux-server> clone
Enter a new value for name: new.machine
(output omitted)
/host/new.machine> add host_name new.machine.loc
Adding 'host_name' as 'new.machine.loc'
/host/new.machine.loc> add host_name new.machine.loc
Not adding 'host_name' as 'new.machine.loc'; item already exists. Use [set key value] instead.
/host/new.machine.loc> `
See also ifadd and set.
Takes two arguments: the field to set and its value.
If the field does not already exists this will do nothing and will generate a warning, unless the field is a multi-value field like hostgroups. Multi-value fields are simply added to, if the value was not already in the set.
Note that add and set behave identically for multi-value fields.
/> cd host/localhost
/host/localhost> ls
address alias host_name use
/host/localhost> set address <IP_ADDRESS>
Changing 'address' from '<IP_ADDRESS>' to '<IP_ADDRESS>'
/host/localhost> rm address
Removing 'address'
/host/localhost> set address <IP_ADDRESS>
Not setting 'address' to '<IP_ADDRESS>'; not an existing item. Use [add key value] instead.
/host/localhost> add address <IP_ADDRESS>
Adding 'address' as '<IP_ADDRESS>'
/host/localhost> set host_name thismachine
Updated members from a10,a20,localhost,virtmachine to a10,a20,thismachine,virtmachine
Updated members from localhost,linksys,snom320 to linksys,snom320,thismachine
Updated members from localhost to thismachine
Updated parents from localhost to thismachine
Changing 'host_name' from 'localhost' to 'thismachine'
/host/this-machine>
See also ifset and add.
Takes an optional argument that should be a relative or absolute selector of an object or a category.
If you omit the argument a list is printed you can select from.
Finally, you can add an asterisk (*) to the argument to select the first matching object or category.
/> cd /host/lin*
/host/linux-server> cd /
/> cd
0: command
1: contact
2: contactgroup
3: host
4: hostgroup
5: service
6: servicegroup
7: timeperiod
8: hostextinfo
Pick one: 4
/hostgroup>
See also ifcd.
Runs the Nagios pre-flight check. You should really read some of the Nagios documentation if this means nothing to you.
Note that NagCliCfg has build-in checks as well, you should get some messages if your configuration is inconsistent. This will not catch all cases however, run check to be sure.
/> check
Nagios Core 3.5.1
Copyright (c) 2009-2011 Nagios Core Development Team and Community Contributors
Copyright (c) 1999-2009 Ethan Galstad
Last Modified: 08-30-2013
License: GPL
Website: http://www.nagios.org
Reading configuration data...
Read main config file okay...
Processing object config directory '/etc/nagios3/nagclicfg.d'...
Processing object config file '/etc/nagios3/nagclicfg.d/hostextinfo.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/service.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/timeperiod.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/hostgroup.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/contact.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/host.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/contactgroup.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/servicegroup.cfg'...
Processing object config file '/etc/nagios3/nagclicfg.d/command.cfg'...
Read object config files okay...
Running pre-flight check on configuration data...
Checking services...
Checked 26 services.
Checking hosts...
Checked 19 hosts.
Checking host groups...
Checked 8 host groups.
Checking service groups...
Checked 2 service groups.
Checking contacts...
Checked 2 contacts.
Checking contact groups...
Checked 1 contact groups.
Checking service escalations...
Checked 0 service escalations.
Checking service dependencies...
Checked 0 service dependencies.
Checking host escalations...
Checked 0 host escalations.
Checking host dependencies...
Checked 0 host dependencies.
Checking commands...
Checked 154 commands.
Checking time periods...
Checked 4 time periods.
Checking for circular paths between hosts...
Checking for circular host and service dependencies...
Checking global event handlers...
Checking obsessive compulsive processor commands...
Checking misc settings...
Total Warnings: 0
Total Errors: 0
Things look okay - No serious problems were detected during the pre-flight check
/>
You should enter this when having selected an object or template first. You will be prompted for the fields naming the current object so you can name your new clone. Note that if you are cloning a template (a generic object), it will be named by a field "name".  If the object exists in both the configuration as you have currently loaded (and possibly altered) and the configuration of the running Nagios (taken from the objects.cache file), this will do a side-by-side diff of the two.  If the object exists in the configuration of the running Nagios (taken from the objects.cache file), this will show the full definition.
See also Export.
/> cd
0: command
1: contact
2: contactgroup
3: host
4: hostgroup
5: service
6: servicegroup
7: timeperiod
8: hostextinfo
Pick one: 3
/host> cd localhost
/host/localhost> dump
define host {
active_checks_enabled 1
address <IP_ADDRESS>
alias localhost
check_command check-host-alive
check_freshness 0
check_interval 5.000000
contact_groups admins
event_handler_enabled 1
failure_prediction_enabled 1
first_notification_delay 0.000000
flap_detection_enabled 1
flap_detection_options o,d,u
freshness_threshold 0
high_flap_threshold 0.000000
host_name localhost
icon_image base/debian.png
icon_image_alt Debian GNU/Linux
initial_state o
low_flap_threshold 0.000000
max_check_attempts 10
notes Debian GNU/Linux servers
notification_interval 0.000000
notification_options d,u,r
notification_period 24x7
notifications_enabled 1
obsess_over_host 1
passive_checks_enabled 1
process_perf_data 1
retain_nonstatus_information 1
retain_status_information 1
retry_interval 1.000000
stalking_options n
statusmap_image base/debian.gd2
vrml_image debian.png
}
/host/localhost>
You should enter this when having selected an object or template first. If the object exists in the currently loaded configuration, this will show the definition.
See also Dump.
/> cd host/localhost
/host/localhost> export
define host {
address <IP_ADDRESS>
alias localhost
host_name localhost
use generic-host
}
/host/localhost>
Just prints its arguments. Mostly makes sense in scripts.
/> ifcd /host/localhost
/host/localhost> echo it is there!
it is there!
/host/localhost> else
/host/localhost> echo No localhost found.
/host/localhost> fi
/host/localhost>
Part of the ifxxx [else] fi constructs.
/> ifcd /host/localhost
/host/localhost> echo it is there!
it is there!
/host/localhost> else
/host/localhost> echo No localhost found.
/host/localhost> fi
/host/localhost>
Part of the ifxxx [else] fi constructs.
/> ifcd /host/localhost
/host/localhost> echo it is there!
it is there!
/host/localhost> else
/host/localhost> echo No localhost found.
/host/localhost> fi
/host/localhost>
Does a search of the argument, listing partial matches as well.
/> find local
/host/localhost
/host/virtmachine: parents -> localhost
/hostgroup/debian-machines: members -> localhost
/hostgroup/http-servers: members -> localhost
/hostgroup/nagios-servers: members -> localhost
/hostgroup/ssh-servers: members -> localhost
/>
Prints the in-program help.
This does not need any external file, contrary to explain which needs the nagclicfg.md file available in the Nagios configuration directory.
The conditional version of add, can be followed by else and must be terminated by fi.
If the field is a multi-value field like hostgroups the value will be added if the value was not already in the set, returning true.
If a multi-value field already contained the value, ifadd will return false.
Note that ifadd and ifset behave identically for multi-value fields.
The conditional version of set, can be followed by else and must be terminated by fi.
If the field is a multi-value field like hostgroups the value will be added if the value was not already in the set, returning true.
If a multi-value field already contained the value, ifset will return false.
Note that ifadd and ifset behave identically for multi-value fields.
The conditional version of cd, can be followed by else and must be terminated by fi.
The conditional version of rm, can be followed by else and must be terminated by fi.
The conditional version of rmdir, can be followed by else and must be terminated by fi.
 More on this command later.
As you can cd quite deep down object referals, this command shows you the current absolute path.
/host/localhost> cd gen*
/host/localhost/generic-host> cd ch*
/host/localhost/generic-host/check-host-alive> pwd
/command/check-host-alive
/host/localhost/generic-host/check-host-alive>
Like pressing ^D, exits the program. Unsaved changes (see also write) will be silently discarded.
Like pressing ^D, exits the program. Unsaved changes (see also write) will be silently discarded.
Simple executes the configured reload command. Assumes you have sufficient privileges and that you wrote something to reload. See also write and check.
Removes a field from the current object or a value from a multi-value field. In the second case you must supply the value to remove, as in rm parents localhost to remove localhost from the list of parents.
/> cd host/localhost
/host/localhost> rm host_name
Sorry, cannot remove/clear a field naming an object.
/host/localhost> rm use
Removing 'use'
/host/localhost> ls
address alias host_name
/host/localhost> ls -l
address . <IP_ADDRESS>
alias . . localhost
host_name localhost
/host/localhost>
Removes the entire current object! This also recursively removes the object from anything that has a referral to it, possibly breaking those definitions.
/host/localhost> rmdir
Removed reference via 'members' from '/hostgroup/debian-machines'
Removed reference via 'members' from '/hostgroup/http-servers'
Removed reference via 'members' from '/hostgroup/nagios-servers'
Removed reference via 'members' from '/hostgroup/ssh-servers'
Removed reference via 'parents' from '/host/virtmachine'
/host>
Writes the current in-memory configuration out to files in the Nagios configuration directory, in a directory that should be private to this tool (nagclicfg.d). Note that this unlinks any configuration that was in place before, like from a package install, your current setup or another tool.
You will be warned before this happens!
However, this change should be fairly safe and restoring your old configuration should be simple. The old nagios.cfg file is also backed up so it should be a simple matter of replacing nagios.cfg as updated by this tool with that backup file.
There are however no guarantees! Make a backup or live on the edge, your choice :)
For use in deployment tasks, does the above write without asking confirmation.
A simple command that prompts for all the required fields for an object, as specified by the Nagios manual. Not recommended for complex objects but very handy for creating a hostgroup, for instance.
/hostgroup> define
Enter hostgroup_name: new-group
Enter alias: My new group
/hostgroup/new-group>
This incredibly dangerous-seeming command deletes all host, service, hostgroup and servicegroup objects. If you are using hostextinfo this will probably print warnings about those objects having missing references.
Obviously you should type quit immediately after this command unless you are doing a full idempotent reinstall of your Nagios environment, for which purpose this command is intended.
In normal use it would be in some kind of script and be followed by an import or replace command. Alternatively the script can have a list of clone or define commands to recreate the desired configuration.
The advantage of this approach is that you remove any old entries. It is also useful after an initial install by a package manager of the Nagios system to get rid of all the stock objects.


class Minion
def initialize (name, eyes)
@name = name
@eyes = eyes
end
end
kevin = Minion.new("Kevin", 2)
steve = Minion.new("Steve", 1)
One the first line, I named the new class Minion. Then I defined the initialize method. This method is very useful because it automatically runs everything inside it as soon as an instance of the class is created. The method takes two arguments, name and number of eyes. It then assigns each of those arguments to an instance varaible. You assign instance variables with the @ sign. These variables will be available for every subsequent method in its individual instance of the class Minion and only that instance. For example, the variable @eyes for kevin will not affect Steve ever, in any way. The two are completely separate. On the last two lines I made an instance of Minion named kevin and one of steve.


“Education is the most powerful weapon which you can use to change the world.”
-Nelson Mandela
"Power is gained by sharing knowledge, not hoarding it."
"An investment in knowledge pays the best interest."


RSA accumulators can efficiently store primes, but are (as far as I know) not efficient with non-prime numbers. My goal is to store arbitrary values, just like you can do in a Merkle tree, but having a shorter proof size. This can have multiple applications, such as in zk-sta...


_The_General's_Daughter_ (R) *** (out of ****)
It appears that the "in" thing for directors of popcorn fluff to do these days is tackle projects of greater weight--witness _Ace_Ventura_ helmer Tom Shadyac's _Patch_Adams_ and _While_You_Were_Sleeping_ director Jon Turtletaub's _Instinct_. Yet while those films proved--all too painfully--the limits of their respective directors' skills, _Con_Air_ director Simon West respectably stretches beyond slam-bang action theatrics with the largely absorbing mystery thriller _The_General's_Daughter_.
However, West is not completely immune to regressing to his commercial-bred bag of tricks. That's not necessarily a bad thing; in fact, West channels that energy into some effective sequences. The quick edits during a big fight scene between Army investigator Paul Brenner (John Travolta) and a weapons-trading baddie are initially distracting, but they do succeed in ratcheting up the tension level. The frenetic visual style works even more effectively in a harrowing rape scene, where the cuts keep the onscreen happenings from being overly graphic and exploitative, all the while still jangling the audience's nerves.
What does become problematic, though, is West's insistence on pleasing the audience in the broadest terms. The story, based on the best selling novel by Nelson DeMille, revolves the brutal murder of the title character, Army captain Elisabeth Campbell (Leslie Stefanson), an Army captain; brought in to solve the crime is Brenner and rape investigator Sarah Sunhill (Madeleine Stowe). It soon becomes clear that the two have stumbled onto something bigger, and must (as the tagline goes) "go behind the lies" to find the truth. Complex issues of honor, military code, and loyalty are brought up along the way, and they are all fairly intelligently handled--that is, until the underwhelming end. A big explosion at the climax serves no real purpose other than to inflate the budget and sate audiences hungry for pyrotechnics. The film rebounds with a thought-provoking coda, but instead of leaving audiences with something to chew on, West spoils the mood with an arbitrary (perhaps test screening-mandated?) closing text card that divulges the ultimate fate of one key character. As if not knowing when to quit, he ruins things further with rolling the end credits over a pointless shot of another character literally driving off into the sunset.
Nonetheless, these missteps do not fatally dilute _The_General's_Daughter_'s effectiveness. While Christopher Bertolini and William Goldman's script takes some interesting twists and turns, what keeps the film gripping are the actors.  Travolta is ideally cast as the alternately goofy and no-nonsense yet always on-target Brenner; Stowe, exuding her usual air of intelligence, works well off of him. James Woods is in his element as Elisabeth's shady and slimy mentor; just as intimidating, if not more, is Clarence Williams III as a colonel loyal to the general (James Cromwell, carving out a nice post-_Babe_ career as an all-purpose character actor).
Although it has more dramatic heft than a _Con_Air_, _The_General's_Daughter_ is a fairly comfortable step for West; in the end, it's still unmistakably a Hollywood entertainment, which kept his wrong turns from being ruinous ones. Nonetheless, it is an important step for him, one that shows that he has a grasp on substance as well as style--and, as such, making him a filmmaker to keep an eye on.
Michael Dequina
<EMAIL_ADDRESS>|<EMAIL_ADDRESS>Mr. Brown's Movie Site: http://welcome.to/mrbrown
CompuServe Hollywood Hotline: http://www.HollywoodHotline.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{% extends 'layout.html' %} {% block pageTitle %} Error: Some details do not match {% endblock %} {# {% block beforeContent %} {{ breadcrumb({ href: "/", text: "Home" }) }} {% endblock %} #} {% block content %}
You cannot respond to {{data.primaryUserFirstName or 'Alice'}} {{data.primaryUserLastName or 'Smith'}}’s invite. This is because some of the details they have told us do not match the details we hold about you. For example, {{data.primaryUserFirstName or 'Alice'}} may have spelt your name wrong.
Go to your NHS login account management area to check your details and make sure {{data.primaryUserFirstName or 'Alice'}} has the same information. Delete the email with the original invite and ask {{data.primaryUserFirstName or 'Alice'}} to send you a new invite with the right details.
Reference: CID9101


--- layout: post title: ! 'And the Lord said: http://www.flickr.com/photos/verdammelt/3790935592/in/set-72157621948941882/' published: true date: 2009-08-04 categories: [] posterous_url: http://verdammelt.posterous.com/and-the-lord-said-httpwwwflickrcomphotosverda posterous_slug: and-the-lord-said-httpwwwflickrcomphotosverda --- The Lord looking down on Boston. I heard the chorus of angels singing:
Love that dirty water....


Updated 1829 GMT (0129) HKT April 20, 2019
President Trump states that China is ripping the Americans off; he also demanded the president of Mexico again to pay for the wall.
In an early-morning Twitter post, President Trump insisted on Thursday that he has been unwavering in his stance for building a border wall between Mexico and the United States to thwart illegal immigration. He was responding to — and directly contradicting — private statements by John F. Kelly, his chief of staff, who told the Congressional Hispanic Caucus on Wednesday that Mr. Trump had not been “fully informed” when he first promised the wall, and that the president’s position on building it had “evolved” over time. “The Wall is the Wall, it has never changed or evolved from the first day I conceived of it,” Mr. Trump wrote on Twitter at 6:15 a.m. Thursday. But a review of Mr. Trump’s public statements on Twitter, in campaign speeches and during interviews shows that the president’s views on the border wall have shifted repeatedly since he raised the idea nearly four years ago, on Aug. 5, 2014.
What Jared doing in the Saudy Arabia?
What would be the estimated cost of the border wall between US and Mexico?
Latest news about Trump's impeachment
What happend in the interview held in the White House?


This chapter describes the syntax and semantics of the Prolog language, and introduces the central built-in predicates and other important language constructs. In many cases, an entry in a list of built-in predicates, will be annotated with keywords. These annotations are defined in mpg-ref-cat.


{% extends "base.html" %} {% block content %}
The Limb Darkening Calculator calculates limb-darkening coefficients for a specified stellar model, plotting results versus intensity ratio and wavelength. It uses high spectral resolution stellar atmospheric models, which are a neccesisty given JWST's expected precision.


|
phylopomp
Phylodynamics for POMPs
|
Go to the source code of this file.
Functions | |
| SEXP | curtail (SEXP State, SEXP Time) |
| curtail the given genealogy More... | |
| SEXP | yaml (SEXP State) |
| extract a YAML description More... | |
| SEXP curtail | ( | SEXP | State, |
| SEXP | Time | ||
| ) |
| SEXP yaml | ( | SEXP | State | ) |
extract a YAML description
Definition at line 21 of file bare.cc.


== Report Structure ==
The report is broken down into two (2) major sections in order to communicate the objectives, methods, and results of the testing conducted to various audiences.


All SVG graphics need to be contained inside of a set of SVG tags:

<svg></svg>

Shape properties are set as attributes of the element.

<svg>
<rect x="50px" y="100px" width="150px" height="100px" fill="red" />
</svg>

Some text
Some text
Some text
CSS for a specific tag can be defined in the  of a document, and it will effect every element of that type on the page.

<meta charset="utf-8" />
<title>My cool test page</title>

Hello!

Goodbye!

The ID attribute can be set on an element so that you can specifically select it in CSS:
Some text

The "p" before the pound sign is optional.
Element IDs should only be used on single elements. If you have multiple elements that need the same style applied to them, use the "class" attribute:
Some text
Some text

The "p" before the decimal sign is also optional.
In the place of


| Goal |
KPI |
Target Completion |
Weighting |
Year-end Comments |
Manager Comments |
Score |
|
{{performanceGoal.goal}}
|
{{performanceGoal.kpi}}
|
{{performanceGoal.targetCompletion}}
|
{{performanceGoal.weighting}}
|
{{performanceGoal.yearEndComments ? performanceGoal.yearEndComments : 'N/A'}}
|
{{performanceGoal.yearEndManagerComments ? performanceGoal.yearEndManagerComments : 'N/A'}}
|
{{performanceGoal.score}} {{ performanceGoal.score ? getRatingText(performanceGoal.score) :'' }}
|
|
{{c.CompetenyName}}
Overall Rating :
{{c.CompetencyAvgRating||0}}
|
| Competency |
Rating |
Comments |
|
{{question.label}}
|
{{finalRating.Manager.IsSubmitted ? question.value : ''}} {{
finalRating.Manager.IsSubmitted ? getRatingText(question.value) :''
}}
|
{{finalRating.Manager.IsSubmitted ? c.comments : ''}}
|
|
0"
class="list-group">
-
{{peer.FirstName}} {{peer.LastName}}
-
Direct Report Review List
0"
class="list-group">
-
{{dr.FirstName}} {{dr.LastName}}
|
Development Goal :
{{goal.DevGoal}}
|
|
Performance Goal :
{{goal.Kpi}}
|
|
Desired Outcomes :
{{goal.DesiredOutcomes}}
|
| Action Step |
Progress Indicators |
Barriers |
Target Date |
Other Participants |
Status |
|
{{goalActionItem.ActionStep}}
|
{{goalActionItem.ProgressIndicators}}
|
{{goalActionItem.Barriers}}
|
{{goalActionItem.TargetDate}}
|
{{goalActionItem.OtherParticipants}}
|
{{goalActionItem.Status}}
|
|
| Strength |
Leverage |
Benefit(Self) |
Benefit(Team) |
Progress Comments |
|
{{strength.Strength}}
|
{{strength.Leverage}}
|
{{strength.SelfBenifit}}
|
{{strength.TeamBenifit}}
|
{{strength.ProgressComments}}
|
| Sign-off text |
|
My signature below represents my continued commitment to adhere to the ___________Code of Conduct
|
| APPENDIX |
|
|
A critical leadership responsibility is to evaluate and coach employee performance. The
performance evaluation is a key component of employee development and demonstrates our Vision
and Values in action.
|
In completing the evaluation, please observe the following principles:
|
Using the rating scale indicated, select the rating for each element that best reflects the
Employee’s
performance or skill level against established standards. Supporting comments are key
elements of the evaluation.
|


Hello world! This is your HTML5 entry point for your progressive web application.
Real-time text sync
Database text sync
Save


XML Tools API overview.
Status
Under development.
See also API changes document.
Purpose
XML tools API simplifies writing inter-operable modules handling user's XML
resources. It also improves consistency of user experience as it introduces
minimum standard behavior support for all XML domains.
Supported Use Cases
Actions
XML is general document format that allows to define document structure
and semantics. It influences behavior of common user's actions. Particular
behavior of such action depends on specifics of defined semantics. This
can be modeled in OpenIDE APIs using cookies. XML tools API defines set of
common cookies {@link org.netbeans.api.xml.cookies} and support for their providers
{@link org.netbeans.spi.xml.cookies}.
A user can take a cookie action from the action pool and put it on a data
object serving particular cookie. The action is performed via served cookie
that is aware of actual behavioural enhancement for given data object.
User's XML Document Parsing
All standard XML processors APIs define call-back interfaces that must be provided
by clients. Further evaluation identifies one type of application wide
call-back interface - entity resolution (e.g. in SAX called
{@link org.xml.sax.EntityResolver}). XML tools API introduces notion of context
user's entity catalog service {@link org.netbeans.api.xml.services.UserCatalog}
back-ended by plugged in providers.
A user has all their entity registrations at one place for given context and
these are shared by all processors handling user's documents in the context.
Unification&Integration
Standard XML APIs (DOM, TrAX, SAX, OpenIDE) define a API for the same purpose
several times to avoid dependencies.
{@link org.netbeans.api.xml.parsers} provides classes bridging between them.
It also contains utility classes such as DTD parser.
Model
Looking for model and 2-way editing support? We are looking for ideas
how to define it!


Proudly bred from two Champion Staghorn dogs , Gretel is a dream. We love her silly and yet gentle sense of humour and her dense, double coat. After a slow to mature start (often the best kind) she's coming nicely into her own now and will be making her debut in the show ring this year. A wonderful girl, she's very easy to live with and keeps us smiling. We expect great things with this fun gal. With her parents excellent clearances, looks and brains, we have nothing but the highest of hopes for our girlie.


Implementing a new service¶
To demonstrate implementing a new service, this guide details implementing a new logging service. In most applications, it may be more desirable to utilise a persistent storage medium as opposed to an in-memory one. This tutorial details implementing a simple service that will achieve this functionality.
Services in UNDERSEA implement the AgentService
interface and in turn, this interface extends from AgentAware
. While creating a new service, the initialisation process may require a reference to the associated agent instance, however, this has not been fully constructed yet. The AgentAware
interface solves this by moving initialisation process of a service to the initialise
method that must be implemented and this provides a reference to the agent.
Lets start by creating a new DiskLogService
that contains a BufferedWriter
public class DiskLogService implements LogService {
private Agent agent;
private BufferedWriter writer;
@Override
public void initialise(Agent parentAgent) {
this.agent = parentAgent;
try {
this.writer = new BufferedWriter(new FileWriter("log-" + agent.name() + ".txt", true));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
...
The initialise
method is called by the ServiceManager
during starting a service before calling the run
method on the service. This ensures that every service is fully initialise beforehand.
Now we can implement the (very simple) add
method so log entries are written:
@Override
public void add(LogEntry logEntry) {
try {
writer.write(logEntry.toString());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
The add
method can be invoked directly on the instance of the DiskLogService
or, normally, by acting directly on the instance of an agent through agent.log(logEntry)
. To register the new logging service with the ServiceManager
:
serviceManager.registerService(new DiskLogService());


API documentation
<--- Select one of the example operations to begin
obtain Project ID<PHONE_NUMBER> or my-project-name) from the Google Cloud Storage Console
obtain activity ID from activities listing
Required Inputs
obtain activity ID from activities listing


https://docs.scipy.org/doc/scipy/tutorial/integrate.html
https://en.wikipedia.org/wiki/Numerical_integration
https://en.wikipedia.org/wiki/Trapezoidal_rule
https://en.wikipedia.org/wiki/Simpson%27s_rule
The 'scipy.integrate' sub-package provides several integration techniques including an ordinary differential equation integrator.
import numpy as np import scipy.integrate as integrate # help(integrate) # The function quad() is provided to integrate a function of one variable # between two points. # \integ_x1^x2 dx f(x) - a definite integral # integrate.quad(f, x1, x2) # The first argument to quad is a callable Python object. # x1 and x2 are the limits of integration. # Infinite inputs are also allowed in quad by using 'np.inf'. f = lambda x: np.exp(-x) result = integrate.quad(f, 0, 1) # (0.6321205588285578, 7.017947987503856e-15) # 0.632_120_558_828_5578(70) # exact = (np.e - 1) / np.e = 0.632_120_558_828_5577(1) # np.e = 2.718_281_828_459_045 # 16 digits
from scipy.special import jv # Bessel function of the first kind f = lambda x: jv(0, x) result = integrate.quad(f, 0, 5) # (0.7153119177847678, 2.47260738289741e-14) # 0.715_311_917_784_768(25)
# Double integration with the dblquad() function. # \integ_y1^y2 dy \integ_x1(y)^x2(y) dx f(x,y) # integrate.dblquad(f, y1, y2, x1, x2) # Note that x1=g(y) an x2=h(y) can be functions of y. # y2 (0,1)+---+(1,1) # | | # y1 (0,0)+---+(1,0) # x1 x2 f = lambda x, y: np.exp(-x**2 -y**2) y1, y2 = 0, 1 x1 = lambda y: 0 x2 = lambda y: 1 area = integrate.dblquad(f, y1, y2, x1, x2) # (0.5577462853510337, 8.291374381535408e-15) # 0.557_746_285_351_0337(83)
# f(x,y) = x*y, the area is a triangle with boundaries: # x = 0, y = 0, x + 2*y = 1, # vertices are (0, 0), (1, 0), (0, 0.5). # (0,0.5)+ # | \ # | \ # (0,0)+---+(1,0) f = lambda x, y: x*y y1, y2 = 0, 0.5 x1 = lambda y: 0 x2 = lambda y: 1-2*y # x = 1 - 2*y area = integrate.dblquad(f, y1, y2, x1, x2) # (0.010416666666666668, 4.101620128472366e-16) # 0.010_416_666_666_666_67(41) # exact = 1. / 96. = 0.010_416_666_666_666_666(1)
# Triple integration with the tplquad() function. # For n-fold integration, scipy provides the function nquad. # integrate.nquad(f, iterable_with_bounds) def bounds_y(): return [0, 0.5] def bounds_x(y): return [0, 1-2*y] area3 = integrate.nquad(lambda x, y: x*y, [bounds_x, bounds_y])
The purpose of the numerical integration is to calculate the numerical value of a definite integral to a given degree of accuracy. The integrand is evaluated at a finite set of points called 'integration points' and a weighted sum of these values is used to approximate the integral.
I = \integ_x1^x2 dx f(x) The midpoint rule or rectangle rule (constant function approximation) I = (x2-x1) f((x1+x2) / 2) The trapezoidal rule (linear function approximation) I = (x2-x1) [f(x1) + f(x2)] / 2 Simpson's 1/3 rule (quadratic function approximation) I = [(x2-x1) / 6] [f(x1) + 4 f((x1+x2) / 2) + f(x2)]
# Integrating functions using fixed samples. # trapz - Newton-Coates formulas (straight lines between adjacent points) # simps - Simpson’s rule (parabolas between three adjacent points) # romb - Romberg integration (2**k+1 points are required) # \integ_x1^x2 dx f(x) # \integ_0^2 dx sqrt(x) f = lambda x: np.sqrt(x) x1, x2 = 0, 2 x = np.linspace(x1, x2, 2**5+1) y = f(x) res_trapz = integrate.trapz(y, x) res_simps = integrate.simps(y, x) # recommended res_romb = integrate.romb(y, dx=x[1]-x[0]) # 2**k+1 points are required res_exact = (2.0/3.0) * (x2-x1)**(3.0/2.0) # for 2**5+1=33 points # res_trapz 1.882_484_948_488_58 # res_simps 1.884_349_579_078_4088 # res_romb 1.884_546_200_832_0417 # res_exact 1.885_618_083_164_1267 # for 2**6+1=65 points # res_trapz 1.884_498_435_329_6215 # res_simps 1.885_169_597_609_9685 # res_romb 1.885_239_284_741_2136 # res_exact 1.885_618_083_164_1267


Verbal communication allows individuals to directly express themselves to the wider community. Unfortunately, people with hearing and speaking difficulties tend to remain constrained due to the constant need of visual aids or an interpreter to translate the meaning of their hand gestures. Kross-Konnection has been designed to bridge this communication gap and empower the vulnerable individuals to voice themselves without restrictions. This project presents a translator which converts the Australian Sign Language into literal English alphabets.
Become a pro at communicating with AUSLAN. Our signbank offers complete illustrations of all English alphabets along with interactive activities to sharpen your finger spelling skills.
_____________________________________________________________________________________________________________________________________________________
"Wow, never knew learning AUSLAN could be so fun! kudos to K-K!
"I always wanted to learn AUSLAN but just couldn't find the right resource until a friend suggested to use Kross-Konnection. It's definitely worth the time!"
"So excited to say that I can finally understand AUSLAN! Thank You KROSS-KONNECTION!!"
"Perfection in one platform. All the love for Kross-Konnection!"
"The translation offered by Kross-Konnection is fantastic. Very Accurate. Would highly recommend all to use this platform!"


Watch: Kamala Harris Mistakenly Says ‘Fags’ in Post-Debate Interview
Harris suffered a verbal slip-up.
by BreitbartSen. Kamala Harris (D-CA) suffered a verbal slip-up, referring to “flags” as “fags” before quickly correcting herself in a live interview following Wednesday’s Democrat presidential debate in Atlanta, Georgia.
“This guy just you know again, goes for the photo-op, you remember all of these fags — flags — that looked almost fake” Harris told MSNBC’s Chris Matthews, referring to President Trump’s meetings with North Korean dictator Kim Jong Un in Singapore and Hanoi Summit, Vietnam.
Earlier Wednesday evening, Harris argued during the debate that President Trump had gotten “punked” on foreign policy regarding his administration’s denuclearization negotiations with North Korea.
When asked whether she would have held a summit with Kim, Harris replied: “With all due deference to the fact this is a presidential debate, Donald Trump got punked.”
“He has conducted foreign policy since day one borne out of a very fragile ego,” she continued. “That fails to understand that one of the most important responsibilities of the commander-in-chief is to concern herself with the security of our nation and homeland. And to do it in a way that understands that part of the strength of who we are as a nation, and therefore an extension of our ability to be secure is not only that we have a vibrant military, but that when we walk in any room around the globe, we are respected because we keep to our word, we are consistent, we speak truth, and we are loyal.”
Alex Jones Confronts Leftist Demons & Trump In Austin
During President Trump’s visit to Austin, Texas, Alex Jones shows up to confront him and is met by leftist demons against free speech.
By the way, overhaul your body’s cellular engine with our fan-favorite DNA Force Plus!


It uses utility classes for typography and spacing to space content out within the larger container.
Learn more


Change Camera Roll Status
Note:
Click the button above to propagate all Camera Roll values on the right hand side to the fake PhoneHub manager. Values will update when changed outside of this page.
Camera Roll Enabled
Onboarding Dismissed
File Access Granted
Loading View Shown
Number of Thumbnails
File Type
[[getFileTypeName_(item)]]
Download Result
[[getDownloadResultName_(item)]]


Tabs Custom Element Wizard Example.
Personal info
Shopping basket
Review order
Username:
Password:
I accept the terms and conditions
Next
Back
Next
Selected products
Back


Notebooks
Story: The digging out of 'Bushman rice'
The digging out of 'Bushman rice'
Title
The digging out of 'Bushman rice'
Collection
Summary
Bushman rice' may be dug by both men and women. (L VIII.-10. 6888 rev., note). Others look for gambro and catch korhaan and hares when there are no springbok to hunt.
Comments
1) This story is found in Book VIII-10
Contributors
|han≠kass'o (Klein Jantje) (VIII)
Date
May 1878
Categories
Custom and daily life, Plants and animals
Keywords
Bushman rice (ant larvae) , Bushman rice (the digging out of) , Bushman rice (methods of digging for) , Bushman rice ('women's hunting') , Bushman rice (dug by men and women) , Bushman rice (when it is dug out) , Bushman rice (is eaten as food) , food (found and eaten by men and women) , food (the digging out of 'Bushman rice') , food (the eating of gambro) , food (the eating of korhaan) , food (the eating of hares) , food (finding and hunting for) , food (what is eaten when there are no springbok) , ant larvae ('Bushman rice') , ant larvae (the digging out of) , springbok (what is eaten when there are none) , springbok (and the digging out of 'Bushman rice') , korhaan (eaten when there are no springbok) , korhaan (and the digging out of 'Bushman rice') , hare (eaten when there are no springbok) , hare (and the digging out of 'Bushman rice') , gambro (eaten when there are no springbok) , gambro (and the digging out of 'Bushman rice') , hunting (women's) , hunting (of hares and korhaan) , hunting (and the digging out of 'Bushman rice') , names (of foods eaten by the |xam when there are no springbok) , names (and the digging out of 'Bushman rice') , women (hunting by) , women (and the digging out of 'Bushman rice') , digging (out of 'Bushman rice')
Story Pages
6888v


| Blast 5 | 01 October 17 | 5 | miles | |
| Name | Position | Road bike | Actual Time | Avg. mph |
| Matt Plews | 1 | 00:10:54 | 27.52 | |
| Jonathan Durnin | 2 | 00:11:01 | 27.23 | |
| Peter Bentley | 3 | 00:11:15 | 26.67 | |
| James Lowe | 4 | 00:11:20 | 26.47 | |
| Lawrence Cox | 5 | 00:11:23 | 26.35 | |
| Matt Crabtree | 6 | 00:11:29 | 26.12 | |
| Linda Hubbard | 7 | 00:12:30 | 24.00 | |
| Steven Welch | 8 | 1 | 00:12:31 | 23.97 |
| David Sweetman | 9 | 00:12:48 | 23.44 | |
| Richard Vallance | 10 | 2 | 00:12:50 | 23.38 |
| Steve King | 11 | 00:13:08 | 22.84 | |
| Stewart Holland | 12 | 3 | 00:13:41 | 21.92 |
| Simon Ward | DNF |


We are experts in the adoption of technology and have developed methodologies to make this process faster with more deterministic outcomes.
Suitable for a team that is already using programming languages such as Python or R that need a more formalised development process.
A development team that is ready to take full control of their deployments and application lifecycle.
Suitable for a team that is already using programming languages such as Python or R that need a more formalised development process.
A development or Analytics team that wants to start using AWS for storage and processing of data.
A team that is already using programming languages such as Python or R that need to have a more formalised development process.
A team that is already using programming languages such as Python or R that need to have a more formalised development process.
A team that is already using programming languages such as Python or R that need to have a more formalised development process.
A team of people using Microsoft Excel or other similar tools. There is a lot of manual work with an ever increasing error rate. Some of my team have expressed an interest in learning to code.


Just add new files to archive?
When this is set to No (as it is by default), the backup destination
will be replaced with an archive of all files currently in the source directories. But if you select Yes, only files that have been changed since the
archive was create will be appended to it. This is useful when making incremental backups. However, it cannot be used with compressed or remote archives.


A visible paragraph
Note: much of this page is hidden, in one way or another
A paragraph hidden using CSS visibility=hidden
A paragraph suppressed using CSS display=none
A sub-element hidden using CSS visibility=hidden
A sub-element that is explicitly visible using CSS visibility=visible
A sub-element suppressed using CSS display=none
A paragraph hidden using CSS visibility=hidden, applied by JavaScript
A paragraph suppressed via CSS class
A paragraph suppressed via CSS class, applied by JavaScript


Here you can find the information needed in order to reach your local, state, and federal government officials!
Military veteran and Dewey Beach homeowner for the last 20 years, these are two small items on Mayor Cooke's long list of accomplishments. Mayor Cooke is also a member of many other Dewey Beach committees and the leader of many other groups. His wide range of experience qualifies him for role of mayor well.
Send a Letter or Stop In:
105 Rodney Ave.
Beach, DE 19971
Commissioner Dunmeyer is currently the owner of two growing small businesses that serve Sussex County and the surrounding area. Prior to that, Mike was the Executive Director for Ocean Champions, the country's only ocean-focused political organization. Mike brings a diverse background to the role of Commissioner.
Send a Letter or Stop In:
105 Rodney Ave.
Beach, DE 19971
John Charles Carney Jr. (born May 20, 1956) is the 74th and current Governor of Delaware since January 2017. A member of the Democratic Party, he served as the U.S. Representative for Delaware's at-large congressional district from 2011 to 2017 prior to his governorship. Carney was also the 24th Lieutenant Governor of Delaware from 2001 to 2009 and served as Delaware's Secretary of Finance. He first unsuccessfully sought the Democratic nomination for Governor of Delaware in 2008, losing to Jack Markell. He ran for Governor of Delaware again in 2016 and won to succeed Markell, who was term-limited.
Contact By Mail
Carvel State Office Building
820 N. French Street
12th Floor
Wilmington, DE 19801
Alternate Mailing Address
Tatnall Building
150 Martin Luther King Jr Blvd South
Dover, DE 19901
Contact By Phone
Dover Office:<PHONE_NUMBER>
Wilmington Office:<PHONE_NUMBER>
Washington D.C. Office:<PHONE_NUMBER>
Thomas Richard "Tom" Carper (born January 23, 1947) is the senior United States Senator from Delaware, serving since 2001. A member of the Democratic Party, Carper served in the United States House of Representatives from 1983 to 1993 and was the 71st Governor of Delaware from 1993 to 2001.
Contact By Mail
301 North Walnut Street
Suite 102L-1
Wilmington, DE 19801-3974
Alternate Mailing Address
United States Senate
513 Hart Senate Office Building
Washington, DC 20510
Contact By Phone
Washington D.C. Office:<PHONE_NUMBER>
Wilmington Office:<PHONE_NUMBER>
Christopher Andrew "Chris" Coons (born September 9, 1963) is the junior United States Senator from Delaware and a member of the Democratic Party. He won a special election in 2010 to succeed Ted Kaufman, who had been appointed to the seat when Joe Biden resigned to become Vice President. Previously, Coons was the county executive of New Castle County. Coons is the 1983 Truman Scholar from Delaware, and the first recipient of the award to serve in the United States Senate.
Contact By Mail
301 North Walnut Street
Suite 102L-1
Alternate Mailing Address
United States Senate
513 Hart Senate Office Building
Washington, DC 20510
Contact By Phone
Washington D.C. Office:<PHONE_NUMBER>
Wilmington Office:<PHONE_NUMBER>
Lisa Blunt Rochester (born February 10, 1962) is an American politician from the state of Delaware. A member of the Democratic Party, she is a member of the United States House of Representatives, representing Delaware's at-large congressional district. Blunt Rochester was born in Philadelphia, Pennsylvania on February 10, 1962.[1] Her family moved to Wilmington, Delaware, in 1969.[2] Her father, Ted Blunt, served on the Wilmington City Council, including as council president.
Contact By Mail
Wilmington Office
1105 N Market St, Ste. 400
Wilmington, DE 19801
Alternate Mailing Address
Washington D.C. Office
1123 Longworth House Office Building
Washington, DC 20515
Contact By Phone
Washington D.C. Office:<PHONE_NUMBER>
Wilmington Office:<PHONE_NUMBER>


| What |
- Comma-separated data table as input.
- Contains categorical data (e.g. type of whisky) as well as nominal (e.g. age) and ordinal (e.g. rating) numerical data.
- Source of data is self-collection.
|
| Why |
- To better understand the releationship (or lack thereof) between the amount of time a whisky is aged and how much I enjoy it drinking it.
|
| How |
- The location of the marks represents Age (x-axis) and Rating (y-axis).
-
The data points are color-coded by according to the type of whisky that comprises the plurality of that point as follows:
- Yellow: Scotch
- Red: Bourbon
- Purple: Rye
- Green: Irish
- Blue: Japanese
- The luminance of the points are determined by the number of records occupying that point on the x-y plane. The darker (blacker) a point, the more whiskies meet those coordinates and the whiter, the fewer.
|
| Insight: Relationship |
There does not seem to be any strong correlation between age and perceived quality. Except that there seems to be a floor where that no age-stated whiskies fall below. |
| Insight: Style as it Relates to Age |
For the most part, Scotch occupies the older (farther right) part of the graph more heavily than the others, which tend to occupy the younger space (with a few exceptions). |
| Insight: Style as it Relates to Quality |
Scotches also tend to dominate the higher (higher-rated) portion of the graph, across all age ranges. Bourbons reach up the next most frequently, ryes and Irish whiskies are fairly evenly distributed, while Japanese whiskies seem to be more narrowly limited and do not reach as high. |


Delicious
THE BEST FOOD BLOG ON THE WEB.
Chocolate Pizza
POSTED ON 15 DEC 2013 / DESSERTS
Print
11/2 cups milk
1/2 cup mascarpone
1/2 tsp pink salt
1 lb Black Mission Figs
1/2 cup brown sugar
2-4 tbsp water
11/2 cups heavy cream
1/3 granulated sugar
2 egg yolks
1 lemon, juiced
2 tbsp butter
1 cup honey roasted pecans, roughly chopped


User Persona's/User Stories Interaction Flow Landing Page
Casual User 1
New User
Power User
Admin User
Conceptual Model


--- title: rOpenSci Fellowship Application res_class: R concept: Application for rOpenSci's Fellowship program to construct a workflow management system. layout: page-no-titles section: R Coding ---
Simon Goring – University of Wisconsin – Madison
Complexity is a significant hurdle to user adoption of new tools and workflows (Kim and Crowston, 2011). Complexity also leads to heterogeneity in data processing and archiving practices (workflows), as best practices are often culturally transmitted. In the “long tail” of science, data (which includes scientific workflows) tend to be collected and generated for project-specific purposes, with greater emphasis on sharing within research groups than with the public (Wallis et al., 2013). Heterogeneity can then limit our ability to undertake synthesis work, and complicates the transmission of knowledge, particularly when disciplinary communities are small and highly distributed, as in the paleogeosciences. Open publication of results and data may be insufficient for limiting these challenges given the complexity of many modern workflows, thus a disparity will continue to exist between the standards for publication, with extensive peer review, and the standards for data archiving (Lee and Bietz, 2009).
To solve the challenge of best-practices heterogeneity around new tools & techniques, I propose a system, rNoteBase, to archive and expose workflows generated using Rmarkdown (focusing on API-based tools supported by rOpenSci). Documents linked to rNoteBase can be annotated, tagged with keywords, and edited through existing version control platforms (e.g. GitHub). rNoteBase will not host the documents directly, rather linking to the documents from a code repository, this helps balance centralizing tendencies of technology with the distributed nature of modern scientific collaboration (Lynch, 2008).
The rNoteBase will assist researchers move toward greater transparency by facilitating reproducibility and increasing the competency of researchers for core technical skills. One barrier for code sharing is the sense that code or data is too messy (Barnes, 2010). By providing researchers with tools, written with scientific and technical best practices in the forefront, we encourage reproducibility. By basing initial generation of this system around the API-focused rOpenSci packages we hope to foster partnerships between data creators, data repositories, and data users.
This project was originally a component of the NSF funded Throughout proposal but was removed due to funding constraints. It is my belief that the rOpenSci fellowship would provide the opportunity to build a working prototype of this platform in connection with work underway in the Throughput proposal that is designed to link resources across the geoscientific web, as part of the EarthCube program (http://earthcube.org).
rNoteBase will ensure (1) that workflows undergo a vetting process; (2) that end-users are assured that web-centric methods are reliable; (3) that workflows contained within the notebase are discoverable, and (4) that credit can be provided to rNoteBase contributors. To accomplish this, the rNoteBase proposal consists of four elements:
A Peer Review System for API-centered scientific workflows that leverages the existing rOpenSci peer-review system (e.g., https://github.com/ropensci/onboarding), but remains separate and domain-specific to avoid overburdening the existing system.
A Continuous Integration System to check notebooks regularly (cf., CI with Rmarkdown), to provide failure notification to notebook developers and, if requested, API maintainers.
A User Interface, leveraging RMarkdown YAML headers to help sort and manage notebooks, providing search capacities and allowing discovery by keyword, discipline, R package, or author. The intention is to construct a system using an API-first philosophy, with vue.js to support the UI development. This rNoteBase would be able to support its own rOpenSci package.
A DOI Management System to be supported initially through the University of Wisconsin’s Library System and its contract with DataCite along with data citations for the workflow products to support recognition.
Figure 1: Visual representation of the elements within the rNoteBase ecosystem. Individual elements are described further in the proposal.
The implementation plan for rNoteBase differs from the more common development of end-user tools in that it will provide descriptive, citable workflow resources for researchers engaged in domain research. This ensures that notebook authors recieve academic credit through citations, and that users receive support by having peer-reviewed general workflows to use as a type of “cookbook”.
Workflows developed with the Neotoma Paleoecological Database (http://neotomadb.org) include questions critical to the paleogeosciences broadly, such as chronology construction using Bayesian tools (e.g., based on http://bit.ly/2mkAVCd), age-uncertain analysis of paleogeoscientific data (using GeoChronR tools; McKay), sediment core alignment using affine and splice, geospatial-temporal mapping of lake water chemistry, or sediment geochemistry from EarthChem, pollen-based climate reconstruction (e.g., http://bit.ly/2m1clUx), vegetation reconstruction using pollen, cluster analysis of tephra events, or sample mapping and correlation of paleo-proxies. We will use these as the initial basis for document links, metadata harvesting and annotation. As the platform approaches maturity we wil solicit additional workflows through social media channels and relationships with partners in the EarthCube program as part of the EarthCube Engagement Committee’s work. We will also work to harvest information from existing package vignettes that perform discipline-related tasks.
This proposal would result in several deliverable products. All code for the prototype would be available on GitHub under an MIT License. Content would be dynamically linked, and as such, the rNoteBase would not host markdown documents itself.
Standards for data objects defined from DublinCore, WC3, schema.org and other ontologies
Data model for DOI atomic units & data citation elements
Prototype neo4j graph database linking RMarkdown documents to user profiles (e.g., ORCiD), peer reviewers, API resources and R package information
API developed using vue.js to query the graph database and return content based on rNoteBase workflow attributes (e.g., keywords, packages used, data types accessed, authors)
Peer review process outlined, discussions with potential partner organizations (Ubiquity Press, Earth Science Information Partners – currently engaged in development of an earth science preprint service)
A web application developed using vue.js
Simon Goring (http://goring.org) is an Assistant Scientist at the University of Wisconsin-Madison, with PI status. He is the lead author of the neotoma R package and the IT lead for the Neotoma Paleoecological Database, as well as a member of the Leadership Council for the NSF’s EarthCube Program.
We aim to leverage resources from the NSF Throughput grant to help undertake a workshop at the University of Wisconsin in the summer of 2018 that would focus on workflow development for the paleogeosciences. This would provide further support to the rNoteBase proposal by adding content and acting as an opportunity to beta-test the platform.
Barnes, N. (2010). Publish your computer code: it is good enough. Nature, 467: 753. doi:10.1038/467753a
Kim, Y., & Crowston, K. (2011). Technology adoption and use theory review for studying scientists' continued use of cyber‐infrastructure. Proceedings of the Association for Information Science and Technology, 48:1-10. doi:10.1002/meet.2011.14504801197
Lee, C. P., & Bietz, M. (2009). Barriers to the adoption of new collaboration technologies for scientists. In: ACM Conference on Computer-Human Interaction (CHI). [link]
Lynch, C. (2008). The institutional challenges of cyberinfrastructure and e-research. Educause Review, 43: 74-88. [link]
Wallis, J. C., Rolando, E., & Borgman, C. L. (2013). If we share data, will anyone use them? Data sharing and reuse in the long tail of science and technology. PloS one, 8(7), e67332. doi:10.1371/journal.pone.0067332