Table of Contents
The Java® programming language is a general-purpose, concurrent, class-based, object-oriented language. It is designed to be simple enough that many programmers can achieve fluency in the language. The Java programming language is related to C and C++ but is organized rather differently, with a number of aspects of C and C++ omitted and a few ideas from other languages included. It is intended to be a production language, not a research language, and so, as C. A. R. Hoare suggested in his classic paper on language design, the design has avoided including new and untested features.
The Java programming language is strongly and statically typed. This specification clearly distinguishes between the compile-time errors that can and must be detected at compile time, and those that occur at run time. Compile time normally consists of translating programs into a machine-independent byte code representation. Run-time activities include loading and linking of the classes needed to execute a program, optional machine code generation and dynamic optimization of the program, and actual program execution.
The Java programming language is a relatively
high-level language, in that details of the machine representation are
not available through the language. It includes automatic storage
management, typically using a garbage collector, to avoid the safety
problems of explicit deallocation (as in C's free
or C++'s delete
). High-performance
garbage-collected implementations can have bounded pauses to support
systems programming and real-time applications. The language does not
include any unsafe constructs, such as array accesses without index
checking, since such unsafe constructs would cause a program to behave
in an unspecified way.
The Java programming language is normally compiled to the bytecode instruction set and binary format defined in The Java Virtual Machine Specification, Java SE 8 Edition.
Chapter 2 describes grammars and the notation used to present the lexical and syntactic grammars for the language.
Chapter 3 describes the lexical structure of the Java programming language, which is based on C and C++. The language is written in the Unicode character set. It supports the writing of Unicode characters on systems that support only ASCII.
Chapter 4 describes types, values, and variables. Types are subdivided into primitive types and reference types.
The primitive types are defined
to be the same on all machines and in all implementations, and are
various sizes of two's-complement integers, single- and
double-precision IEEE 754 standard floating-point numbers, a boolean
type, and a Unicode character char
type. Values of the primitive
types do not share state.
Reference types are the class
types, the interface types, and the array types. The reference types
are implemented by dynamically created objects that are either
instances of classes or arrays. Many references to each object can
exist. All objects (including arrays) support the methods of the class
Object
, which is the (single) root of the class hierarchy. A
predefined String
class supports Unicode character strings. Classes
exist for wrapping primitive values inside of objects. In many cases,
wrapping and unwrapping is performed automatically by the compiler (in
which case, wrapping is called boxing, and unwrapping is called
unboxing). Class and interface declarations may be generic, that is,
they may be parameterized by other reference types. Such declarations
may then be invoked with specific type arguments.
Variables are typed storage
locations. A variable of a primitive type holds a value of that exact
primitive type. A variable of a class type can hold a null reference
or a reference to an object whose type is that class type or any
subclass of that class type. A variable of an interface type can hold
a null reference or a reference to an instance of any class that
implements the interface. A variable of an array type can hold a null
reference or a reference to an array. A variable of class type
Object
can hold a null reference or a reference to any object,
whether class instance or array.
Chapter 5 describes conversions and numeric promotions. Conversions change the compile-time type and, sometimes, the value of an expression. These conversions include the boxing and unboxing conversions between primitive types and reference types. Numeric promotions are used to convert the operands of a numeric operator to a common type where an operation can be performed. There are no loopholes in the language; casts on reference types are checked at run time to ensure type safety.
Chapter 6 describes declarations and names, and how to determine what names mean (denote). The language does not require types or their members to be declared before they are used. Declaration order is significant only for local variables, local classes, and the order of initializers of fields in a class or interface.
The Java programming language provides control over the scope of names and supports limitations on external access to members of packages, classes, and interfaces. This helps in writing large programs by distinguishing the implementation of a type from its users and those who extend it. Recommended naming conventions that make for more readable programs are described here.
Chapter 7 describes the structure of a program, which is organized into packages similar to the modules of Modula. The members of a package are classes, interfaces, and subpackages. Packages are divided into compilation units. Compilation units contain type declarations and can import types from other packages to give them short names. Packages have names in a hierarchical name space, and the Internet domain name system can usually be used to form unique package names.
Chapter 8 describes
classes. The members of classes are classes, interfaces, fields
(variables) and methods. Class variables exist once per class. Class
methods operate without reference to a specific object. Instance
variables are dynamically created in objects that are instances of
classes. Instance methods are invoked on instances of classes; such
instances become the current object this
during their execution,
supporting the object-oriented programming style.
Classes support single
implementation inheritance, in which the implementation of each class
is derived from that of a single superclass, and ultimately from the
class Object
. Variables of a class type can reference an instance of
that class or of any subclass of that class, allowing new types to be
used with existing methods, polymorphically.
Classes support concurrent
programming with synchronized
methods. Methods declare the checked
exceptions that can arise from their execution, which allows
compile-time checking to ensure that exceptional conditions are
handled. Objects can declare a finalize
method that
will be invoked before the objects are discarded by the garbage
collector, allowing the objects to clean up their state.
For simplicity, the language has neither declaration "headers" separate from the implementation of a class nor separate type and class hierarchies.
A special form of classes, enums, support the definition of small sets of values and their manipulation in a type safe manner. Unlike enumerations in other languages, enums are objects and may have their own methods.
Chapter 9 describes interface types, which declare a set of abstract methods, member types, and constants. Classes that are otherwise unrelated can implement the same interface type. A variable of an interface type can contain a reference to any object that implements the interface. Multiple interface inheritance is supported.
Annotation types are specialized interfaces used to annotate declarations. Such annotations are not permitted to affect the semantics of programs in the Java programming language in any way. However, they provide useful input to various tools.
Chapter 10 describes
arrays. Array accesses include bounds checking. Arrays are dynamically
created objects and may be assigned to variables of type Object
. The
language supports arrays of arrays, rather than multidimensional
arrays.
Chapter 11 describes
exceptions, which are nonresuming and fully integrated with the
language semantics and concurrency mechanisms. There are three kinds
of exceptions: checked exceptions, run-time exceptions, and
errors. The compiler ensures that checked exceptions are properly
handled by requiring that a method or constructor can result in a
checked exception only if the method or constructor declares it. This
provides compile-time checking that exception handlers exist, and aids
programming in the large. Most user-defined exceptions should be
checked exceptions. Invalid operations in the program detected by the
Java Virtual Machine result in run-time exceptions, such as NullPointerException
. Errors result from
failures detected by the Java Virtual Machine, such as OutOfMemoryError
. Most
simple programs
do not try to handle errors.
Chapter 12 describes activities that occur during execution of a program. A program is normally stored as binary files representing compiled classes and interfaces. These binary files can be loaded into a Java Virtual Machine, linked to other classes and interfaces, and initialized.
After initialization, class methods and class variables may be used. Some classes may be instantiated to create new objects of the class type. Objects that are class instances also contain an instance of each superclass of the class, and object creation involves recursive creation of these superclass instances.
When an object is no longer referenced, it may be reclaimed by the garbage collector. If an object declares a finalizer, the finalizer is executed before the object is reclaimed to give the object a last chance to clean up resources that would not otherwise be released. When a class is no longer needed, it may be unloaded.
Chapter 13 describes binary compatibility, specifying the impact of changes to types on other types that use the changed types but have not been recompiled. These considerations are of interest to developers of types that are to be widely distributed, in a continuing series of versions, often through the Internet. Good program development environments automatically recompile dependent code whenever a type is changed, so most programmers need not be concerned about these details.
Chapter 14 describes blocks and
statements, which are based on C and C++. The language has
no goto
statement, but includes labeled break
and
continue
statements. Unlike C, the Java programming language requires boolean
(or
Boolean
) expressions in control-flow statements, and does not
convert types to boolean
implicitly (except through unboxing), in
the hope of catching more errors at compile time. A synchronized
statement provides basic object-level monitor locking. A try
statement can include catch
and finally
clauses to
protect against
non-local control transfers.
Chapter 15 describes expressions. This document fully specifies the (apparent) order of evaluation of expressions, for increased determinism and portability. Overloaded methods and constructors are resolved at compile time by picking the most specific method or constructor from those which are applicable.
Chapter 16 describes the precise way in which the language ensures that local variables are definitely set before use. While all other variables are automatically initialized to a default value, the Java programming language does not automatically initialize local variables in order to avoid masking programming errors.
Chapter 17 describes the semantics of threads and locks, which are based on the monitor-based concurrency originally introduced with the Mesa programming language. The Java programming language specifies a memory model for shared-memory multiprocessors that supports high-performance implementations.
Chapter 18 describes a variety of type inference algorithms used to test applicability of generic methods and to infer types in a generic method invocation.
Most of the example programs given in the text are ready to be executed and are similar in form to:
class Test { public static void main(String[] args) { for (int i = 0; i < args.length; i++) System.out.print(i == 0 ? args[i] : " " + args[i]); System.out.println(); } }
On a machine with the Oracle
JDK installed, this class, stored in the
file Test.java
, can be compiled and executed by
giving the commands:
javac Test.java java Test Hello, world.
Hello, world.
Throughout this specification
we refer to classes and interfaces drawn from the Java SE platform
API. Whenever we refer to a class or interface (other than those
declared in an example) using a single
identifier N, the intended reference is to the
class or interface named N in the package
java.lang
. We use the canonical name (§6.7)
for
classes or interfaces from packages other than java.lang
.
Non-normative information, designed to clarify the specification, is given in smaller, indented text.
This is non-normative information. It provides intuition, rationale, advice, examples, etc.
The type system of the Java programming language occasionally relies
on
the notion of a substitution. The notation
[F1:=T1,...,Fn:=Tn]
denotes
substitution of
Fi by Ti for 1 ≤ i ≤ n.
As noted above, this
specification often refers to classes of the Java SE platform API. In
particular, some classes have a special relationship with the
Java programming language. Examples include classes such as Object
, Class
,
ClassLoader
, String
, Thread
, and the classes and interfaces in
package java.lang.reflect
, among others. This specification constrains
the behavior of such classes and interfaces, but does not provide a
complete specification for them. The reader is referred to the
Java SE platform API documentation.
Consequently, this
specification does not describe reflection in any detail. Many
linguistic constructs have analogs in the Core Reflection API
(java.lang.reflect
) and the Language Model API
(javax.lang.model
), but these are generally not
discussed here. For example, when we list the ways in which an object
can be created, we generally do not include the ways in which the Core
Reflection API can accomplish this. Readers should be aware of these
additional mechanisms even though they are not mentioned in the
text.
Readers are invited to report
technical errors and ambiguities in The Java®
Language Specification
to<EMAIL_ADDRESS>.
Questions concerning the
behavior of javac
(the reference compiler for the
Java programming language), and in particular its conformance to this specification,
may be sent to<EMAIL_ADDRESS>.
Apple Computer. Dylan Reference Manual. Apple Computer Inc., Cupertino, California. September 29, 1995.
Bobrow, Daniel G., Linda G. DeMichiel, Richard P. Gabriel, Sonya E. Keene, Gregor Kiczales, and David A. Moon. Common Lisp Object System Specification, X3J13 Document 88-002R, June 1988; appears as Chapter 28 of Steele, Guy. Common Lisp: The Language, 2nd ed. Digital Press, 1990, ISBN 1-55558-041-6, 770-864.
Ellis, Margaret A., and Bjarne Stroustrup. The Annotated C++ Reference Manual. Addison-Wesley, Reading, Massachusetts, 1990, reprinted with corrections October 1992, ISBN 0-201-51459-1.
Goldberg, Adele and Robson, David. Smalltalk-80: The Language. Addison-Wesley, Reading, Massachusetts, 1989, ISBN 0-201-13688-0.
Hoare, C. A. R. Hints on Programming Language Design. Stanford University Computer Science Department Technical Report No. CS-73-403, December 1973. Reprinted in SIGACT/SIGPLAN Symposium on Principles of Programming Languages. Association for Computing Machinery, New York, October 1973.
IEEE Standard for Binary Floating-Point Arithmetic. ANSI/IEEE Std. 754-1985. Available from Global Engineering Documents, 15 Inverness Way East, Englewood, Colorado 80112-5704 USA;<PHONE_NUMBER>.
Kernighan, Brian W., and Dennis M. Ritchie. The C Programming Language, 2nd ed. Prentice Hall, Englewood Cliffs, New Jersey, 1988, ISBN 0-13-110362-8.
Madsen, Ole Lehrmann, Birger Møller-Pedersen, and Kristen Nygaard. Object-Oriented Programming in the Beta Programming Language. Addison-Wesley, Reading, Massachusetts, 1993, ISBN 0-201-62430-3.
Mitchell, James G., William Maybury, and Richard Sweet. The Mesa Programming Language, Version 5.0. Xerox PARC, Palo Alto, California, CSL 79-3, April 1979.


