Aegisub / Fonts Collector
The fonts collector is an automated tool that finds all fonts used in the current script, scans your system's fonts folder(s) and copies all the relevant fonts to a destination of your choosing. The dialog box looks like so:
The collector can perform any of the following actions:
- Check fonts for availability - Checks the fonts folder(s) to see if you have all the fonts used in the current script, and that all fonts contain all of the required glyphs. Do note that for technical reasons, the collector can't detect or collect fonts that aren't actually installed (like for example fonts temporarily loaded by a Matroska splitter or a font viewing program).
- Copy fonts to folder - Copies all the fonts used on the current script to the given folder.
- Copy fonts to subtitle file's folder - Copies all the fonts used on the current script to the folder containing the subtitle file. This is equivalent to using the above option with the destination set to ?script.
- Copy fonts to zipped archive - Copies all the fonts used on the current script to a compressed .ZIP archive.
The fonts collector will output diagnostic information about its doings in the lower half of the window.


curs_termattrs 3x
NAME
baudrate, erasechar, has_ic, has_il, killchar, longname,
termattrs, termname - curses environment query routines
SYNOPSIS
#include <curses.h>
int baudrate(void);
char erasechar(void);
bool has_ic(void);
bool has_il(void);
char killchar(void);
char *longname(void);
attr_t termattrs(void);
char *termname(void);
DESCRIPTION
The baudrate routine returns the output speed of the ter-
minal. The number returned is in bits per second, for
example 9600, and is an integer.
The erasechar routine returns the user's current erase
character.
The has_ic routine is true if the terminal has insert- and
delete- character capabilities.
The has_il routine is true if the terminal has insert- and
delete-line capabilities, or can simulate them using
scrolling regions. This might be used to determine if it
would be appropriate to turn on physical scrolling using
scrollok.