Here you will find various rants about my DevBootcamp experience from technical topics to cultural innuendos.
blog


The MusEEG package is a Python package containing useful classes that aid developers in preprocessing and classifying EEG data, creating MIDI objects, instantiating an OSC client, and designing a Brain-Computer Music Interface that allows a user to trigger MIDI events and OSC messages from performing facial expressions. The MusEEG project is available as an open-source package and can be downloaded from its GitHub repository1.
Regarding Open Source Privacy Concerns
Due to the open-source, train-it yourself nature of the MusEEG project, a particular subject’s EEG data is handled by only the subject himself, as it is advised that the neural network model is trained for a single individual only for higher classification accuracy. In order for a user to create their own personalized neural network model, the user must first download the MusEEG package from GitHub to their personal computer. The MusEEG eegData module’s training methods facilitate the data collection process, organizing and labeling the training data into processing chunks inside the MusEEG directory. The processed and labeled training data is then used to create and train a new neural network model customized to the user’s training data, which will also be stored inside the MusEEG directory. It should be noted that all of the EEG data acquired by the user is processed and saved inside the user’s local MusEEG directory and is never uploaded to the web. Thus, each user’s EEG data and trained neural network models reside inside the same user’s computer, and are never shared, accessed, or viewed by any other subject without the original user’s consent and deliberate intent.
Demo Application
The demo application was created as a static proof-of-concept that provides a demonstration of the basic functionality of the MusEEG package. In short, the MusEEG demo application lets the user perform the following actions:
-
Create a MIDI chord dictionary by entering note names next to the desired facial expression.
-
Load a pre-recorded facial expression sample from the dataset.
-
Process the pre-recorded sample using wavelet decomposition as well as perform the statistical moments calculation.
-
Classify the pre-recorded facial expression sample using the bigBrain classifier.
-
Refer the resulting facial expression from the classification result to its corresponding chord in the MIDI dictionary.
-
Send the MIDI event to a virtual MIDI port with a set of music-related control parameters (arpeggiation, tempo, sustain duration, arpeggio note duration).
The Facial Expression Buttons and Chord Dictionary
The top left corner of the demo application allows the user to load a random sample from the existing facial expression dataset by pressing on one of the facial expression buttons. Once loaded, the 14-channel raw EEG signal will be plotted in the plot box. Next to each facial expression button is a text entry field that allows the user to define the set of notes that will be played when the facial expression is sent to the main processor. Note: whenever the user changes notes in the chord dictionary, the update chord dictionary button must be pressed in order for the changes to take effect.
Process and Send Button
The process and send button performs the following actions:\
- wavelet transform of raw EEG signal\
- statistical moment calculations of wavelet decomposition vectors\
- creates ANN input array from extracted stat moments\
- the ANN classifies the signal into either of the available facial expressions\
- the facial expression is referred to its matching chord in the chord dictionary, and a chord object is created from the matching chord\
- the playchord method is called on the chord object, sending a MIDI message according to the additional control parameters
Additional Controls
Additional controls are available for the demo app:\ • arpeggiate: if the box is checked, the chord will play in an arpeggio as opposed to vertically.\ • sustain duration: indicates how long (in quarter notes) the chord will be sustained (only applied if arpeggiate is unchecked)\ • arpeggio note duration: indicates how long (in quarter notes) each note in the arpeggio will last.\
Real-Time Processing
Two different real-time processing algorithms were designed for MusEEG. Though both use the same preprocessing and classification methods (discussed in ), their methods for segmenting the raw EEG data into analyzable chunks are distinct.
Real Time Processing with smallBrain Wake Up
A flowchart describing the real-time processing workflow using smallBrain wake up is described in (Figure 5.2).
In the client thread, a TCP client receives single EEG data packets from a live EEG stream using the EPOC+. Each packet is placed into a python queue, waiting to be retrieved by the main processing thread when requested. A copy of this queue additionally stores 128 sample buffers to be acquired by the band power processing thread.
In the main processing thread, a chunkGetter thread takes care of receiving EEG packets from the client thread and placing them into smallChunks (64 samples). A "small" ANN model (smallBrain) classifies the smallChunk into either a facial expression/no facial expression result. If a facial expression is found, a wake up call is sent to the bigBrain classifier (320 samples), where facial expression classification takes place.
The classification result is sent to a message thread, which in turn performs the predefined MIDI event indicated by the facial expression-MIDI dictionary, or sends the designated OSC message for each facial expression.
The band power processing thread takes care of retrieving 128 sample (0.5s) chunks from the client and computing band power data by using the aforementioned feature extraction algorithm. Band power values are then sent as OSC messages, where they can be used as musical control parameters in a sound processing application such as Max/MSP or SuperCollider.
Real Time Processing with Rising Edge Wake Up
A flowchart for this real-time processing algorithm is provided in (Figure 5.4). This is the algorithm implemented in the current release of the MusEEG app, as it provides a less error-prone approach to segmenting facial expressions into analyzable chunks.
In this algorithm, the client, band power and MIDI/OSC message threads remain the same as the previous algorithm, while the main processsing thread proposes a simpler approach.
In this algorithm’s main processing thread, single raw EEG samples are retrieved from the client’s queue and compared with a threshold voltage. If the magnitude of the packet’s voltage surpasses the threshold voltage, the bigBrain classifier is woken up, where it classifies the chunk to a facial expression.
The classification result is sent to a message thread, which in turn performs the predefined MIDI event indicated by the facial expression-MIDI dictionary, or sends the designated OSC message for each facial expression.
Because the real time processor with smallBrain wake up performs a full dedicated analysis on the transient data, it is able to detect facial expressions with smaller voltage magnitudes, making it a feasible option for classification of motor imagery commands. However, this can also lead to multiple false detection results that lead to a neutral classification result from the classifier.
On the other hand, the real time processor with rising edge wake up is only able to detect facial expressions with high voltage magnitude, but it does so with more confidence. It was observed that the rising edge wake up algorithm provided more favorable results during unit testing. However, this algorithm might not perform well in MI classification systems.
Graphical User Interface
The MusEEG Graphical User Interface (GUI) (Figure 5.5) was designed to allow the user to perform the following actions:
-
select their desired EEG device (MusEEG currently supports the Emotiv EPOC+, and prerecorded .csv files),
-
open the MIDI menu, which contains a control center for modifying the MIDI messages assigned to facial expressions and the way the are performed on the system.
-
load a custom bigBrain model, and
-
view several monitoring windows for the raw EEG data, bigBrain data chunks, and average band power over all channels.
In addition, a post window prints classification results and other useful messages from the backend.
-
The MIDI Menu
MusEEG’s MIDI menu allows users to assign custom chords to facial expressions and control the way the are performed, such as:
-
save the current MIDI-facial expression dictionary
-
load a stored MIDI-facial expression dictionary
-
set sustain duration for non-arpeggiated chords
-
arpeggiate the chord
-
(if the chord is arppegiated) scramble the arpeggio note order
-
set the number of repeats for the arpeggio pattern.
Open Sound Control
MusEEG offers a simple OSC module that wraps on top of the open-source osc4py3 library. The module introduces availability to refer user-defined OSC messages and bundles to facial expressions, and builds a client that sends said messages over a network in the message thread.
-
To access the MusEEG GitHub repository visit: https://github.com/hugofloresgarcia/MusEEG ↩


THE YARDS
Reviewed by Harvey Karten Miramax Films Director: James Gray Writer: James Gray & Matt Reeves Cast: Mark Wahlberg, Joaquin Phoenix, Charlize Theron, James Caan, Ellen Burstyn, Faye Dunaway, Andrew Davoli, Steve Lawrence, Tony Musante, Victor Argo, Tomas Milian, Robert Montano, Victor Arnold
What a fine society we'd have if people were all community minded. Usually, though, each of us acts to benefit not only himself but his immediate family and maybe best friends as well. Only after that do we look after the welfare of the greater society. This comes across as the subtext of James Gray's taut, restrained, suspenseful drama of people acting in a corrupt manner to allow their own cliques to prosper at the expense of the greater society. Filmed in New York City, particularly in the boroughs of Queens and Brooklyn, Gray's movie aptly demonstrates the backstabbing and betrayals that we all know go on in local politics. Thanks to a fine cast of celebrated performers, the script written by the director and Matt Reeves cleverly communicates this pattern of duplicity by pointing out the cynical ways that loyalties change in a moment. Given the right circumstances, your best friend can quickly become your assassin, your oppressed group can shed its airs of martyrdom to demand its own share of unscrupulously derived loot.
As the tale unfolds, we discover that Leo Handler (Mark Wahlberg) is the only good man in an extended company of family, friends, and rivals in business. After unfortunately taking a bum rap for stealing some cars, he serves part of his term and, seeking a gig to please his parole officer, he asks his uncle Frank Olchin (James Caan) for a job in a company that builds and repairs subway cars for the city of New York. Devoted to his sick mother Val (Ellen Burstyn), Leo does not have the patience to take a two-year training program in school, so he hooks up with his best friend, Willie Gutierrez (Joaquin Phoenix), who like Uncle Frank is engaged in shady dealings involving payoffs to cops and politicians. Willie, like Frank, wants only to provide the good things for the family he anticipates having with his gorgeous girl friend Erica (Charlize Theron--here with black hair to give her the appropriate ethnic look), and while he brings his pal Leo into his disreputable arrangement, he will not hesitate to sell the young man out if his own neck is on the line.
James Gray, whose previous work, "Little Odessa," portrays a hitman who is disowned by his adulterous father during a bleak Brooklyn winter, is in his element. Gray is adept at conveying the drama's melancholy atmosphere in the way he partially lights the faces of his characters as they act out their conspiracies in indoor locations and is equally competent at imparting the sensuality of a samba-loving nightclub known as Club Rio, the happy dancers bearing their upraised arms as they swing and sway to the pulsating rhythms of the night.
Part of the picture takes place in an actual subway yard, known to New Yorkers as a place so immense that fun-loving teens are able to patrol the area at night affixing their favorite graffiti to the sides of the cars. The damage is greater in this case, though, as groups of thugs hired by a company eager to procure valuable city contracts go about the business of vandalizing competing companies' work in order to discredit them.
Mark Wahlberg, whose sullen bearing anchors this generally gripping movie, is wonderfully cast--a young man who compared to those around him is almost a saint and who eventually plays Serpico in the mean streets of one of New York's outer boroughs. The friendship between him and his friend played by Phoenix is as palpable as the affection portrayed between Phoenix and Theron. Recall Phoenix's striking role as Marcus Aurelius's backstabbing Commodus in "The Gladiator" and you have an idea of how this fine actor can play the part of betrayer in his sleep. Particularly striking as well is Howard Shore's score, somber music which never needs to be pumped up, as "The Yards" is anything but the typical Hollywood slam-bam gangster melodrama that forever captures the attention of a less discerning audience.
Rated R. Running time: 115 minutes. (C) 2000 by Harvey Karten<EMAIL_ADDRESS>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