The longname routine returns a pointer to a static area
containing a verbose description of the current terminal.
The maximum length of a verbose description is 128 charac-
ters. It is defined only after the call to initscr or
newterm. The area is overwritten by each call to newterm
and is not restored by set_term, so the value should be
saved between calls to newterm if longname is going to be
used with multiple terminals.
If a given terminal doesn't support a video attribute that
an application program is trying to use, curses may sub-
stitute a different video attribute for it. The termattrs
function returns a logical OR of all video attributes sup-
ported by the terminal. This information is useful when a
curses program needs complete control over the appearance
of the screen.
The termname routine returns the value of the
environmental variable TERM (truncated to 14 characters).
RETURN VALUE
longname and termname return NULL on error.
Routines that return an integer return ERR upon failure
and OK (SVr4 only specifies "an integer value other than
ERR") upon successful completion.
NOTES
Note that termattrs may be a macro.
PORTABILITY
The XSI Curses standard, Issue 4 describes these func-
tions. It changes the return type of termattrs to the new
type attr_t.
SEE ALSO
curses(3x), curs_initscr(3x), curs_outopts(3x)
Man(1) output converted with
man2html


The programs that we explored in Chapters 1 and 2 did little more than read a single string and write it again, sometimes with decoration. Most problems are more complicated than such simple programs can solve. Among the most common sources of complexity in programs is the need to handle multiple pieces of similar data.
Our programs have already started doing so, in the sense that a string
comprises
multiple characters. Indeed, it is exactly the ability to put an unknown number of characters
into a single object-a string
-that makes these programs easy to write.
In this chapter, we'll look at more ways of dealing with batches of data, by writing a program that reads a student's exam and homework grades and computes a final grade. Along the way, we'll learn how to store all the grades, even if we don't know in advance how many grades there are.
Imagine a course in which each student's final exam counts for 40% of the final grade, the midterm exam counts for 20%, and the average homework grade makes up the remaining 40%. Here is our first try at a program that helps students compute their final grades:
#include <iomanip> #include <ios> #include <iostream> #include <string> using std::cin; using std::setprecision; using std::cout; using std::string; using std::endl; using std::streamsize; int main() { // ask for and read the student's name cout << "Please enter your first name: "; string name; cin >> name; cout << "Hello, " << name << "!" << endl; // ask for and read the midterm and final grades cout << "Please enter your midterm and final exam grades: "; double midterm, final; cin >> midterm >> final; // ask for the homework grades cout << "Enter all your homework grades, " "followed by end-of-file: "; // the number and sum of grades read so far int count = 0; double sum = 0; // a variable into which to read double x; // invariant: // we have read count grades so far, and // sum is the sum of the first count grades while (cin >> x) { ++count; sum += x; } // write the result streamsize prec = cout.precision(); cout << "Your final grade is " << setprecision(3) << 0.2 * midterm + 0.4 * final + 0.4 * sum / count << setprecision(prec) << endl; return 0; }
As usual, we begin with #include
directives and using
-declarations for the library
facilities that we intend to use. These facilities include <iomanip>
and <ios>
, which we
have not yet seen. The <ios>
header defines streamsize
, which is the type that the
input-output library uses to represent sizes. The <iomanip>
header defines the manipulator
setprecision
, which lets us say how many significant digits we want our output
to contain.
When we used endl
, which is also a manipulator, we did not have to include
the <iomanip>
header. The endl
manipulator is used so often that its definition appears in
<iostream>
, rather than in <iomanip>
.
The program begins by asking for and reading the student's name, and the midterm
and final grades. Next, it asks for the student's homework grades, which it continues to
read until it encounters an end-of-file signal. Different C++ implementations offer their
users different ways of sending such a signal to a program, the most common way being
to begin a new line of input, hold down the control key, and press z
(for computers running Microsoft Windows)
or d
(for computers running the Unix or Linux systems).
While reading the grades, the program uses count
to keep track of how many grades
were entered, and stores in sum
a running total of the grades. Once the program has read
all the grades, it writes a greeting message, and reports the student's final grade. In doing
so, it uses count
and sum
to compute the average homework grade.
Much of this program should already be familiar, but there are several new usages, which we will explain.
The first new idea occurs in the section that reads the student's exam grades:
cout << "Enter your midterm and final exam grades: "; double midterm, final; cin >> midterm >> final;
The first of these statements should be familiar: It writes a message, which, in this case,
tells the student what to do next. The next statement defines midterm
and final
as having
type double
, which is the built-in type for double-precision floating-point numbers.
There is also a single-precision floating-point type, called float
. Even though it might
seem that float
is the appropriate type, it is almost always right to use double
for
floating-point computations.
These types' names date back to when memory was much more expensive than it is
today. The shorter floating-point type, called float
, is permitted to offer as little precision
as six significant (decimal) digits or so, which is not even enough to represent the
price of a house to the nearest penny. The double
type is guaranteed to offer at least ten
significant digits, and we know of no implementation that does not offer at least 15 significant
digits. On modern computers, double
is usually much more accurate than float
,
and not much slower. Sometimes, double
is even faster.
Now that we have defined the midterm
and final
variables, we read values into
them. Like the output operator (§0.7/4), the input operator returns its left operand as its
result. So, we can chain input operations just as we chain output operations, so
cin >> midterm >> final;
has the same effect as
cin >> midterm; cin >> final;
Either form reads a number from the standard input into midterm
, and the next number
into final
.
The next statement asks the student to enter homework grades:
cout << "Enter all your homework grades, " "followed by end-of-file: ";
A careful reading will reveal that this statement contains only a single <<
, even though it
seems to be writing two string literals. We can get away with this because two or more
string literals in a program, separated only by whitespace, are automatically concatenated.
Therefore, this statement has exactly the same effect as
cout << "Enter all your homework grades, followed by end-of-file: ";
By breaking the string literal in two, we avoid lines in our programs that are too long to read conveniently.
The next section of the code defines the variables that we'll use to hold the information that we intend to read. Of these, the interesting part is
int count = 0; double sum = 0;
Note that we give the initial value 0
to both sum
and count
. The value 0
has type int
,
which means that the implementation must convert it to type double
in order to use it to
initialize sum
. We could have avoided this conversion by initializing sum
to 0.0
instead
of 0
, but it makes no practical difference in this context: Any competent implementation
will do the conversion during compilation, so there is no run-time overhead, and the
result will be exactly the same.
In this case, what's more important than the conversion is that we give these variables
an initial value at all. When we do not specify an initial value for a variable we are implicitly
relying on default-initialization. The initialization that happens by default depends on
the type of the variable. For objects of class type, the class itself says what initializer to
use if there is not one specified. For example, we noted in §1.1/10 that if we do not explicitly
initialize a string
, then the string
is implicitly initialized to be empty. No such
implicit initialization happens for local variables of built-in type.
Local variables of built-in type that are not explicitly initialized are undefined, which means that the variable's value consists of whatever random garbage already happens to occupy the memory in which the variable is created. It is illegal to do anything to an undefined value except to overwrite it with a valid value. Many implementations do not detect the violations of this rule, and allow access to undefined values. The result is almost always a crash or a wrong result, because whatever is in memory by happenstance is almost never a correct value; often it is a value that is invalid for the type.
Had we not given either sum
or count
an initial value, our program most likely
would have failed. The reason is that the first thing the program does with these variables
is to use their values: The program reads count
in order to increment it, and it
reads sum
in order to add its value to the one we just read. By the same token, we do not
bother to give an initial value to x
, because the first thing we do with it is read into it,
thereby obliterating any value we might have given it.
The only new aspect of the while statement is the form of its condition:
// invariant: // we have read count grades so far, and // sum is the sum of the first count grades while (cin >> x) { ++count; sum += x; }
We already know that the while
loop executes so long as the condition cin >> x
succeeds. We'll explore the details of what it means to treat cin >> x
as a condition in
§3.1.1/39, but for now, what's important to know is that this condition succeeds if the
most recent input request (i.e., cin >> x
) succeeded.
Inside the while
, we use the increment and compound-assignment operators, both of
which we used in Chapter 2. From the discussion there we know that ++count
adds 1
to
count
, and that sum += x
adds x
to sum
.
All that is left to explain is how the program does its output:
streamsize prec = cout.precision(); cout << "Your final grade is " << setprecision(3) << 0.2 * midterm + 0.4 * final + 0.4 * sum / count << setprecision(prec) << endl;
Our goal is to write the final grade with three significant digits, which we do by using
setprecision
. Like endl
, setprecision
is a manipulator. It manipulates the stream
by causing subsequent output on that stream to appear with the given number of significant
digits. By writing setprecision(3)
, we ask the implementation to write grades
with three significant digits, generally two before the decimal point and one after.
By using setprecision
, we change the precision of any subsequent output that
might appear on cout
. Because this statement is at the end of the program, we know that
there is no such output. Nevertheless, we believe that it is wise to reset cout
's precision
to what it was before we changed it. We do so by calling a member function (§1.2/14) of
cout
named precision
. This function tells us the precision that a stream uses for
floating-point output. We use setprecision
to set the precision to 3, write the final
grade, and then set the precision back to the value that precision
gave us. The expression
that computes the grade uses several of the arithmetic operators: *
for multiplication,
/
for division, and +
for addition, each of which has the obvious meaning.
We could have used the precision
member function to set the precision, by writing
// set precision to 3, return previous value streamsize prec = cout.precision(3); cout << "Your final grade is " << 0.2 * midterm + 0.4 * final + 0.4 * sum / count << endl; // reset precision to its original value cout.precision(prec);
However, we prefer to use the setprecision
manipulator, because by doing so, we can
minimize the part of the program in which the precision is set to an unusual value.
Conceptually, the only really new part of this program is the condition in the while
statement.
That condition implicitly uses an istream
as the subject of the while
condition:
while (cin >> x) {/*...*/}
The effect of this statement is to attempt to read from cin
. If the read succeeds, x
will
hold the value that we just read, and the while
test also succeeds. If the read fails (either
because we have run out of input or because we encountered input that was invalid for
the type of x
), then the while
test fails, and we should not rely on the value of x
.
Understanding how this code works is a bit subtle. We can start by remembering that
the >>
operator returns its left operand, so that asking for the value of cin >> x
is equivalent
to executing cin >> x
and then asking for the value of cin
. For example, we can
read a single value into x
, and test whether we were successful in doing so, by executing
if (cin >> x) {/*...*/}
This statement has the same meaning as
cin >> x; if (cin) { /* ... */ }
When we use cin >> x
as a condition, we aren't just testing the condition; we are also
reading a value into x
as a side effect. Now, all we need to do is figure out what it means
to use cin
as a condition in a while
statement.
Because cin
has type istream
, which is part of the standard library, we must look to
the definition of istream
for the meaning of if (cin)
or while (cin)
. The details of
that definition turn out to be complicated enough that we won't discuss it in detail until
§12.5/222. However, even without these details, we can already understand a useful
amount of what is happening.
The conditions that we used in Chapter 2 all involved relational operators that directly
yield values of type bool
. In addition, we can use expressions that yield values of arithmetic
type as conditions. When used in a condition, the arithmetic value is converted to a
bool
: Nonzero values convert to true
; zero values convert to false
. For now, what we
need to know is that similarly, the istream
class provides a conversion that can be used
to convert cin
into a value that can be used in a condition. We don't yet know what type
that value has, but we do know that the value can be converted to bool
. Accordingly, we
know that the value can be used in a condition. The value that this conversion yields
depends on the internal state of the istream
object, which will remember whether the
last attempt to read worked. Thus, using cin
as a condition is equivalent to testing
whether the last attempt to read from cin
was successful.
There are several ways in which trying to read from a stream can be unsuccessful:
int
and find
something that isn't a number.In any of these cases, the effect is the same: Using this input stream as a condition will indicate that the condition is false. Moreover, once we have failed to read from a stream, all further attempts to read from that stream will fail until we reset the stream, which we'll learn how to do in §4.1.3/57.
Understanding the invariant (§2.3.2/20) for this loop requires special care, because the
condition in the while
has side effects. Those side effects affect the truth of the invariant:
Successfully executing cin >> x
makes the first part of the invariant-the part that says
that we have read count
grades-false. Accordingly, we must change our analysis to
account for the effect that the condition itself might have on the invariant.
We know that the invariant was true before evaluating the condition, so we know that
we have already read count grades. If cin >> x
succeeds, then we have now read
count + 1
grades. We can make this part of the invariant true again by incrementing
count
. However, doing so falsifies the second part of the invariant-the part that says
that sum
is the sum of the first count
grades-because after we have incremented count
,
sum
is now the sum of the first count - 1
grades, not the first count
grades. Fortunately,
we can make the second part of the invariant true by executing sum += x
; so that
the entire invariant will be true on subsequent trips through the while.
If the condition is false, it means that our attempt at input failed, so we didn't get any
more data, and so the invariant is still true. As a result, we do not have to account for the
condition's side effects after the whi1e
finishes.


The Benefits of Version Control
Using Git & Github
10/26/15
Have you ever saved over a file with revisions you didn't want? Ever updated a website and completely ruined it without knowing how? Version Control subverts these tendencies by giving a detailed log of all saves. They're like checkpoints in a video game but better. At each point, you can also add a custom message of how you got to where you are and what you changed. You can even go back and change things to make the file function better. On top of all of this, Version Control allows multiple users or groups to make and edit files.
Git allows users to make, copy, move, edit, and export files all from your command line. This one incredible simple program can be infinitely complex for that reason. The user can manipulate input and pipe the output data into another file. This new data can in turn be tunneled, exported, and manipulated to other files and so on.
Git can be linked to Github to access files through any computer. This is how multiple users share and update files. Storing files on Github is better for this reason. Users on the same project can also split an original master file into other directories that can be modified by multiple users in multiple groups. When each group finishes their portion, they can be merged back into the master file to create the finished product.


JavaScript arrays are used to store multiple values in a single variable.
An array is a special variable, which can hold more than one value at a time.
If you have a list of items (a list of car names, for example), storing the cars in single variables could look like this:
var car1 = "Saab";
var car2 = "Volvo";
var car3 = "BMW";
However, what if you want to loop through the cars and find a specific one? And what if you had not 3 cars, but 300?
The solution is an array!
An array can hold many values under a single name, and you can access the values by referring to an index number.
Using an array literal is the easiest way to create a JavaScript Array.
Syntax:
var array_name = [item1, item2, ...];
Spaces and line breaks are not important. A declaration can span multiple lines:
Putting a comma after the last element (like "BMW",) is inconsistent across browsers.
IE 8 and earlier will fail.
The following example also creates an Array, and assigns values to it:
The examples above do exactly the same. There is no need to use new Array().
For simplicity, readability and execution speed, use the first one (the array literal method).
You access an array element by referring to the index number.
This statement accesses the value of the first element in cars:
Note: Array indexes start with 0.
[0] is the first element. [1] is the second element.
This statement changes the value of the first element in cars:
With JavaScript, the full array can be accessed by referring to the array name:
Arrays are a special type of objects. The typeof operator in JavaScript returns "object" for arrays.
But, JavaScript arrays are best described as arrays.
Arrays use numbers to access its "elements". In this example, person[0] returns John:
Objects use names to access its "members". In this example, person.firstName returns John:


term_detach - cleanly terminates the protocol
#include <libdill.h>
int term_detach(
int s,
int64_t deadline);
TERM is a protocol that implements clean terminal handshake between peers. When creating the protocol instance user specifies the terminal message to use. When closing the protocol, terminal messages are exchanged between peers in both directions. After the protocol shuts down the peers agree on their position in the message stream.
This function cleanly terminates TERM protocol. If termination message wasn't yet sent to the peer using term_done function it will be sent now. Afterwards, any outstanding inbound messages will be received and dropped silently. The function returns after termination message from the peer is received.
s: The TERM protocol handle.
deadline: A point in time when the operation should time out, in milliseconds. Use the now function to get your current point in time. 0 means immediate timeout, i.e., perform the operation if possible or return without blocking if not. -1 means no deadline, i.e., the call will block forever if the operation cannot be performed.
This function is not available if libdill is compiled with --disable-sockets option.
In case of success the function returns 0. In case of error it returns -1 and sets errno to one of the values below.
s = term_attach(s, "STOP", 4);
...
/* Send terminal message to the peer. */
term_done(s, -1);
/* Process remaining inbound messages. */
while(1) {
char buf[256];
ssize_t sz = mrecv(s, buf, sizeof(buf), -1);
/* Check whether terminal message was received from the peer. */
if(sz < 0 && errno == EPIPE) break;
frobnicate(buff, sz);
}
s = term_detach(s);
mrecv(3) mrecvl(3) msend(3) msendl(3) now(3) term_attach(3) term_attach_mem(3) term_done(3)


Exclusive Trailer: An App Connects the Living and the Dead in Mena Suvari-Starring ‘Apparition’
by John SquiresVertical Entertainment has acquired the supernatural horror film Apparition for release, unleashing it in theaters here in North America and on VOD later this year, on December 27.
Mena Suvari and Kevin Pollack star in the Waymon Boone-directed film, and we’ve got the official trailer and poster art for you today. Find both down below, exclusively here on BD.
The film is said to be “based on true events about former correctional facility the Preston School of Industry.”
“Apparition follows a group of millennials at an abandoned castle, experimenting with a spiritually guided app that connects the living with the dead. This ominous, historic site of murder and torture is linked to each of them in ways they’ll soon discover.”


Home
About Us
Order Now
Contact Us
Sonata-Pizza
Order Now
Sonata-Pizza
Here at Sonata-Pizza we are more than just a franchise, we are a
family
and our customers are our top priority.
Enjoy our many delicacies and various toppings.
Don't forget to give us your feedback.
ENJOY!!


| | |
- do_feature_selection(name, data_file)
- Does lasso regression, ridge regression, recursive feature elimination,
and random forrest modeling for each of the nine properties being modeled
Inputs
------
name : String containing the name of the csv file containing the data
to be analyzed (i.e. "CdTe" for CdTe.csv)
data_file : String containing the name of the file the model statistics will
be stored in, where the RMSE and R-Squared values for each model
will be stored
Outputs
-------
cd_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict $\Delta$H(Cd-rich)
mod_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict $\Delta$H(Mod)
x_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict $\Delta$H(X-rich)
plus_3_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict the (+3/+2) charge transfer state
plus_2_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict the (+2/+1) charge transfer state
plus_1_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict the (+1/0) charge transfer state
minus_1_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict the (0/-1) charge transfer state
minus_2_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict the (-1/-2) charge transfer state
minus_3_list : Contains four lists, one for each model type (Lasso, Ridge,
Recursive Feature Elimination, and Random Forrest), each of which
contains the coefficients for each descriptor used in the model
to predict the (-2/-3) charge transfer state
- get_data_csv(name)
- Retrieves data from a csv file and puts it into a pandas dataframe
Inputs
------
name : String containing the name of the csv file containing the data
to be analyzed
Outputs
-------
df : Pandas dataframe containing all of the data extracted from the
csv file
- get_data_h5(name, key=None)
- Retrieves data from hdf5 file and puts it into a pandas dataframe, then puts
the descriptors into groups
Inputs
------
name : String containing the name of the hdf5 file containing the data
to be analyzed (i.e. data.hdf5)
Outputs
-------
df : Pandas dataframe containing all of the data extracted from the
hdf5 file
el : contains the names of the columns of the elemental descriptors
unit : contains the names of the columns of the unit cell descriptors
dEl : contains the names of the columns of the $\Delta$ elemental descriptors
coul : contains the names of the columns of the coulomb matrix descriptors
dCell : contains the names of the columns of the $\Delta$ cell descriptors
cell : contains the names of the columns of the cell descriptors
- lasso_reg(X, Y, data_file, p=False)
- Does lasso regression on the data provided
Inputs
------
X : Coulumns of the pandas dataframe that contains the data for each
of the descriptors to be used
Y : Column of the pandas dataframe that contains the values to be
predicted
data_file : String containing the name of the file the model statistics will
be stored in, where the RMSE and R-Squared values for each model
will be stored
Outputs
-------
coefs : Contains a list of the coefficient for each descriptor used
- main()
- rf_reg(X, Y, data_file, p=False)
- Does random forrest regression on the data provided
Inputs
------
X : Coulumns of the pandas dataframe that contains the data for each
of the descriptors to be used
Y : Column of the pandas dataframe that contains the values to be
predicted
data_file : String containing the name of the file the model statistics will
be stored in, where the RMSE and R-Squared values for each model
will be stored
Outputs
-------
coefs : Contains a list of the coefficient for each descriptor used
- rfe_selection(X, Y, data_file, p=False)
- Does recursive feature elimination on the data provided
Inputs
------
X : Coulumns of the pandas dataframe that contains the data for each
of the descriptors to be used
Y : Column of the pandas dataframe that contains the values to be
predicted
data_file : String containing the name of the file the model statistics will
be stored in, where the RMSE and R-Squared values for each model
will be stored
Outputs
-------
coefs : Contains a list of the coefficient for each descriptor used
- ridge_reg(X, Y, data_file, p=False)
- Does ridge regression on the data provided
Inputs
------
X : Coulumns of the pandas dataframe that contains the data for each
of the descriptors to be used
Y : Column of the pandas dataframe that contains the values to be
predicted
data_file : String containing the name of the file the model statistics will
be stored in, where the RMSE and R-Squared values for each model
will be stored
Outputs
-------
coefs : Contains a list of the coefficient for each descriptor used
|


PassEncoder
Apple Wallet (formerly Passbook) pass encoding and signing in Swift.
Features
- Modern Swift API
- Allows you to specify custom pass data
- Add other files (images, JSON, etc)
- Manifest generation
- Signing support
- File system managed seamlessly
- Get pass
Data
easily
Requirements
- iOS 10.0+ / macOS 10.12+ / tvOS 10.0+ / watchOS 3.0+
- Or Linux with zlib development package
- Xcode 9.0
- Swift 4.0
- OpenSSL
Installation
Swift Package Manager
Add the following line to your dependencies section of Package.swift
:
.package(url: "https://github.com/aydenp/PassEncoder.git", .upToNextMajor(from: "1.0.0"))
and add PassEncoder
to your target’s dependencies.
Heads up! Because this package requires macOS 10.12+, and as of writing this, SPM does not support setting minimum deployment targets, you will have to manually specify building with that target, or set it in your Xcode project (if applicable). swift build -Xswiftc
-target-Xswiftcx86_64-apple-macosx10.12
Usage
// Create our encoder
if let encoder = PassEncoder(passDataURL: directory.appendingPathComponent("pass.json")) {
// Add a nice icon
encoder.addFile(from: directory.appendingPathComponent("icon.png"))
let passData = encoder.encode(signingInfo: (certificate: URL_TO_CERT.PEM, password: CERT_PASSWORD))
// Your archived .pkpass file is in passData as Data
}
Before using the library, you’ll also need to set the Apple WWDR certificate URL, which you can read about below.
Heads up! Operations in this library are all synchronous, so it is advisable to run them on a separate
OperationQueue
so that they do not block your thread.
Creating and preparing your certificate
You need to repeat this step for each different passTypeId
you have in your pass.json
.
- Go to the Apple Developer Pass Type IDs page and create your pass type.
- Go to the certificate section and follow the instructions to create a certificate for your pass.
- Download the certificate, and ensure it is named
Certificates.p12
. - Run the following command:
openssl pkcs12 -in Certificates.p12 -out PassCert.pem
. - Your pass certificate is now stored in
PassCert.pem
!
You’ll also need to download the Apple Worldwide Developer Relations Root Certificate Authority file to sign passes.
- Download the certificate from here.
- Import it into Keychain Access (double click it).
- Find it in Keychain Access, and export it as a .pem file.
Set the
PassSigner
‘s WWDR URL to it in your code.PassSigner.shared.appleWWDRCertURL = URL(fileURLWithPath: PATH_TO_WWDR_CERT.PEM)
Documentation
To take full advantage of the package, check out the documentation and see all of the methods and variables that are made available to you.
Contributing
Feel free to contribute to the source code of PassEncoder to make it something even better! Just try to adhere to the general coding style throughout, to make it as readable as possible.
If you find an issue in the code or while using it, create an issue. If you can, you’re encouraged to contribute and make a pull request.
License
This project is licensed under the MIT license. Please make sure you comply with its terms while using it in any way.


The edit tab is used for manipulating the components and their interconnections. The list below provides a detailed description of the available operations found on the Edit Tab as shown in the figure.
Description of the Model Properties Group:
Edit Model ID (not yet implemented) edits the unique model ID. This ID is generated automatically and is used by the ARE to store model based information belonging to the editing model.
Show Model Description (not yet implemented) shows the model description dialog, allowing the user to edit the model description. The description is divided into three parts: Short Description, Model Requirements and Detailed Description
Description of the Edit Group:
Cut cuts out the selected elements and stores them to clipboard.
Copy copies the selected elements to the clipboard.
Paste copies the elements from the clipboard to the drawing field.
Delete Selection deletes the selected elements. This can also be done with the delete-key.
Undo the last editing action like move a component, add/delete a component or also the channel and event channel operations. Setting properties and events (things done in the property window) are excluded form undo.
Redo the last editing action that has been undone with Undo. Setting properties and events (things done in the property window) are excluded form redo.
After at least two components have been added to the deployment, they can be connected to each other. A connection always has to start at an output port (right hand side of a component) connecting to an input port (left side of a component). One output port can be connected to several input ports, but an input port can only receive data from one output port. Additionally the data types of the ports must match in order to be able to connect them (see the section on Channels).


Games
What games do we have?
Current games
Game id
Game name
Status
accepts/(tot. invites)
action
Invites for new games
Game id
Game name
Accepts/(tot. invites)
Accept?
Decline?
Message goes here


Toggle navigation
Home
Crime Against Women
Property Stolen & Recovered
Murder Victim
Murder Causes
Rape
Crime
Analysis
Home
Cases against Women
Murder Cases
Indian
Crime Data Analysis & Prediction
This website provides a better visualization of Indian Crimes analysis form period 2001-2010
Indian
Crime Data Analysis & Prediction
This website provides a better visualization of Indian Crimes analysis form period 2001-2010


Introduction¶
Management summary¶
Goal of this page is to provide a manual and scripts to
- get an reliable open source infrastructure for your business / environment
- reproducibly running in less than 1 hour
- at a cost of less 20 € month (lets see how this changes)
About the Flex4Apps¶
The convergence of cloud, communication and IoT infrastructure plus the trend towards virtual applications (e.g. migrating software to the cloud) create new challenges for application developers and infrastructure providers. The resulting systems are complex with dynamic resources hiding possible problems. This creates a requirement for flexible monitoring and optimisation methods. The Flex4Apps project addresses the challenges of monitoring and optimising large, distributed, cyber-physical systems. The goal of the project is to provide a solution to manage the high data volumes and complexity of system monitoring whilst disturbing the target system as little as possible.
The demonstrator is setup using the f4a.me domain.
High level architecture¶
Goal of the project is not to worry about "hardware" while operating an infrastructure. Currently servers have to be rented / purchased. They need to be maintained and in case something breaks down, the operation of the overlaying service / system is impacted.
Docker swarm is one solution to achieve this abstraction layer. For this approach three or more (virtual) servers are required. RAM and CPU power is key, SSDs help to improve the performance.
Even though docker runs on many platforms we decided to operate based on an Ubuntu 16.04 LTS. Windows is also possible, but has some drawbacks.
Docker only achieves the independence with regards to the stateless execution of services like webservers, mailservers and other services. To provide persistent storage a file server / cluster and a database server is needed.


 Perhaps I'm just becoming jaded, but I found Stone's editing technique, in which no shot is more than about two seconds long, to be distancing. I walked out of PLATOON in the village scene; it seemed to me that Stone was showing violence just for its sensational effect. Here, perhaps, he is trying to do the same thing but he has over-edited the film, with the result that one sees it as a movie rather than the commentary on our culture that it evidently tries to be.
Stone's films take a controversial stand, which helps marketing. Thus, JFK asserted a particularly unlikely version of the Kennedy assassination myth, and Stone extended it in a kind of performance art, going on talk shows to claim he really believed it. BORN ON THE FOURTH OF JULY turned a bitter Vietnam vet's tragic story into a condemnation of the Veteran's administration, US policy in Vietnam, etc. NATURAL BORN KILLERS claims that we have been so desensitized by television that we would accept truly evil people as national heroes.
Woody Harrelson is quite good as the murdering duo. I liked Harrelson particularly, as he drawls and slouches his way through the part. He seems deeply relaxed and comfortable with his character.
Against this, Juliette Lewis seems weak, except in a few scenes where her anger explodes; she's great in the fight scenes, and while dancing. But I did not think she carried the weight of her role very well; I still can't decide if she was meant to be a moral zero into which Harrelson's character poured his evil, or the catalyst for his transformation.
The scenes with Rodney Dangerfield are probably the best of the film, and make its point most clearly. In fact, I think Dangerfield would have destroyed his career with this part, if he had done it earlier. (Dangerfield's character is just too close to his comic personality for comfort.) It is a parody of a TV show, with laugh track, etc., but Dangerfield plays a sickeningly evil father, abusing Lewis's character and the rest of his family.
There's a little too much (any is too much) of the Oliver Stone trademark American Indian mysticism here, as there was in THE DOORS.
Robert Downey, Jr. is great as tabloid TV reporter with the voice of Robin Leach (I wonder if they made a deal with Leach, or is he suing?) who makes the murderers into stars.
This film forms a natural end (hopefully) to Stone's indictment of American culture. It is an attack on television style sensationalization of murderers, etc., which in itself extends that sensationalization. I don't think Stone could go much farther with this point; like overbeaten egg whites this film falls flat. He'll have to think of something original to do next.
.
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


Caitlyn Jenner defended against of torrent of transphobic abuse during I'm A Celeb launch
I'm A Celebrity viewers were furious over the amount of abuse realty TV star Caitlyn received this evenning
by Irishmirror.ieFurious I'm A Celebrity fans took to Twitter to defend Caitlyn Jenner over the torrent of transphobic abuse she was receiving online.
Tonight, ten new celebrities began their jungle journey as they took part in a number of terrifying tasks before heading to camp.
Caitlyn, however, was fearless as she was asked to jump out of a plane - something she had never done before despite being a pilot for 45 years.
But, unfortunately, tonight's show was ruined for some over the transphobia hurled Caitlyn's way.
One tweeted: "I’ve already seen some comments but can u mfs pls have some decency and stop with this transphobic s*** towards caitlyn. you are not the comedians you think u are. you’re just being pricks. #ImACeleb."
While another pleaded: "pls don’t be transphobic towards caitlyn, there’s no need #ImACeleb."

Another wrote: "I find it sad how people can be so transphobic esp around caitlin Jenner on #ImACeleb #ImACelebrityGetMeOutOfHere."
"Not ready to read all the unnecessary transphobic comments #ImACeleb," one commented.
Another remarked: "I'm enjoying going through twitter and blocking everyone who makes transphobic jokes during the ad break. #ImACeleb."
*I'm A Celebrity returns tomorrow at 9pm on ITV


HTML, CSS and/or Javascript experimentations go here
These are the most often used elements by beginners:
Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
This is a normal paragraph
This paragrph is explicitly Times New Roman
This paragraph is explicitly monospaced
This date is surrounded by a time element:
You can get all time elements in Javascript by pressing ctrl-shift-i or F12 and putting document.querySelectorAll("time")
into the console
Here are some fancier HTML elements
To make George eat an apple, selectFile|Eat Apple...
<details>
animation test
Automated Status: Operational
Velocity: 12m/s
Direction: North
Copying "Really Achieving Your Childhood Dreams"
Copying... 25%
- Transfer rate:
- 452KB/s
- Local filename:
- /home/rpausch/raycd.m4v
- Remote filename:
- /var/www/lectures/raycd.m4v
- Duration:
- 01:16:27
- Color profile:
- SD (6-1-6)
- Dimensions:
- 320×240
Detail Element
The following shows how a details element can be used to hide some controls by default:
CSS border radius
https://www.w3.org/TR/css-backgrounds-3/#the-border-radiusLorem ipsum dolor sit amet.
Corner shaping
Lorem ipsum dolor sit amet.
Lorem ipsum dolor sit amet.
Lorem ipsum dolor sit amet.
Lorem ipsum dolor sit amet.
Lorem ipsum dolor sit amet.
Lorem ipsum dolor sit, amet consectetur adipisicing elit. Inventore, et.
Lorem ipsum dolor sit, amet consectetur adipisicing elit. Inventore, et.
Image scaling
smooth
high-quality
crisp-edges - this looks broken :(
pixelated
default
font weirdness
wut
CSS transitions
CSS Animations
source: Travery Media


--- layout: home title: BLOG description: "The personal blog of Christopher B. Choy, a doctoral candidate in Electrical Engineering at Stanford University." headline: An Engineer's Diary tags: [Christopher, Bongsoo, Choy, computer, vision, blog, stanford, university, KAIST] permalink: / image: feature: wood-texture-1600x800.jpg ---
{{ post.content | strip_html | truncatewords:20 }}
{{ post.content | strip_html | truncatewords:20 }}


Dedesign the Web
How well do you know the Web?
Dedesign the Web is a quick and fun game where you guess a website by looking at its wireframe below.
Guess the website:
.com
Submit ➭
PRESS ENTER
to submit your answer or
SKIP AND MOVE ON
Correct! Click here to move on to the next level.
Website
of 12
Built by
DESIGNATION Labs
. For kicks and giggles.


Home
Being human
Tv shows
Movies
Movies
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
HDRip
Salman Khan Full movies | In Hindi
Previous
Next


Java imaging Mistral Java2D JAI ImageJ JHLabs JIU
This article describes Mistral, an opensource, high level imaging engine aimed at professional imaging
applications which:
- allows to use under an unified API a number of existing imaging engines (such as Java2D, JAI and others);
- implements platform-specific optimizations;
- can be easily extended;
- includes an advanced image renderer;
- has extensive support for distributed processing;
- supports metadata extraction (in progress).
Feedback to this article can be posted to the Mistral forum.
Introduction
In more than ten years Java has colonized a lot of application fields, ranging from the cellular phone to the data
center and beyond. In the latest years there has also been a "renaissance" in the desktop segment, both thanks to
new rich APIs such as SwingLabs and to the general fact that the Virtual
Machine and Swing itself have gotten faster, removing a lot of showstopping problems that haunted their early
versions. Furthermore, rich platforms such as NetBeans RCP or Eclipse
RCP now provide a lot of tools for the design of complex and modular desktop applications.
Focusing on the desktop, one of the application fields that have been only marginally targeted is imaging - I'm
talking of the end-user, desktop kind of imaging, as in some scientific and technologic fields Java2D,
JAI (Java Advanced Imaging) and ImageJ
have been used for years.
But it looks like things are changing also in this scenario. More or less one year ago, Lightzone,
a commercial application targeted at photographers, has appeared; Jasper
Potts has recently blogged about a nice
desktop application used for setting up photos for printing albums; Jasper himself has worked at Xerto that
has produced Imagery, announced some months ago and that now seems
to be near the beta stage; even though is not a full-fledged imaging software, JAlbum
is one of the most used tools for creating an publishing gallery. Also worth mentioning is JH
Labs, an open source application; and Dirk Hennig has his own project named Quippix.
All of these projects have been done in Java and this means that probably the technology is now mature also in this
field.
I've been working on opensource imaging since 2003, even though for some time I wasn't clearly committed in
delivering a real product - I've rather worked on prototypes that I used to try some technologies I didn't knew.
I've taken the final decision of going towards a real product only recently. Today the project, called blueMarine,
is near to its first Release Candidate (compulsive downloaders, beware: there are some early eaccess builds already
available, but they aren't quality tested and in most cases they will fail just when installing - I'd suggest you to
go to the site and rather subscribe to the news feed and
wait for the incoming RC1; if instead you're interested in joining the project, contact me following the links on
the website).
As the project has grown, I've started to spin-off some sub-projects which covers specific parts, since I thought
that they could be useful to others. One of the APIs at the core of blueMarine is Mistral, an imaging engine with
all the features for a professional imaging application.
State of the art of Java imaging
Before talking of Mistral, I think it's a good thing to look at the current scenario about imaging APIs.
- The core API for imaging is Java2D, which is part
of the JRE. Java2D deals with BufferedImage, provides some operation for image
manipulation - and BufferedImage is fully compatible with Swing, so it can be
directly drawn on a GUI component.
- JAI is the Java Advanced Imaging API and is a step forward: not only it
provides a much richer set of manipulation primitives (such as Fourier Transforms and Histograms, support for
Region of Interests, etc...), but it also comes with its own image class, PlanarImage,
which has support for "tiling". Tiling is a memory allocation strategy by which only the currently used portions
of the image are kept in memory. The JAI attitude towards efficient handling of large images is also
demonstrated by the "deferred
execution" feature: when you apply a sequence of operations to an image, they are not executed at once,
but only when the API understands that the application wants a result (e.g. it wants to draw the image
somewhere). In this way execution can be optimized as only the strictly required subset of tiles is manipulated.
This attitude towards very large images is explained by the fact that NASA -
who has contributed the design of the API - is using JAI for the management of astronomic images that tend to be
very large. JAI is not part of the JDK but it's available as a standard extension; and PlanarImage
is somewhat a close relative of BufferedImage (but must be handled in a rather
different way if you want to use tiling).
- ImageJ is a public domain imaging engine developed by the National
Institutes of Health. While it is not as sophisticated as JAI, it has some popularity in the scientific
world, specially for medical image processing. It comes with a desktop application for image manipulation, with
the same name (I didn't cited it before since it's not targeted at the desktop casual end-user). ImageJ models
images with its own class.
- JHLabs provides a set of filter classes orientated to photo
manipulation, with similar effects as Photoshop. JHLabs works on regular BufferedImages.
- JIU is the latest API I've been aware of (just a few days ago)
and provides another set of image manipulation classes. I don't know much about it since I was be pointed to JIU
just a few days ago. I could be wrong but I think that JIU models images with its own class.
So, indeed it looks like there's a lot of stuff. While blueMarine editing attitude is presently only aimed to RAW
camera formats conversion (that require a very special set of filters), I plan to integrate a full-fledged editor
sooner or later. Even though JAI is by far my favourite imaging API, as blueMarine has been designed as a
plugin-expandable core I would also like to have people to use it with their own library. How to achieve this?
A meta imaging engine
Mistral is a "meta imaging engine", in the sense that it doesn't include its own imaging code, but use other APIs.
It acts as an abstract imaging layer, as the programmer only sees Mistral classes, while the actual implementation
is pluggable. This means that you can use the very same Mistral code and have Java2D, or JAI, or JHLabs, or JIU to
do the work (of course, supposing that you're done something which is covered by all these APIs). Furthermore, you
are not constrained in using a single implementation, but you can use multiple ones at different stages of the
elaboration. For instance, you can start with Java2D (by default Mistral always starts with Java2D when an image is
loaded from a file, since the JDK has a very rich and puggable image I/O facility), perform some operations with
Java2D, then use some JAI features, later JHLabs and so on. This makes a lot of sense when the different APIs share
the same image representation (such as, for instance, Java2D and JHLabs) or where the conversion of the image
representation is fast (such as for Java2D and JAI when no tiling is used). For instance, a typical imaging
application operation is creating thumbnails from the original files, which can be done by using Java2D; but if you
need a Fourier Transform, you can immediately switch to JAI.
The core of Mistral is the EditableImage class, an opaque wrapper against the actual
image representation. It exposes a few methods for reading an image from an external source or creating it from the
scratch, performing operations on it and getting the most common attributes such as the size, the number of colors,
and so on. Here it is an example of code:
EditableImage image = EditableImage.create(new ReadOp(file, 0));
image.execute(new CropOp(10, 10, 600, 400));
Histogram histogram = image.execute(new HistogramOp()).getHistogram();
This sequence loads an image from a file, crops it, and computes the histogram on the cropped image. ReadOp,
CropOp and HistogramOp are classes representing the three
operations; they are simple Java beans that only hold the required parameters (and eventually the result if it's not
an image), but not the implementation code. The code is instead contained in some specific CropXXXOp
and HistogramXXXOp classes which are specific to the API used (for instance, CropJ2DOp,
HistogramJ2DOp - and CropJAIOp, HistogramJAIOp,
and so on). The mapping between the generic and the specialized operations is stored in so called "implementation
factories". There's one implementation factory for every supported API and they are registered into the runtime with
the following code:
ImplementationFactoryRegistry registry = ImplementationFactoryRegistry.getInstance();
registry.registerFactory(new ImplementationFactoryJ2D());
registry.registerFactory(new ImplementationFactoryJAI());
registry.registerFactory(new ImplementationFactoryImageJ());
(in the real case, ImplementationFactoryJ2D is always registered by default, while the
others have to be explicitly registered by the programmer). When an execute() operation
is performed, Mistral searches the implementation in the current implementation factory (always Java2D at the
beginning); if it can't find it, other factories are searched and the image representation is eventually converted.
Referring to the above histogram example, the whole sequence is executed using Java2D since all the three operations
are defined in its factory. Somebody could prefer to use the JAI version of HistogramOp
(which BTW is faster and much accurate). The programmer can take the control and choose the proper API for each
operation, unregistering the operation from all the other factories. For instance:
ImplementationFactoryJ2D.getInstance().unregister(HistogramOp.class);
makes sure that the implementation from Java2D is not used (note that the previous sample code for computing the
histogram doesn't change, but now the histogram is computed by means of JAI).
Last but not least, new operations can be defined and added to a factory by registering them at runtime.
It is to be pointed out that this abstraction layer doesn't have a significant performance cost since finding an
implementation is just a matter of a few hashtable lookups, a much faster operation than the average image
manipulation.
Added value of the abstraction layer
If you need this imaging API interchangeability you are already appreciating the abstraction layer of Mistral; if
you don't, consider another bunch of clear advantages of it:
The Renderer
A central feature of any desktop imaging application is the image renderer: a component able to show images at
various scales, quickly, possibly integrating with other tools visual cues (such as selection tools and so on). Thus
it's no surprise that Mistral comes with its own image renderer able to work with EditableImages.
The design of such a component is apparently easy: after all an image can be directly drawn over a Graphics
object.
There are some issues indeed, that Mistral rendering component EditableImageRenderer
deals with:
- Performance. As we said before, scaling is one of those troubled
operations, as its speed can dramatically change in different scenarios. There are also other potential
problems: for instance, some performance bugs must be worked around (e.g. it's extremely slow to resize images
with certain non-sRGB color profiles). Furthermore, a professional image renderer should be also able to rotate
an image and this is another source of performance troubles. Last but not least, there are some specialized
Java2D image classes, such as VolatileImage, which offer a substantial performance
boost and sometimes even hardware acceleration. EditableImageRenderer takes care of
this and offers some approaches for trading off memory with speed, for instance keeping optimized copies of the
image in memory.
- Flexibility. Many image visualization components use scroll bars for
dealing with very large images - after all scroll bars have been invented for this. Nevertheless, this approach
is not necessarily the best for an imaging tool. Modern applications usually prefer to use the mouse drag to pan
the image and mouse click to toggle between zoomed mode and 1:1 rendering. Also, zooming can be controlled by
specialized buttons or by mouse wheel. EditableImageRenderer allows to implement all
of these approaches by attaching specialized (and extendable) controllers.
- Previewing editing. Users want to preview in real time the editing
changes they apply - for instance a contrast or a white point adjustment. For performance reasons, it's not
feasible to apply these changes in real time to the whole image and redisplay it: the preview transformation -
when possible - must be instead directly applied to the scaled image in the renderer. For this purpose a special
PreviewSettings class can be applied to rendering.
- Support for different imaging APIs. The actual rendering of the image
is delegated to a PaintOp, which can be implemented in different ways by the
underlying adapter as previously explained. For instance, the JAI adapter could take advantage of tiling for
large images and take into memory only the portion of the image that should be shown. Other existing image
rendering components usually require a preliminary conversion to a BufferedImage,
which is not compatible with tiling.
The renderer has been designed in a modular way as all the classes that control the interaction with the user are
external controllers. In this way, for instance, it has been possible to implement an AnimatedZoomController
which applies a smooth animation when the scale is changed; the programmer can add his own as well.
Some JavaWebStart demos
for the image renderer are available.
Status
Mistral, at present time, is in beta stage. The design requires only a few changes before the final version, most of
the things described in this article are ready and stable (there are just a few platform-specific performance
issues). The two parts that now require extensive development are: operation coverage (only a subset of Java2D and
JAI features are covered - up to now Mistral development has been driven by the needs of some projects that rely on
it) and testing (there is basic automated testing, but it's not enough). Only adapters for Java2D and JAI exist;
there's a non working skeleton for ImageJ. Some old workarounds, written at the old times of JDK 1.4, could probably
be removed as the relevant JDK bugs could have been fixed (Mistral targets JDK 1.5).
Work is already scheduled for integrating metadata extraction capability (including native maker notes and XMP)
- taking advantage of both the standard Java capabilities and external libraries. Mistral is able to work with "RAW
format files" thanks to the Image I/O jrawio plugin.
While most of this article has been focused on desktop applications, Mistral can be used on the server side as well.
Its various features are implemented in separated JARs, so you can include in your classpath only what you need and
keep the footprint low.
Future plans
The evolution of Mistral is strictly related to the feedback we will have from the community (the current plans are
constrained by the requirements of a few opensource and paid projects that rely upon it). The ideal target is to
have Mistral to become something similar as CoreImage
is for Mac OS X. At the moment there are two improvement areas we are thinking of:
- providing a component for generation and maintainance of thumbnails;
- creating an adapter for Mac OS X CoreImage Image Units, in order to take full advantage of Mac OS X imaging
facilities.
The former activity is already scheduled (indeed there's already working code in blueMarine that just has to be
moved and refactored); the latter would start only if programmers with specific CoreImage skills will join the
project.
Feedback to this article can be posted to the Mistral forum.
Further reading


The OWASP Node Goat is an educational Node.js web application vulnerable to the OWASP Top 10 risks.
It is intended to show how each of these vulnerabilities can manifest in a Node.js specific way, and provides the subsequent mitigation for each with source code examples.
To start hacking the application, login using the form below, or access the tutorial guide to know more.


built this site because he likes watching competitive matches for Team Fortress 2 but kept forgetting when they were going live. He's currently the lead developer at Ad Hoc Labs, the creators of Burner. Before that he co-founded the startup ReadyUp!, wrote a bunch of code at Google, and got a couple computer science degrees from UCLA.


What is Zero-Touch?
Zero-Touch Importing refers to a simple point-and-click method for importing C# libraries. Dynamo will read the public methods of a .dll file and convert them to Dynamo nodes. You can use Zero-Touch to develop your own custom nodes and packages, and to import external libraries into the Dynamo environment.
With Zero-Touch, you can actually import a library which was not necessarily developed for Dynamo and create a suite of new nodes. The current Zero-Touch functionality demonstrates the cross-platform mentality of the Dynamo Project.
This section demonstrates how to use Zero-Touch to import a third party library. For information on developing your own Zero-Touch Library, reference the Dynamo wiki page.
Zero-Touch Packages
Zero-touch packages are a good complement to user-defined custom nodes. A few packages which use C# libraries are listed in the table below. For more detailed information on packages, visit the Packages section in the Appendix.
| Logo/Image | Name |
| Mesh Toolkit | |
| Dynamo Unfold | |
| Rhynamo | |
| Optimo |
Case Study - Importing AForge
In this case study, we'll show how to import the AForge external .dll library. AForge is a robust library which offers a range of functionality from image processing to artificial intelligence. We'll reference the imaging class in AForge to do a few image processing exercises below.
Download and unzip the example files that accompany this package case study (Right click and "Save Link As..."). A full list of example files can be found in the Appendix. Zero-Touch-Examples.zip.
- Let's beging by downloading AForge. On the AForge download page, select [Download Installer] and install after download has completed.
- In Dynamo, create a new file and select File > Import Library...
- In the pop-up window, navigate to the release folder in your AForge install. This will likely be in a folder similar to this one: C:\Program Files (x86)\AForge.NET\Framework\Release.
- AForge.Imaging.dll: We only want to use this one file from the AForge library for this case study. Select this .dll and hit "Open".
- Back in Dynamo, you should see an "AForge" group of nodes added to your Library Toolbar. We now have access to the AForge imaging library from our visual program!
Exercise 1 - Edge Detection
Now that the library's imported, we'll start off simple with this first exercise. We'll do some basic image processing on a sample image to show how AForge image filters. We'll use the "Watch Image" node to show our results and apply filters in Dynamo similar to those in Photoshop.
Download and unzip the example files that accompany this package case study (Right click and "Save Link As..."). A full list of example files can be found in the Appendix. ZeroTouchImages.zip
Now that the library's imported, we'll start off simple with this first exercise (01-EdgeDetection.dyn). We'll do some basic image processing on a sample image to show how AForge image filters. We'll use the "Watch Image" node to show our results and apply filters in Dynamo similar to those in Photoshop
First, we want to import an image to work with. Add a File Path node to the canvas and select "soapbubbles.jpg" from the downloaded exercise folder (photo cred: flickr).
- The File Path node simply provides a String of the path to the image we've selected. We need to convert this File Path to an image in the Dynamo environment.
- Connect the File Path node to the File.FromPath node.
- To convert this File into an Image, we'll use the Image.ReadFromFile node.
- Last, let's see the result! Drop a Watch Image node onto the canvas and connect to Image.ReadFromFile. We haven't used AForge yet, but we've successfully imported an image into Dynamo.
Under AForge.Imaging.AForge.Filters (in the navigation menu), you'll notice that there is a wide array of filters available. We're going to use one of these filters now to desaturate an image based on threshold values.
- Drop three sliders onto the canvas, change their ranges to be from 0 to 1 and their step values to be 0.01.
- Add the Grayscale.Grayscale node to the canvas. This is an AForge filter which applies a grayscale filter to an image. Connect the three sliders from step 1 into cr, cg, and cb. Change the top and bottom sliders to have a value of 1 and the middle slider to have a value of 0.
- In order to apply the Grayscale filter, we need an action to perform on our image. For this, we use IFilter.Apply. Connect the image into the image input and Grayscale.Grayscale into the iFilter input.
- Plugging into a Watch Image node, we get a desaturated image.
We can have control over how to desaturate this image based on threshold values for red, green, and blue. These are defined by the inputs to the Grayscale.Grayscale node. Notice that the image looks pretty dim - this is because the green value is set to 0 from our slider.
- Change the top and bottom sliders to have a value of 0 and the middle slider to have a value of 1. This way we get a more legible desaturated image.
Let's use the desaturated image, and apply another filter on top of it. The desaturated image has some contrast, so we we're going to test some edge detection.
- Add a SobelEdgeDetector.SobelEdgeDetector node to the canvas. Connect this as the IFilter to a new IFilter node, and connect the desaturated image to the image input of the IFilter node.
- The Sobel Edge Detector has highlighted the edges in a new image.
Zooming in, the edge detector has called out the outlines of the bubbles with pixels. The AForge library has tools to take results like this and create Dynamo geometry. We'll explore that in the next exercise.
Exercise 2 - Rectangle Creation
Download and unzip the example files that accompany this package case study (Right click and "Save Link As..."). A full list of example files can be found in the Appendix. ZeroTouchImages.zip
Now that we're introduced to some basic image processing, let's use an image to drive Dynamo geometry! On an elementary level, in this exercise we're aiming to do a "Live Trace" of an image using AForge and Dynamo. We're going to keep it simple and extract rectangles from a reference image, but there are tools available in AForge for more complex operations. We'll be working with 02-RectangleCreation.dyn from the downloaded exercise files.
- With the File Path node, navigate to grid.jpg in the exercise folder.
- Connect the remaining series of nodes above to reveal a course parametric grid.
In this next step, we want to reference the white squares in the image and convert them to actual Dynamo geometry. AForge has a lot of powerful Computer Vision tools, and here we're going to use a particularly important one for the library called BlobCounter.
- After adding a BlobCounter to the canvas, we need a way to process the image (similar to the IFilter tool in the previous exercise). Unfortunately the "Process Image" node is not immediately visible in the Dynamo library. This is because the function may not be visible in the AForge source code. In order to fix this, we'll need to find a work-around.
- Add a Python node to the canvas.
import clr
clr.AddReference('AForge.Imaging')
from AForge.Imaging import *
bc= BlobCounter()
bc.ProcessImage(IN[0])
OUT=bc
Add the code above to the Python node. This code imports the AForge library and then processes the imported image.
Connecting the image output to the Python node input, we get an AForge.Imaging.BlobCounter result from the Python node.
The next steps will do some tricks that demonstrate familiarity with the AForge Imaging API. It's not necessary to learn all of this for Dynamo work. This is more of a demonstration of working with external libraries within the flexibility of the Dynamo environment.
- Connect the output of the Python script to BlobCounterBase.GetObjectRectangles. This reads objects in an image, based on a threshold value, and extracts quantified rectangles from the pixel space.
- Adding another Python node to the canvas, connect to the GetObjectRectangles, and input the code below. This will create an organized list of Dynamo objects.
OUT = []
for rec in IN[0]:
subOUT=[]
subOUT.append(rec.X)
subOUT.append(rec.Y)
subOUT.append(rec.Width)
subOUT.append(rec.Height)
OUT.append(subOUT)
- Transpose the output of the Python node from the previous step. This creates 4 lists, each representing X,Y, Width, and Height for each rectangle.
- Using Code Block, we organize the data into a structure that accommodates the Rectangle.ByCornerPoints node (code below).
recData;
x0=List.GetItemAtIndex(recData,0);
y0=List.GetItemAtIndex(recData,1);
width=List.GetItemAtIndex(recData,2);
height=List.GetItemAtIndex(recData,3);
x1=x0+width;
y1=y0+height;
p0=Autodesk.Point.ByCoordinates(x0,y0);
p1=Autodesk.Point.ByCoordinates(x0,y1);
p2=Autodesk.Point.ByCoordinates(x1,y1);
p3=Autodesk.Point.ByCoordinates(x1,y0);
Zooming out, we have an array of rectangles representing the white squares in the image. Through programming, we've done something (roughly) similar to a live trace in Illustrator!
We still need some cleanup, however. Zooming in, we can see that we have a bunch of small, unwanted rectangles.
- We get rid of the unwanted rectangles by inserting a Python node in between the GetObjectRectangles node and another Python node. The node's code is below, and removes all rectangles which are below a given size.
rectangles=IN[0]
OUT=[]
for rec in rectangles:
if rec.Width>8 and rec.Height>8:
OUT.append(rec)
With the superfluous rectangles gone, just for kicks, let's create a surface from these rectangles and extrude them by a distance based on their areas.
- Last, change the both_sides input to false and we get an extrusion in one direction. Dip this baby in resin and you've got yourself one super nerdy table.
These are basic examples, but the concepts outlined here are transferable to exciting real-world applications. Computer vision can be used for a whole host of processes. To name a few: barcode readers, perspective matching, projection mapping, and augmented reality. For more advanced topics with AForge related to this exercise, have a read through this article.


Recipe was added.
Title is required.
Servings number is required.
Description is required.
Ingredient name is required.
Ingredient quantity is required.
Ingredient quantity value is required.(Add kg or l or psc)


@(Path can contain absolute path in the form: ~/path/to/database/)
@(If you want to disconnect this setup interface for everyone with the token, check the control below. However, be careful because you won't be able to change anything for this OpenDB instance.).
@(Disconnect the setup interface)
@(Setup token)
@(Generate token). @(Setup token is important for access to the OpenDB setup).
@(A transation log saves all operations into the log file for each database with except FileStorage)
@(Enable a transation log file)
@(Log all requests)
@(TMS allows you to subscribe insert, update, modify and upload operations in this OpenDB instance). @(For more information follow:) @(TMS documentation).
@(Secret key)
@(Generate token)
@(Endpoint for the Total.js Message Service app will be in the form )


{% extends 'base.html' %} {% block main %} Not Found Sorry, this page does not exist. {% endblock %}
Sorry, this page does not exist.


Hello
I want to use a Raspberry Pi with EmonCMS to monitor my electrical consumption.
I don't want to use an external HDD (like this tuto : http://emoncms.org/site/docs/raspberrypihdd)
Is it possible ?
And how to do this ?
Today, I have web server + MySQL on the Pi. I use teleinfo to extract datas of my electric meter.
Re: Raspberry Pi + EmonCMS ??
The read only gateway forwarder should do exactly what you want
http://emoncms.org/site/docs/raspberrypigateway
These are pre built so card image available for download and we sell ready to go sd cards in the shop
Re: Raspberry Pi + EmonCMS ??
Thank you for your answer glyn :)
With this solution, is it possible to save datas in SQL table (SD card) and send this datas to EmonCMS ?
Re: Raspberry Pi + EmonCMS ??
No, the reason for this read-only file system on the SD card solution is that we found that logging data to the SD card 24/7 caused the card to fail after about 3 months hence the move to a HDD solution for users who want to log data locally. This blog post should explain http://openenergymonitor.blogspot.com/2013/12/setup-emoncms-on-raspberrypi-with-hard.html
Re: Raspberry Pi + EmonCMS ??
Ok, it's true.
So with your solution (OEMGateway), the datas are sent directly to EmonCMS and I can monitor my consumption with graph ?
But I don't know how EmonCMS works exactly. I don't find any tuto...
Re: Raspberry Pi + EmonCMS ??
Go to the EmonCMS website, click "Guide". Then look under "Using emoncms".
When you send your data to emonCMS (you must create an account, get your APIkey from Input Help and set that in your Raspberry PI to give it permission to write into the database) "Inputs" are created automatically. You can then process the data (say convert °C to °F, or Power to kWh) and send it to a "Feed". A "Feed" is stored in the database and you can then draw a graph from that.
Re: Raspberry Pi + EmonCMS ??
Thanks you, it's ok now, I can connect to EmonCMS with my Raspberry Pi.
How to send data automatically from my teleinfo (USB) to EmonCMS ?
I use script to save data to my Database.
Re: Raspberry Pi + EmonCMS ??
Is it possible to use emoncms.org url in my PHP script to send data ? (URL with datas + key)
Re: Raspberry Pi + EmonCMS ??
Not sure I understand the question, but in emoncms.org, go to the "inputs" page and see "API help" link.
Re: Raspberry Pi + EmonCMS ??
I've a PHP script which save energy data from my electric meter to my SQL database. Now, I want to send these datas to emonCMS.org.
I have the link in "API help", it works when I click on it.
But I want to use it in my PHP script.
Is it possible to do this ?
Re: Raspberry Pi + EmonCMS ??
The examples provided in the API help page should help you create appropriate http requests in your PHP script to send the data to emoncms.org.
Re: Raspberry Pi + EmonCMS ??
Thank you for your answer jerôme.
I can use this URL : http://emoncms.org/input/post.json?json={power:200}&apikey=*****************************
But, how can I send many datas ? (like power, intensity,...)
It's necessary to use many URL for all datas or can I put all datas in one URL ?
Re: Raspberry Pi + EmonCMS ??
The API Help page shows JSON, CSV and bulk data formats. You might find that a search engine will help you to find more information about the first two.
You can easily type in your web browser a string that you think might work and test it, before writing it into your script.
Re: Raspberry Pi + EmonCMS ??
Yes I know Robert, but I don't know how to put many variable in URL with JSON...
I look for it...
Re: Raspberry Pi + EmonCMS ??
Form a bash script you could use curl this way, on a single line:
curl http://emoncms.org/input/post.json?time=1396607593.66&node=0&json={RaspberryPi:ADCO:0**********,OPTARIF:2,ISOUSC:45,HCHC:006611999,HCHP:009297403,PTEC:1,IINST:002,IMAX:045,PAPP:00390,HHPHC:3,MOTDETAT:000000}&apikey=e1***************
where *** are specific to your data, api keys and so on.
Note that:


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/chain.20rule.html ---
I have this chain rule proof in https://github.com/PatrickMassot/lean-differential-topology/blob/master/src/calculus.lean which 100 lines long. And @Assia Mahboubi tells me https://github.com/math-comp/analysis/blob/6b36593f4a6a612212163b25c6bad3522c7fa679/derive.v#L494
What is the miracle here? Is it proving stuff about o and O notations?
I don't know anything about that proof in particular, but what I have noticed is that it's good practice to never prove too much in one go, and extract as many lemmas as possible.
Stuff like add_halves
, and exists_forall_ge_and
are the sorts of things Mario has extracted, when a pattern comes up very often
Some of it is just style to make things shorter, for example, if D
and D'
were moved after the :
, the first seven lines of the proof could be shortened to
λ ⟨cont_lin_l, ε, TEf, lim_ε⟩ ⟨cont_lin_P, η, TEg, lim_η⟩, let cont_linPL := is_bounded_linear_map.comp cont_lin_L cont_lin_P in ⟨cont_linPL, begin ...
unfold is_differential
is probably unnecessary as split
does that for you
lines 78 to 85 could be moved into a couple of lines in term mode, possibly even without the simp
s at the start, if all they do is unfold definitional equalities
simp [δ], simp [H]
, can probably be shortened to simp [δ, H]
Also the lines of calc could possibly be shortened to one line of rw or simp, when it's just equality that needs to be proved.
My experience is that you really have to pay attention to matters of style like this if you make a mathlib PR
The reason Assia's proof is so short is because almost all the work is in the previous lemma dcomp
(and possibly also compOo_eqo
)
I understand that some stuff is split into several lemmas, but it still doesn't seem to be 100 lines long
It might be one of those "the whole is more than the sum of its parts" situation. It's surprising sometimes how much you shrink your code by choosing abstract interfaces between components.
@Chris Hughes thank you for your comments. I agree about the first seven lines, although I'm not sure it improves readability. I thought about simplifying simp [δ], simp [H]
to simp [δ, H]
but it doesn't work. The calc lines are compressed as much as I could: I could get it to worked when skipping any step.
Hello everyone.
I am the author of the proof Assia told you about. All in all, my proof is also 100 lines long if you take into account the lemmas I had to prove for this:
- linear_lipschitz
and its consequence linear_eqO
to state that a continuous linear function is a O(id) at 0
- the two composition rules for O(id) and o(id) at 0: compOo_eqo
and compoO_eqo
.
The remaining is just manipulation of asymptotic expansions. No miracle in here :-)
linear_lipschitz
is not included in my version, it is in https://github.com/PatrickMassot/lean-differential-topology/blob/master/src/continuous_linear_maps.lean#L116
I don't know if Assia gave you the context though: I'm not a all an expert in Lean or any other proof assistant, I'm a regular mathematician would fancies trying proof assistants and started three months ago
I was interested in understanding what kind of support for o and O you managed to setup. But it's very hard for me to read Coq, especially SSReflect style
Can you do computations with o and O floating around in the middle of formulas?
Or only state as an hypothesis or conclusion that f = o(g)?
We have rewriting rules for o and O so we can indeed manipulate such expressions.
Arggg, I'm required for more serious stuff. I'm on vacations and it's time to go skiing with my daughters (I can no longer follow my 10 years old son but I'm still a God skier to my 4 and 7 years old daughters). I will very carefully read whatever you'll write when I'll come back
In order to prove that f = o(g) we have two possibilities:
- go back to the definition of o(g), that's what I do for compOo_eqo
for instance
- use rewriting rules to change the goal into o(g) = o(g).
Our notation for o(g) hides a function, which has the property to be a o(g). So the goal f = o(g) is an equality between two functions and after using rewriting rules the goal o(g) = o(g) is an equality between functions too. These can be different so we have a mean to replace the hidden function in f = o(g) with an existential variable so that unification will close the goal o(g) = o(g).
We have a draft paper here about this: https://hal.inria.fr/hal-01719918
Nice! :heart_eyes: @Mario Carneiro please, please, please, can we have this little-o and big-O magic in mathlib?
@Cyril Cohen @Damien Rouhling I would be a very nice way to learn Lean to translate this to Lean. I'm sure you understand that your goal of having asymptotic reasoning that looks natural to mathematicians is completely blocked by shortcomings of Coq notations. With Lean you could have much more natural notations
Where is Johannes? It seems he didn't come from Gitter to here. He should see this.
@Patrick Massot in this case Coq notations are not "blocking" because we hack around the shortcommings.
Most of the "magic" of our little-o and big-O notation happen in the use of existential variables to delay their instantiation until a stage where they appear in the goal. And of course in splitting the proof into the parts that depend only in little-o/big-O arithmetic and parts that depend only on linearity.
I think you are so much used to SSReflect notations that can't see how weird they look
Have you seen the calc
blocks in my proof? This looks like mathematics to a mathematician eyes
I agree about delayed existential. The definition of delta very early in my proof is clearly the weirdest aspect for a mathematician
https://github.com/PatrickMassot/lean-differential-topology/blob/master/src/calculus.lean#L41 and https://github.com/PatrickMassot/lean-differential-topology/blob/master/src/continuous_linear_maps.lean#L129 completely kill the illusion of being doing maths
I see your calc
, that's what the mathematician should see, but do you like to explain line by line the new members of your equalities? Personally I prefer giving fewer explicit terms, and more unambiguous instructions... and letting the proof assistant show me where I am,... is it not a matter of taste?
How the notation f = g + o (e) looks exactly is another debate IMHO, and I think you are right, Coq gets in the way to get the most readable notation possible...
But @^~_ @ F
from line 38 of your paper...
https://github.com/PatrickMassot/lean-differential-topology/blob/master/src/calculus.lean#L41 and https://github.com/PatrickMassot/lean-differential-topology/blob/master/src/continuous_linear_maps.lean#L129 completely kill the illusion of being doing maths
I am happy to hear you say this, and this is exactly the point of the above mentioned code and paper.
Yes I understand, here my :heart_eyes: reaction
But
@^~_ @ F
from line 38 of your paper...
...looks cryptic... I realize that now. Is it that bad?
I didn't know you could embed Perl into Coq!
bad -> difficult to read
Be careful what you say around Coq people. Next thing you know there's "Cerl" or "Peroq".
In Lean you could write "bad → difficult to read". Unicode symbols is the default option
No ascii art notation
...looks cryptic... I realize that now. Is it that bad?
It's not much worse than g => /=.
But even removing SSReflect from the discussion, in Lean you could replace \forall k \near +oo, \forall x \near F, ‘|[f x]| <= k * ‘|[g x]|.
by
∀ k near +∞, ∀ x near F, |f x| ≤ k*|g x|
. I'm sorry I'm totally incompetent at discussing anything deep in dependent type theory, I only tell you what an average mathematician sees when starting using a proof assistant.
And my kids need me again (nap time ended), sorry
I can totally agree with your last remark.
Maybe mathematicians will never use proof assistants, I don't know. But I'm 100% sure they will never use a proof assistant using alien notations
Coq notation system makes us take solutions that are not satisfactory.
(the debate about => /=
and @~_
and "Cerl" and "Peroq" is totally different)
I don't know if Coq can be "fixed" or if you should switch to Lean to get nice notations (and I have no idea about deeper reasons to choose one or the other). But I can tell you that notations (and the awesomeness of Theorem proving in Lean) is what made me start using Lean instead of Coq (remember I have no CS training at all)
And now I really have to go. See you!
(the difference is in your last example the symbols correspond to usual mathematical practice, and in the "Cerl" criticism symbols that are introduced by programs or proof scripts, and both suffer from the lack of expressivness of Coq notation system)
@Patrick Massot see you later
I love SSreflect notation! I think ever since APL they've been building resistance in CS people to horrible notation (to the point where conciseness looks strangely appealing).
Cyril showed me the near
tactics at the TYPES meeting in Nijmegen a month ago. And indeed, they looks very nice! Modulo ssreflect which I still can't read :)
Would it be an awful lot of work to adapt this to Lean and have them in mathlib?
I'm not sure what's the best way to do it in Lean. One way would be to introduce a new tactic mode (like the smt
or conv
modes). But all we want is to add data and hide metavariables, so that we can take care of them later.
Cyril showed me the
near
tactics at the TYPES meeting in Nijmegen a month ago. And indeed, they looks very nice! Modulo ssreflect which I still can't read :)
Hi @Johannes Hölzl ! How are you? In Nijmegen I did show you near tactics but I did not have the time to show you the little-o and big-O notations and arithmetic. I might want to take a look at that too.
Oh yes, it's on my list!
Great!
@Johannes Hölzl is today's filter commit related to the discussion in this topic?
not directly . This was a change I had flying around since a couple of month. But I implemented filter_upwards
when @Cyril Cohen showed me his filter-tactics. It is a much simpler implementation, its what is available in Isabelle.
For a goal of the form s \in f.sets
and terms for h1 : t1 \in f.sets
... hn : tn \in f.sets
one gets the new goal:
\forall x, x \in t1 -> .. -> x \in tn -> x \in s
(I will add this as docstring)
Ok, thanks. Do you think you'll try to adapt the full thing at some point? Or is it too much work for something which wouldn't be new (hence not publishable)?
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Loading...
MENU
Home
Home - 1
Home - 2
Home - 3
About
Portfolio
Pages
404
About
Career
Coming Soon
Contact
Faq
Portfolio
Pricing
Service
Team
Testimonial
Contact
Home
Home - 1
Home - 2
Home - 3
About
Portfolio
Pages
404
About
Career
Coming Soon
Contact
Faq
Portfolio
Pricing
Service
Team
Testimonial
Contact
Our Work
Malesuada fames ac turpis egestas. Vestibulum tortor quam, feugiat vitae.
Show All
Ceramics
Branding
Design
Photography
View Case Studie
The Back ChiroPractor
Ceramics, Design
View Case Studie
The Back ChiroPractor
Ceramics, Design
View Case Studie
The Back ChiroPractor
Ceramics, Design
View Case Studie
The Back ChiroPractor
Ceramics, Design
View Case Studie
The Back ChiroPractor
Ceramics, Design
View Case Studie
The Back ChiroPractor
Ceramics, Design


| Ben Trevett | Home | GitHub | Twitter |
2022-07-24
Of course, like almost everybody, I stopped posting on a regular basis for various reasons. Life finds a way (to get in the way). On a related note: I didn’t think Jurassic World 3 was as bad as reviewers say. Sure, it wasn’t great, but a 38 on metacritic?!
Anyway, picking up on where we left off. I did lots of tweaks on this site recently because that gave me the feeling like I’m doing something, even though it’s the equivalent of just sweeping dust from one corner of the room to the other. I added dates to the posts because it feels weird to have someone go through the posts and have no indication when they were published. I also did some shuffling about of the posts section on the main page – combining both the weak links and other posts together into a reverse chronological list, removing the short descriptions and replacing them with tags.
One thing I’d like to add is an RSS feed, because I haven’t done one before.
I seriously considered moving the posts to bearblog. It fits with my ethos of a very minimal blog with no fluff, and also upgrading to premium is a small one-off fee instead of a monthly subscription. However, I like having my posts and site to have a coherent theme, and I like tweaking things myself – it at least teaches me a little bit of HTML and CSS.
The only subscriptions I have are:
That already feels a lot to me. I don’t understand how anyone could justify a subscription to a weather app. It just seems absurd.
I recently found out about test time augmentation (TTA), in which you apply augmentations not only when training, but also when evaluating on the validation/test sets. When applying TTA, you average the predictions across each augmentation to make your final prediction.
It seems to be effective for computer vision (I first read about it in Jeremy Howard’s Kaggle tutorials), and there is some research in applying it to text.
The way I used to “save” interesting articles (which I didn’t have time to go through in detail) I found on my phone was by screenshotting them. Then, once a week or so, I would go through my screenshots, actually read the articles and add them to my notes. If I found an article while on my desktop I’d bookmark them to an “Inbox” folder, and do the same thing. There was this mismatch between having lots of screenshots and bookmarks, and having them in two separate places didn’t sit right with me.
I came across raindrop which is a bookmark manager. On my phone I can “share” to raindrop, and on the desktop there’s an extension which adds things to raindrop. Now all my saved articles are all in one place. Of course, having the time to actually go through these articles is another story, and usually most of the saved articles I come back to I’ve later found that I have no interest in actually reading anymore.
I moved all my notes from Obsidian (a stand-alone Electron app) to Dendron (a Visual Studio Code extension). I didn’t really use many of the features of Obsidian – e.g. extensions – and I spent most of my time in Visual Studio Code anyway.
I do still think the personal knowledge management (PKM) fad is a lot of false productivity, i.e. a lot of time organizing notes is just pointless busywork. But I do like writing notes, even if I never go back to them. I find it useful to write something down as if I were explaining it to someone else as it helps me clarify my understanding of a subject.
| Home | Top |


Register
Your Name
Given Name
Looks good!
Please enter your given name.
Family Name
Looks good!
Please enter your family name.
Display Name
Looks good!
Please select a name to be displayed.
Login Information
Email
Looks good!
Please enter a valid email address.
Password
Looks good!
Please enter a valid password.
Confirm Password
Looks good!
Please confirm your password.
Address Information
Street Address
Please enter a valid street address.
Apt/Studio
Please enter a valid apt/studio number.
City
Please enter a valid city.
State
Select...
Illinois
Missouri
Please select a state.
Zip Code
Please enter a valid zipcode.
Register


A ip location server build in vue
lng: {{ result.location.lng }}
lat: {{ result.location.lat }}
address: {{ result.formatted_address }}
adcode: {{ result.addressComponent.adcode }}
sematic description: {{ result.sematic_description }}
citycode: {{ result.citycode }}
business: {{ result.business }}


Installation: SourceTree
Important Note
SourceTree is currently only available for Windows and Macintosh systems.
The creator of SourceTree, Atlassian, has openly stated they are not pursuing compatibility with
Linux-based systems.
Installation: SourceTree
SourceTree is an Atlassian product. Atlassian realized that not all of its users would be comfortable
with using the command line, so they provided a clean, graphical user interface to help users manage
repositories.
Essentially SourceTree is a desktop app that helps you use Git functionality with your repositories.
Installation: SourceTree
A Common Misconception
Visiting GitHub, Bitbucket, or other Git servers in your web browser will not allow you to clone down a copy of your repository. Bitbucket, for example, is merely an interface for viewing elements of your repository. SourceTree offers methods for cloning.
Installation: SourceTree
Download SourceTree
For Mac users, after unzipping your download, it is recommended to move the actual SourceTree
application to your Applications directory.
Installation: SourceTree
Once you complete the download and decompress the file, open the application.
If you've never used Git on your computer, you should see a registration page similar to this.
Installation: SourceTree
Atlassian may require you to create a free Bitbucket account.
(Bitbucket is their tool for repository hosting)
If you prefer another tool (e.g. GitHub, GitLab, etc.), this can be configured later. For now, just create a free account to get past this. Once you have an account, login appropriately at this screen.
Installation: SourceTree
Next, you will be asked to configure your Git identity within SourceTree.
For example, this scenario shows the infamous George P. Burdell setting his user identity.
It is important to be truthful and accurate in your user identity configuration
This is your Git configuration and marks your commits with your name and email. As an convenient option,
you may also select the checkbox to determine whether or not these credentials should be globally
applied to all repositories on your computer.
After user identity configuration...
If you connected to a server, you will be brought to the "Remote" tab by default, as this
image shows. You should be able to see all of the repositories available to you on the remote
server (i.e. the same you would see by logging into the associated website, such as GitHub or
Bitbucket).
If you did not connect to a server, you may be on the Local tab with an empty repository
list.
You can see that every remote project here has a ”Clone” button to the right of it. You can use
this button to clone down repositories.
In order to successfully clone down a repository, you'll need to ensure the
security protocol
is configured correctly between your computer and the repository server.
If you have already cloned down a repository, you will see the branch that you have checked out.
We will see this shortly.
When you select "Clone", SourceTree will ask you to specify a destination path on your local
computer and a name of a directory to place it in. Typically leaving the defaults in place makes
the most sense.
Once you’ve cloned down a repository, you’re ready to get to work!
If you select the ”Local” tab, you will see any repositories that you have
(a) cloned down, or
(b) created locally and hooked into SourceTree.
Local repositories may only be local to your machine, whereas remote repositories are
guaranteed to exist on the server.
All of your local repositories -- either from cloning down or creating in isolation -- will indicate
which branch is currently checked out.
In this example, we have currently have the dev_obiwan branch checked out.
Installation: SourceTree
To view the account(s) associated with SourceTree, either (a) select the gear in the top-right corner and select “Accounts…” or (b) select Preferences from the program menu and navigate to "Accounts". Here we can see my account information. You can double-click the account to view more details.
Security Protocol
In order to securely connect to a remote server, you will need to configure the relevant security protocol.(Link will open in new tab. Click right arrow to continue.)
Disconnected Account
If at any point you select the ”Remote” tab and see a screen like this, you’ll need to ensure
your account is properly registered and connected to its associated server.
To add or view your accounts, again either select “Accounts…” from the gear in the top-right
corner or visit Preferences.
Binary Files and SourceTree
Fortunately, Git LFS is bundled with SourceTree! If you’ve installed SourceTree, Git LFS has been initialized and added to your local machine’s path.
But wait – there’s more!
(Click the right arrow to quench your suspense...)
Binary Files and SourceTree
You will also need to update the settings of the applicable repositories on their respective servers to allow for Git LFS.
Note
Applying Git LFS to existing repos will NOT retroactively apply to previous commits. This
would require rewriting history.


JsEventManagerClass(packageName: String, className: String)
packageName - The original package name of the class that have "com.artear.annotations.JsEventManager"
packageName
className - The name of the class
className


Denario applies sophisticated machine learning algorythms to historical price movements and analizes news. That allows us to build price forecast for the next 24 hours. Currently our forecast accuracy equals to 0.9785 and SE is 2.8245850332e-06
Denario is a non profitable project fully financed by its founder. Forecast charts are free forever. But precise forecasting requires more sophisticated machine learning models and more investments. If you find Denario interesting and want to see it better please support project development with BTC donation to address bellow. Thank you.
Bitcoin address 1P5tbRqCUCD25TCsauFrJf6vvYnATAwf1U