Provides logging utilities, either to the standard/error output or to a file, with multiple criticality levels.
More...
#include <Logger.hpp>
|
| enum | Domain {
OpenGL = 0,
Resources,
Input,
Utilities,
Config
} |
| | Domain prefix that will be appended before a line.
|
| |
|
|
const std::vector< std::string > | _domainStrings = {"OpenGL", "Resources", "Input", "Utilities", "Config"} |
| | Domain prefix strings.
|
| |
|
const std::vector< std::string > | _levelStrings = {"", "(!) ", "(X) ", ""} |
| | Levels prefix strings.
|
| |
|
const std::vector< std::string > | _colorStrings = {"\x1B[0m\x1B[39m", "\x1B[0m\x1B[33m", "\x1B[0m\x1B[31m", "\x1B[2m\x1B[37m"} |
| | Colors prefix strings.
|
| |
|
Level | _level = Level::INFO |
| | The current criticality level.
|
| |
|
bool | _logToStdOut = true |
| | Should the logs be output to standard output.
|
| |
|
std::ofstream | _file |
| | The output log file stream.
|
| |
|
std::stringstream | _stream |
| | Internal log string stream.
|
| |
|
bool | _verbose = false |
| | Is the logger verbose.
|
| |
|
bool | _ignoreUntilFlush = false |
| | Internal flag to ignore the current line if it is verbose.
|
| |
|
bool | _appendPrefix = false |
| | Should a domain or level prefix be appended to the current line.
|
| |
|
bool | _useColors = false |
| | Should color formatting be used.
|
| |
Provides logging utilities, either to the standard/error output or to a file, with multiple criticality levels.
◆ Level
Criticality level.
| Enumerator |
|---|
| VERBOSE | Will only be logged if verbose is enabled.
|
◆ Log() [1/2]
Default constructor, will use standard output
◆ Log() [2/2]
| Log::Log |
( |
const std::string & |
filePath, |
|
|
bool |
logToStdin, |
|
|
bool |
verbose = false |
|
) |
| |
Constructor
- Parameters
-
| filePath | the file to write the logs to |
| logToStdin | should the logs also be sent to the standard output |
| verbose | should verbose messages be output |
◆ appendIfNeeded()
| void Log::appendIfNeeded |
( |
| ) |
|
|
private |
Append the current domain/level prefix if it is needed.
◆ Error()
The default logger with an "Error" level.
- Returns
- itself for chaining
◆ flush()
◆ Info()
The default logger with an "Info" level.
- Returns
- itself for chaining
◆ operator<<() [1/4]
| Log & Log::operator<< |
( |
const Domain & |
domain | ) |
|
Domain stream operator
- Parameters
-
| domain | the domain to use for the next log line |
- Returns
- itself for chaining
- Note
- The domain is only applied to the incoming line.
◆ operator<<() [2/4]
template<class T >
| Log& Log::operator<< |
( |
const T & |
input | ) |
|
|
inline |
Default stream operator
- Parameters
-
- Returns
- itself for chaining
◆ operator<<() [3/4]
| Log & Log::operator<< |
( |
std::ios_base &(*)(std::ios_base &) |
modif | ) |
|
Modifier stream operator
- Parameters
-
- Returns
- itself for chaining
◆ operator<<() [4/4]
| Log & Log::operator<< |
( |
std::ostream &(*)(std::ostream &) |
modif | ) |
|
Modifier stream operator
- Parameters
-
- Returns
- itself for chaining
◆ set()
Set the criticality level.
- Parameters
-
- Note
- Level is not modified directly, but through the use of Log::Info, Log::Error, etc., mimicking std::cout and std::cerr.
◆ setDefaultFile()
| void Log::setDefaultFile |
( |
const std::string & |
filePath | ) |
|
|
static |
Set the default logger output file.
- Parameters
-
| filePath | the path to the output file |
◆ setDefaultVerbose()
| void Log::setDefaultVerbose |
( |
bool |
verbose | ) |
|
|
static |
Set the default logger verbosity.
- Parameters
-
◆ setFile()
| void Log::setFile |
( |
const std::string & |
filePath, |
|
|
bool |
flushExisting = true |
|
) |
| |
|
private |
Change the output log file.
- Parameters
-
| filePath | the file to write the logs to |
| flushExisting | should the existing unwritten messages be flushed |
◆ setVerbose()
| void Log::setVerbose |
( |
bool |
verbose | ) |
|
Set the verbosity level.
- Parameters
-
◆ Verbose()
The default logger with a verbose level.
- Returns
- itself for chaining
◆ Warning()
The default logger with a "Warning" level.
- Returns
- itself for chaining
The documentation for this class was generated from the following files:
- src/engine/system/Logger.hpp
- src/engine/system/Logger.cpp


Before you are ready to start using maquette, you need to be aware of three rules, which are all easy to follow. These rules are there to make sure maquette can generally render and diff very large pages at 60 frames per second on every device.
Changing event handlers, like onclick
for example, is rarely useful.
Updating an event handler is costly if you accidentally change them on every render.
Because this mistake that is so easy to make, maquette disallows changing event handlers completely.
If you render h('a',{href:'.',target:'_blank'})
and then you want to clear the target
attribute,
you need to use either h('a',{href:'.',target:undefined})
, h('a',{href: '.',target:null})
or
h('a',{href:'.',target:''})
.
If you use h('a',{href:'.'})
maquette will not clear the target
attribute.
This is because maquette does not sacrifice performance searching for properties that you left out.
This makes you responsible to always provide the same set of properties. The same principe applies to the nested
classes
and styles
objects.
The last rule states that if a node has multiple childnodes with the same selector and these childnodes are added or removed dynamically, then they must have unique key properties.
A key property is typically used as follows: (If you are unfamilliar with the javascript map() function see this description on MDN)
h('ul', [
items.map(function(item) {
return h('li', {key: item.id}, [item.text]);
})
])
This rule makes sure that a node is never accidentally morphed into an adjecent node and thereby doing the wrong animation or accidentally triggering a violation of one of the first two rules.


JUST IN: Man arrested over wife's lover's death - The Nation Newspaper
by https://www.facebook.com/CheerfulpraiseOsagie Otabor, Benin
Men of the Edo State Police Command have arrested one Iroghama Moshudi over the murder of one Etinosa Nowaghama aged 35.
Etinosa was reportedly shot dead on November 8, 2019 at the residence of one Happy Ikpomwosa, estranged wife of Iroghama.
It was gathered that the police arrested Iroghama because he was said to have earlier threatened to deal with the deceased.
Police sources said the woman, a mother of four, abandoned her husband for the deceased and refused all pleas to return home.
Read Also: My wife is a serial thief, divorce seeking man tells court
The threat to the deceased was said to have been reported to a traditional ruler in their area.
Edo Police spokesman, DSP Chidi Nwabuzor, who confirmed the incident, said operatives of the Ogida Police Division rushed the deceased to the hospital but he was confirmed dead on arrival.
He said investigation would unravel the killers.


SHA1
Native
Rusha
Chunksha
Chunksha worker
Reading file progress [%]
Computing hash progress [%]
Hash
Execution time [s]:
Error
HMAC SHA1
Key


Excalibur (1981) **** out of *****
Cast: Nigel Terry, Helen Mirren, Nicholas Clay, Cherie Lunghi, Paul Geoffrey, Nicol Williamson, Gabriel Byrne, Katrine Boorman, Liam Neeson, Colin Redgrave, Patrick Stewart, Charlie Boorman Written by: Rospo Pallenberg and John Boorman Based on the book "Le Morte d'Arthur" by: Thomas Malory Directed by: John Boorman Running Time: 141 minutes
I've never been a big fan of the whole "sword and sorcery" genre. Not for any particular reason mind you, it's just never help much appeal to me. As a result, I'd never even considered watching a second of John Boorman's Excalibur. Now, eighteen years after it's release comes a DVD of the film... so I decided I'd give it a shot. I'm thrilled that I did, as Excalibur is one of the best told stories I've seen in a long time.
Surely everyone is familiar in some way with the legend of King Arthur, but I doubt there's a better representation of it on film than this one. Excalibur begins as the wizard Merlin (Nicol Williamson) strikes a deal with Uther (Gabriel Byrne) to help Uther bed the woman he desires, even though it has caused war amongst the people of the land. As a result of this encounter, Arthur is born. Due to the bargain previously struck, Merlin takes young Arthur away with him.
Arthur (Nigel Terry) grows to be a man and one day, by complete random chance, pulls the mighty Excalibur from the stone in which it was thrust into by Uther years earlier. This signifies that Arthur is now king of the land. Much follows, including the rise and fall of Camelot, the introduction of the knights of the round table, meeting Lancelot (Nicholas Clay) and his subsequent affair with Arthur's wife Guenevere (Cherie Lunghi), and the battles between Merlin and Arthur's half-sister Morgana (a gorgeously young Helen Mirren).
Excalibur holds up incredibly well considering it's age... more than likely due to the incredibly compelling story. Great production values and use of music (both original score by Trevor Jones and familiar stock music from Richard Wagner and Carl Orff) compliment this experience.
Excalibur is available on DVD from Warner Home Video. It contains the film in it's original theatrical aspect ratio of 1.85:1, a commentary track with director John Boorman, a biography and filmography for Boorman, and the film's original theatrical trailer.
I'm not sure why, but I wasn't expecting much from the commentary by John Boorman. To my surprise though it was very informative. Boorman does take his time, and sometimes leaves gaps of silence between bits of information, but he's still knowledgeable about seemingly every aspect of this film. Most directors I hear do commentary about a film that they made years earlier tend to forget many of the tiny details... like actor's names for example. In those cases, directors usually bring along a director of photography or co-producer to ask questions to in order to help refresh their memory. But Boorman's there all by himself, able to identify things as detailed as every different filming location, even when they change two or three times in a single scene (unfortunately, if you've never been in Ireland you won't know where he's talking about). Boorman's commentary is also highly complimentary. He's very giving with kind words to both cast and crew.
Some interesting tidbits of info he shares: Helen Mirren and Nicol Williamson couldn't stand one another based on an event from their past, and both threatened not to do the film if they had to work with one another. Boorman was able to convince them both to do the film, and since their characters are enemies he was able to use their natural animosity towards one another for their performances. Also, Liam Neeson and Mirren had a relationship for a year or two after they met on the set.
Excalibur is a great film, and this is a great DVD to own. The transfer is great... making it hard to believe that the film is over 18 years old. If it weren't for the familiar faces in the cast you'd think this was a recent effort. If you're a fan of sword and sorcery, a Boorman fan, or just love great storytelling, get yourself a copy of this one. [R]
The Jacksonville Film Journal URL:http://users.southeast.net/~chuckd21/<EMAIL_ADDRESS>© 1999 of The Jacksonville Film Journal. No reviews may be reprinted without permission.
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


Choose an authorization server
..!..
You're already logged in. Logout before you can choose another authorization server.
Logout


Image and Vision Computing, November'14
The authors improve upon our previously proposed state-of-the-art tennis ball tracking algorithm.
Employ audio signal processing techniques to detect key events and construct features for classifying the events
Model event classification (serve, hit, bounce, net, and null) as a sequence labelling problem
Similar: Object Detection and Tracking Based on Trajectory in Broadcast Tennis Video
MITSSC'13
1. Find the factors such as location and speed of the incoming shot which are most conducive to a player hitting a winner
(i.e. “sweet-spot”) or cause an error.
2. Do “live in-point” prediction - based on the shots being played during a rally we estimate the probability of the outcome of the next shot.
WACV'14, Best Paper
CVIU, January'17
Automatic system for actions annotation in tennis video sequences for coaching needs. 3D ball trajectory reconstruction and player position detection. Strokes, serves, and bounces recognition from ball trajectory changes.
Also provides hardware architecture, processing modules to perform such analytics.
Good Reference Hunt!
ICAVSBS'13
Adapted a mono-camera detection and tracking system, originally designed for video surveillance to do sport analytics.
Extracts player trajecteries by computing homographies wrt to multiple cameras. Shows some simple statistics over it.
Neural Processing Letters, February'13
They present a semi-parametric method for the automatic segmentation of a sport video and the extraction of its dominant regions, robust to different sport scenarios, without the need of camera calibration or background extraction.
CVPR'17 (Under Review)
Proposes an alternate approach exploiting the edge information and demonstrates its success in a specific scenario of registering football broadcast video frames on the static top view model of the playing surface.
International Conference on Image Analysis and Recognition (ICIAR) '07
Classifying the different tennis strokes (Forehand, Backhand and No Shot) is the prime goal of this project.
Algorithm uses the gradient information of the player's skeleton. The player is modeled using color histogram and tracked across the video using histogram back projection. An oriented histogram of the skeleton obtained in each frame forms the feature vector which is then sent to a SVM classifier.
CVIU, March'09
Our approach combines the structure event detection method with the highlight ranking algorithm
Firstly, unsupervised shot clustering and supervised audio classification are performed to obtain the visual and audio mid-level patterns respectively. Then, a temporal voting scheme for structure event detection is proposed by utilizing the correspondence between audio and video content. Finally, by using the affective features extracted from the detected events, a linear highlight model is adopted to rank the detected events in terms of their exciting degrees.
Human evaluation for highlights.
MITSSAC'16, Best Paper
The authors show that a small set of features can be used to predict shot outcomes.
Using style priors, i.e. cluster players and forming player descriptors significantly improves performance
The handcrafted features are extracted from Hawk-eye data.
Master's Dissertation
Used Computer vision techniques to collect statistics during badminton matches. The end result is a chronological list with statistics of every stroke played in a certain rally. Those statistics include the start and end zone of the stroke and the stroke type.
Similar: Badminton shot classification in compressed video with baseline angled camera
ACM SIGKDD'13
Uses an entire football season of ball tracking data to reinforce the common held belief that teams should aim to “win home games and draw away ones”.
1. A representation of team behavior is formed by chunking spatiotemporal signal into a series of quantized bins.
2. Generated an expectation model of team behavior based on a code-book of past performance.
Expert Systems with Applications'09
Proposes the use of computational intelligence strategies and information from both the audio and video domains to automatically locate sporting highlight on personal video playback devices.
Multimedia Tools and Applications, December'14
Comparing to other set ups, the main contribution of this work lays on the utilization of an unique camera per border line to extract 3D bounce point information.
Sports Engineering, July'11
The method used records racket and ball movement in 3D, intrudes minimally into the player’s environment. The method allows accurate measurement of ball and racket speeds, impact positions, and angular velocities of the racket in three-dimensions.
Workshop on Multimedia Signal Processing'04
Designed an efficient and accurate temporal segmentation of the video into segments homogeneous w.r.t. the camera motion.
Focus on the creation of a selective summary containing the best winning serves and rallies of the match, using "applause" and "ball hit" clusters.
 The algorithm presented in this paper requires the set of all-pairs shortest paths in a directed and edge-weighted graph.
We also propose an efficient All-Pairs Shortest Path algorithm by exploiting a special topological property of the graph.
Prev: A Tennis Ball Tracking Algorithm for Automatic Annotation of Tennis Match, BMVC'05
ICIP'03
Search for highlights at places where strong excitement is evoked in the user by the content of a video. It is namely realistic to assume that independent of the type of a highlighting event, each such event induces an increase in user's excitement. They mimic the changes in user's excitement by observing the temporal behavior of domain-independent audiovisual signal properties and the editing scheme of a video.
CBMI'11
Automatically index a complete tennis match into all the main tennis events, so that a match can be recorded using affordable visual sensing equipment and then be automatically indexed into key events for retrieval and editing. The tennis events detected in this paper are a tennis game, a change of end and a tennis serve - all of which share temporal commonalities.


ContentType
public enum ContentType : String
Collection of most common values send under the Content-Type
http header key.
-
Marks the content as unspecified.
Declaration
Swift
case all = "*/*"
-
Marks the content as plain text.
Declaration
Swift
case plainText = "text/plain"
-
Marks the content as png image.
Declaration
Swift
case png = "image/png"
-
Marks the content as jpeg image.
Declaration
Swift
case jpeg = "image/jpeg"
-
Marks the content as gif image.
Declaration
Swift
case gif = "image/gif"
-
Marks the content as mutipart form data.
Declaration
Swift
case multipartForm = "multipart/form-data"
-
Marks the content as text that is in valid json format.
Declaration
Swift
case json = "application/json"
-
Marks the content as text that is in valid xml format.
Declaration
Swift
case xml = "application/xml"