ROS
I/O Package
Getting Started Guide
R2014a
Revision History
December
2013 New
for Version <IP_ADDRESS> (Release 2013b)
January
2014 Updated
for Version <IP_ADDRESS> (Release 2013b)
March 2014 Updated
for Version <IP_ADDRESS> (Release 2014a)
Table
of Contents
Installation and
Configuration
Creating a Publisher
and a Subscriber
Reassigning Message
Listener Tasks of a Subscriber.
Creating a Custom
Message Listener
Setting Up Shutdown
Tasks of a Node
ROS I/O Package is a MATLAB® extension that provides the capability to interact with Robot Operating System (ROS) from MATLAB. ROS is basically a set of libraries and tools that helps software developers create robot applications. Licensed under an open source, BSD license, ROS provides hardware abstraction, device drivers, libraries, visualizers, message-passing, package management, and others. For more information, see http://wiki.ros.org. Due to its flexibility, ROS is very popular among software developers in robotics. On the other hand, MATLAB and Simulink® are commonly used when it comes to prototyping algorithms and designs. The ability for MATLAB to interface with ROS is therefore very useful for users who want to verify their new algorithms prototyped in MATLAB along with existing software running on ROS. ROS I/O Package allows users to interact with robots and simulators that run on ROS from MATLAB directly without having to reimplement their publisher and/or subscriber nodes in Python®, C++, or Java®.
By extending the rosjava API, ROS I/O Package provides a set of new API for creating ROS nodes in MATLAB that operate and communicate based on ROS publisher/subscriber mechanism. ROS I/O Package has the following key features:
· Enable creation and removal of new nodes from MATLAB.
· Enable creation and removal of publishers from MATLAB.
· Enable creation and removal of subscribers from MATLAB.
· Enable creation of ROS messages in MATLAB.
· Enable publishers to publish MATLAB data to their advertised topics.
· Enable subscribers’ message listeners to execute arbitrary user defined MATLAB functions when applicable messages are received.
· Enable launching of ROS masters on the local host from MATLAB if none is available for connection externally.
· Support 32-bit and 64-bit Windows®.
· Support 64-bit Linux®, including Ubuntu®.
· Support 64-bit Mac OS X.
·
Operating system: Windows (32-bit and 64-bit),
Linux (64-bit only), or Mac OS X (64-bit only).
·
MATLAB R2014a, R2013b, R2013a, or R2012b.
·
Access to ROS Hydro and Gazebo is recommended
for running more examples on http://www.mathworks.com/ros.
Note:
·
Even though this guide is written specifically
for MATLAB R2014a, you may use it with any of the supported releases. However, make
sure you use the installer that matches the MATLAB release when installing ROS
I/O Package.
·
While ROS I/O Package is only tested against
ROS Hydro, it is expected to work with other ROS releases as well. However,
keep in mind that incompatibilities can exist if you apply messages that have
mismatched signatures across releases.
·
To install ROS I/O Package on MATLAB R2014a
win32, run the installer
ROSIOPackage-R2014a_v<IP_ADDRESS>_win32-Install.exe.
·
To install ROS I/O Package on MATLAB R2014a
win64, run the installer
ROSIOPackage-R2014a_v<IP_ADDRESS>_win64-Install.exe.
·
To install ROS I/O Package on MATLAB R2014a
glnxa64, run the installer
ROSIOPackage-R2014a_v<IP_ADDRESS>_glnxa64-Install.
·
To install ROS I/O Package on MATLAB R2014a
maci64, run the installer
ROSIOPackage-R2014a_v<IP_ADDRESS>_maci64-Install.
·
You will be asked to select a destination
folder for the PSP when running the installer. Select the root folder of your
MATLAB installation as the destination folder. If necessary, you can use the
MATLAB command matlabroot to
determine the root folder where MATLAB is installed.
·
Note that if ROS I/O Package is
already installed, you must first uninstall it by running the uninstaller ROSIOPackage-R2014a_v<IP_ADDRESS>_XXXXX-Uninstall.
You can find the uninstaller at matlabroot\uninstall
(e.g., C:\Program Files\MATLAB\R2014a\uninstall).
See the uninstallation instructions below.
Here are
the instructions to run the installer:
1. Double-click
ROSIOPackage-R2014a_v<IP_ADDRESS>_XXXXX-Install
to launch the installer.
2. Click Yes when the Install ROS IO Package
dialog appears.
3. When the Welcome to the InstallJammer Wizard for ROS
IO Package screen appears in the ROS IO Package Setup dialog, click Next > to start the installation
process.
4. When the License Agreement screen appears in the ROS
IO Package Setup dialog, read and then accept the license agreement by clicking
Next >.
5. When the Choose Destination Location screen
appears, click Browse to select a
destination folder. This must be the root folder of your MATLAB installation.
6. Click Next > after selecting a destination
folder.
7. When the Verifying MATLAB Directory screen
appears, click Next > to start the
release verification step.
8. The
verification result is displayed in the Verifying
MATLAB Release screen. If the selected MATLAB release matches the targeted
release, click Next >. Otherwise,
you have to return to the Choose
Destination Location screen to re-select the targeted release.
9. When the Start Copying Files screen appears, click
Next > to start file extraction.
10. The Installing screen appears after all
files are successfully copied. Click Next
> to start the configuration process. The configuration process sets up
the path so that ROS I/O Package is available for use when you launch MATLAB
next time. Because this step automatically launches MATLAB to perform path
addition, it may take a few minutes before the next screen appears.
11. When the Adding ROS IO Package to the MATLAB Path
screen appears, click Next >.
12. If the
installation is successful, you will be brought to the InstallJammer Wizard Complete screen. Click Finish to close the installer.
13. On
Windows, the Program Compatibility Assistant may appear after the installation.
You can simply click This program
installed correctly to dismiss the dialog.
When using
ROS I/O Package, you might find it helpful to know the location of related
files and folders as explained below:
·
ROS I/O Package uses folders and files located
in matlabroot\toolbox\psp\rosmatlab.
This folder contains the new API that is made available under a package named rosmatlab.
It also contains utilities for managing all related MATLAB and Java class
paths.
·
All applicable Java archive files that are
distributed through the maven artifact repository for rosjava
dependencies and builds are placed in matlabroot\toolbox\psp\rosmatlab\jars. Note that ROS I/O Package <IP_ADDRESS>
complements rosjava_core 0.1.6 (rosjava-0.1.6.jar).
Its compatibility with other versions of rosjava_core is unknown.
·
The folder matlabroot\toolbox\psp\rosmatlab\examples
contains files used for demonstrating the ROS I/O Package API. These examples
contain instructions for creating publisher and subscriber nodes in MATLAB.
FOR WINDOWS AND LINUX USERS:
An
uninstaller named ROSIOPackage-R2014a_v<IP_ADDRESS>_XXXXXUniInstall
is automatically created and placed in matlabroot\uninstall
upon a successful installation. Here are the instructions to remove ROS I/O
Package from MATLAB using the uninstaller:
1. Double-click
ROSIOPackage-R2014a_v<IP_ADDRESS>_XXXXX-Uninstall
to launch the uninstaller.
2. Click Yes when the Uninstall ROS IO Package
dialog appears.
3. When the Removing ROS IO Package from the MATLAB Path
screen appears in the ROS IO Package Setup dialog, click Next > to start the uninstallation process.
4.
If the uninstallation is successful, you will
be brought to the Uninstall Complete
screen. Click Finish to close the
uninstaller.
5. On
Windows, the Program Compatibility Assistant may appear after the uninstallation.
You can simply click This program
installed correctly to dismiss the dialog.
FOR MAC USERS:
There is
no uninstaller available for Mac. Use the following instructions to remove ROS
I/O Package from MATLAB:
1. In MATLAB,
run rosmatlab_SetPath(1) to revert
changes to the Java class path and remove ROS I/O Package from the MATLAB path.
2. Exit
MATLAB.
3. You can now
safely delete all contents in matlabroot\toolbox\psp\rosmatlab.
You can update
or add new JAR files under the rosjava distribution if necessary. To do this,
1. Download
the applicable JAR files from the maven artifact repository for rosjava
dependencies and builds.
2. Copy the
downloaded JAR files to matlabroot\toolbox\psp\rosmatlab\jars.
3. Remove JAR
files that you want to replace from matlabroot\toolbox\psp\rosmatlab\jars.
4. Run the
utility rosmatlab_AddClassPath to update
the Java class path.
5. Restart
MATLAB in order for the changes to take effect.
Keep in
mind that when you replace existing JAR files in ROS I/O Package, the risk of
incompatibility exists.
If you have
custom messages that are generated using rosjava based on the instructions
given at http://wiki.ros.org/rosjava/Tutorials/hydro/Unofficial%20Messages, you can
import them for use with ROS I/O Package. To do this,
1. Copy the
rosjava generated JAR files to matlabroot\toolbox\psp\rosmatlab\jars.
2. Run the
utility rosmatlab_AddClassPath to update
the Java class path.
3. Restart
MATLAB in order for the changes to take effect.
|
Note: Commands
used in the following example can be found in matlabroot\toolbox\psp\ |
The following example explains the basic
instructions for creating publishers and subscribers. In the example, we create
a node with a publisher and a subscriber that exchange std_msgs/String messages.
Every
ROS node must connect to a master. Assuming that there is no external master
available for connection, we have to first launch a master on the local host
before proceeding with creating a new node. Use the following command to launch
a ROS master on port 11311 on the
local host:
|
roscore =
rosmatlab.roscore(11311); |
To
see the URI of the master, enter roscore.RosMasterUri.
An attempt to launch another master on the same port will result in an error.
Note that you must assign the returned object to a handle variable in order to
keep it in memory. Otherwise, the object is automatically assigned to ans, and the object will be destroyed if
ans is reassigned.
With
a master available for connection, we are now ready to create a new node. Use
the following command to create a new node named /NODE and connect it to the master we just launched:
|
node = rosmatlab.node('NODE', roscore.RosMasterUri); |
To
see the URI of the node, enter node.Node.getUri().
Notice that the IP address of the local host has been used to construct the
URI. Also, notice that both node.Publishers
and node.Subscribers are empty in the
new node.
Next,
we will create a publisher and a subscriber that exchange messages of type std_msgs/String via a topic named /TOPIC. First, use the following command
to add a publisher to the new node:
|
publisher = rosmatlab.publisher('TOPIC', 'std_msgs/String',
node); |
Then,
use the following command to add a subscriber to the new node:
|
subscriber = rosmatlab.subscriber('TOPIC', 'std_msgs/String',
1, node); |
Notice
how the above command sets the buffer limit of the subscriber to 1. Given the queue size of one, if the message listener
processes new messages slower than they are received, the
existing message that is yet to be processed will be removed from the buffer if
a new message is received. If a subscriber is expecting messages that are
published repeatedly, we recommend setting the buffer limit to at least a
quarter of the highest frequency at which messages are received. Such a setting
minimizes chances of experiencing dropped messages. For example, to receive
messages at 100 Hz, consider using a
buffer limit of 25. Note that this
setting is particularly crucial if you are running on Windows.
In
order for the subscriber to be useful, we need to bind at least one function to
its standard message listener. This function executes when a valid message is
published to the subscribed topic. It serves the purpose of carrying out
message-driven tasks. Use the following command to set execution of a pair of
functions named function1 and function2 whenever a valid message is published
to /TOPIC:
|
subscriber.setOnNewMessageListeners({@function1,
@function2}); |
The
definitions of both function1 and function2 are given in the code snippet
below:
|
function function1(message)
disp(char(message.getData())); end function function2(message) disp(sprintf('Message received: %s',datestr(now))); end |
Note
that each function expects the received message as its sole argument. Also,
notice how function1 reads the data field of the std_msgs/String message using the getData method of the message object.
Now,
let us create a new message for use by the publisher. Use the following command
to first create a std_msgs/String
message:
|
msg = rosmatlab.message('std_msgs/String', node); |
Then
use the following command to set the data
field of the std_msgs/String message:
|
msg.setData(sprintf('Message created: %s', datestr(now))); |
Notice
how the above command writes the data
field of the std_msgs/String message
using the setData method of the
message object.
Once
a message is populated with useful data, it is ready to be published. Use the
following command to publish the message we just constructed:
|
publisher.publish(msg); |
You
should see outputs similar to the following depending on the current date and
time:
|
Message
created: dd-mmm-yyyy HH:MM:SS Message received: dd-mmm-yyyy HH:MM:SS |
|
Note: Commands
used in the following example can be found in matlabroot\toolbox\psp\ |
The
following example explains the basic instructions for reassigning and
withdrawing the functions that you want execute when a valid message is
published to the subscribed topic.
You
can reassign tasks carried out by the standard message listener by simply
binding a new set of functions using the setOnNewMessageListener
method of the subscriber. The following command replaces function1 and function2 that
were previously set with function3.
|
subscriber.setOnNewMessageListeners({@function3}); |
The
definition of function3, which
basically combines the tasks performed by both function 1 and function2
into a single function, is given in the code snippet below:
|
function function3(message)
disp([char(message.getData()), sprintf('\n Message received: %s', datestr(now))]); end |
To
test the new binding, use the following commands to update and publish the
message iteratively:
|
for i = 1:10 msg.setData(sprintf('Iteration %d:\n
Message created: %s', i, datestr(now))); publisher.publish(msg); pause(1); end |
You
can suspend the subscriber without removing it from the node by unbinding all
functions from the standard message listener. To do that, use the following
command:
|
subscriber.setOnNewMessageListeners([]); |
Without
any binding, using the following commands to update and publish the message
produces no effect:
|
msg.setData(sprintf('Message created: %s', datestr(now))); publisher.publish(msg); |
If you want to remove a publisher or a subscriber from a node, you
must use the removePublisher or removeSubscriber method of the node,
respectively. Use the following command to remove the subscriber we previously
created from the node:
|
node.removeSubscriber(subscriber); |
Verify that node.Subscribers is now empty. Notice that the variable subscriber in the workspace has been automatically deleted when you
remove the subscriber from the node. Likewise, if you remove the publisher we
previously created from the node, the variable publisher in the workspace will be automatically deleted as well.
Finally, to clean up, use the following command to delete the
variable roscore:
|
clear('roscore'); |
This command triggers a call to the destructor of the rosmatlab.roscore object. The destructor
first shuts down the master, and then destroys the object. In the process of
doing so, the destructor searches for rosmatlab.node
objects that are connected to the master for deletion. Notice that the above
command not only deletes the variable roscore
in the workspace, it also deletes the variables node, publisher, and subscriber if they still exist in the
workspace.
|
Note: Commands
used in the following example can be found in matlabroot\toolbox\psp\ |
The
following example demonstrates the use of alternative API for creating
publishers, subscribers, and messages. It also explains how you can add a
custom message listener to carry out user defined tasks when a valid message is
published to the subscribed topic. This is useful when the function that
performs the tasks expects arguments other than the message itself. In the
example, we create a node with a publisher and a subscriber that exchange geometry_msgs/Point messages.
Similar
to the previous example, we must first launch a master on the local host before
proceeding with creating a new node. Use the following command to launch a ROS
master on the local host.
|
roscore = rosmatlab.roscore(); |
Enter
roscore.RosMasterUri to return the
URI of the master. Notice that the master is launched on port 11311 by default since the port argument is omitted.
Next,
we proceed with creating a new node. Use the following command to create a new
node named /NODE and connect it to
the master we just launched:
|
node = rosmatlab.node('NODE', [], [], 'rosIP', '<IP_ADDRESS>'); |
Enter
node.Node.getUri() to return the URI
of the node. Notice that the above command uses the loopback interface to
construct the node’s URI instead of using the host’s IP address. Also, notice
that both host and port arguments are omitted in the
command. This assumes the master is running on port 11311 on localhost.
With
a new node, we can now create a publisher and a subscriber that exchange
messages of type geometry_msgs/Point
via a topic named /POINT. Use the
following commands to first add a publisher, and then a subscriber to the new
node:
|
publisher = node.addPublisher('POINT', 'geometry_msgs/Point'); subscriber = node.addSubscriber('POINT', 'geometry_msgs/Point', 10); |
Notice
how the above command sets the buffer limit of the subscriber to 10. If the message listener
processes new messages slower than they are received, existing
messages that are yet to be processed will be removed from the buffer when more
than 10 new messages are queued.
Instead
of binding a function to the subscriber’s standard message listener, let us add
a custom message listener to implement user defined tasks that execute when a
valid message is published to the subscribed topic. Use the following command
to add a custom message listener and set execution of a function named custom_function whenever a valid message
is published to /POINT:
|
subscriber.addCustomMessageListener({@custom_function,
node.Node}); |
Notice
how custom_function is set with a supplementary
argument node.Node in the above
command. We need to inspect the definition of custom_function in order to explain the syntax.
The
definition of custom_function is
given in the code snippet below:
|
function custom_function(handle, event,
node) message =
event.JavaEvent.getSource; magnitude =
norm([message.getX(), message.getY(), message.getZ()]); point = ['[', num2str(message.getX()), ',', num2str(message.getY()), ',', ... node.getLog().info(['Distance of ', point, ' from the origin is ', num2str(magnitude), '.']); end |
Note
that the function expects a node
object as a supplementary argument in addition to the standard arguments handle and event. Also, notice how custom_function
extracts the received message from the event
argument.
Now,
let us create a new message for use by the publisher. Use the following command
to first create a geometry_msgs/Point
message:
|
msg = node.newMessage('geometry_msgs/Point'); |
Then
use the following command to set the x,
y, and z fields of the geometry_msgs/Point
message for publishing iteratively.
|
for i = 1:10 msg.setX(rand(1)) msg.setY(rand(1)) msg.setZ(rand(1)) publisher.publish(msg); pause(0.1); end |
|
Note: Commands
used in the following example can be found in matlabroot\toolbox\psp\ |
Every node has a default node listener. You
can bind user defined functions to a node’s default listener to perform clean
up tasks when the node shuts down. Use the following command to set execution
of a function named preShutdownTask when the node has started to shut
down:
|
node.setOnShutdownListener(@preShutdownTask); |
Likewise, use the following command to set execution
of a function named postShutdownTask when the node has shut down:
|
node.setOnShutdownCompleteListener(@postShutdownTask); |
The
definitions of both preShutdownTask and postShutdownTask are given in the
code snippet below:
|
function preShutdownTask(handle, event) node =
event.JavaEvent.getSource; disp(['Node ', char(node.getName()), ' running on ', char(node.getUri()), ... end function postShutdownTask(handle, event) node =
event.JavaEvent.getSource; disp(['Node ',
char(node.getName()), ' running on ', char(node.getUri()), ... end |
To verify that the binding of preShutdownTask and postShutdownTask
with the default node listener
performs correctly, use the following command to shut down the node:
|
node.Node.shutdown(); |
You should see outputs similar to the following
depending on the port where the node runs:
|
Node /NODE running on http://<IP_ADDRESS>:XXXXX/ is shutting down. Node /NODE running on
http://<IP_ADDRESS>:XXXXX/ has shut down. |
Finally, to completely destroy the node, use the following command
to delete the variable node:
|
clear('node'); |
This command triggers a call to the destructor of the rosmatlab.node object. The destructor
first shuts down the node, and then destroys the object. In the process of
doing so, the destructor searches for rosmatlab.publisher
and rosmatlab.subscriber objects that
are attached to the node for deletion. Notice that the above command not only
deletes the variable node in the
workspace, it also deletes the variables publisher
and subscriber if they still exist in
the workspace.
ROS I/O
Package contains the following classes for constructing ROS masters, nodes,
publishers, subscribers, and messages:
·
rosmatlab.roscore
·
rosmatlab.node
·
rosmatlab.publisher
·
rosmatlab.subscriber
·
rosmatlab.message
Note that these classes are defined under a package named rosmatlab.
|
Property Summary |
|
|
RosMaster |
Master
as returned by rosjava. |
|
RosMasterUri |
URI where
the master is running on. |
|
Constructor Summary |
|
Syntax: roscore
= rosmatlab.roscore(port) Description: Launch a ROS Master on the specified port on the local host. This
constructor automatically starts the master once it is instantiated. The
input argument port must be a double. If port is omitted, 11311
is the default. Example: roscore = rosmatlab.roscore(11311) roscore = rosmatlab.roscore() |
|
Method Summary |
|
Syntax: roscore.start () Description: Start the master. Because the constructor automatically
starts the master, use this method only if you want to restart the master after
it has been shut down by the roscore.shutdown
() method.  Use this method only
if you want to shut down the master without destroying it. Example: roscore.shutdown () |
|
Syntax: roscore.delete() Description: Destructor. Note that this method
automatically deletes all rosmatlab.node
objects that run on the master in the caller workspace. This method is
automatically called when all references to the object are deleted. Example: roscore.delete() |
|
Property Summary |
|
|
Node |
Default
node as returned by rosjava. |
|
NodeName |
Name of
the node. |
|
OnShutdownListener |
Listener binding the MATLAB function that executes
when the node has started to shut down. |
|
OnShutdownCompleteListener |
Listener binding the MATLAB function that
executes when the node has shut down. |
|
Publishers |
Publishers
that are attached to the node. |
|
Subscribers |
Subscribers
that are attached to the node. |
|
Constructor Summary |
|
Syntax: node
= rosmatlab.node(name, host, port) Description: Launch a node with the specified name on the master that is running on
http://host:port. The input arguments name
and host must each be a char array. The input argument port must be a double. Note that host
must be either the name or IP address of the host where the master you want
to connect to is running on. If host
is omitted, localhost is the
default. If port is omitted, 11311 is the default. Every ROS node is
assigned with a URI. This URI is not the same as the URI of its master. The URI
of a new node is always constructed using one of the following in the order
of precedence: ·
Environment
variable ROS_HOSTNAME ·
Environment
variable ROS_IP ·
IP address
of the local host Example: node
= rosmatlab.node('NODE', '<IP_ADDRESS>', 11311) node
= rosmatlab.node('NODE', 'HOSTNAME', 11311) node
= rosmatlab.node('NODE', 'HOSTNAME', []) node
= rosmatlab.node('NODE', [], 11311) node
= rosmatlab.node('NODE') |
|
Syntax: node
= rosmatlab.node(name, uri) Description: Launch a node with the specified name on the master that is running on uri. The input arguments name and uri must each be a char
array (string). Note that uri must
be the URI of the host where the master you want to connect to is running on.
If uri is omitted, the environment
variable ROS_MASTER_URI is used if
it exists. Otherwise, http://localhost:11311
is the default. Every ROS node is assigned with a URI. This URI is not the
same as the URI of its master. The URI of a new node is always constructed
using one of the following in the order of precedence: ·
Environment
variable ROS_HOSTNAME ·
Environment
variable ROS_IP ·
IP address
of the local host Example: node
= rosmatlab.node('NODE', 'http://<IP_ADDRESS>:11311') node
= rosmatlab.node('NODE', 'http://HOSTNAME:11311') node
= rosmatlab.node('NODE', 'http://localhost:11311') |
|
Syntax: node
= rosmatlab.node(name, host, port,
option, value) Description: Launch a node with the specified name on the master that is running on
http://host:port with any combination of the following options: ·
safeMode - Use this
option to enable parsing of connection errors to the master. Its value must
be either true or false. The option is useful when the
status of the master is not known. Note that this option incurs a delay of at
least 20 seconds in order to detect the connection status. Without the
option, you may experience error information that is logged to the MATLAB
command window after every unsuccessful attempt to connect to the master. ·
onShutdown - Use
this option to bind a user defined function that executes when the node has
started to shut down. Its value must be a handle to a function with a
signature of functionName(handle,
event). This option is useful for executing tasks upon a call to node.Node.shutdown(). ·
onShutdownComplete - Use
this option to attach a user defined function that executes when the node has
shut down. Its value must be a handle to a function with a signature of functionName(handle, event). This
option is useful for executing tasks upon a return of node.Node.shutdown(). ·
rosIP - Use
this option to overwrite the IP address that is automatically determined for
the local host. Its value must be a string in dotted decimal notation. When a
node is created, the IP address for the local host is used to construct its
URI for robustness reason. This option is useful for specifying the correct
IP address when the local host is assigned with multiple IP addresses. You
can also use this option to apply the loopback interface (<IP_ADDRESS>) for
better performance if the node only communicates with other nodes on the
local host. Every ROS node is assigned with a URI. This
URI is not the same as the URI of its master. The URI of a new node is always
constructed using one of the following in the order of precedence: ·
Value of
the rosIP option ·
Environment
variable ROS_HOSTNAME ·
Environment
variable ROS_IP ·
IP address
of the local host Example: The following command creates a node that connects
to a master running on http://HOSTNAME:11311 with the safeMode option enabled: node
= rosmatlab.node('NODE', 'HOSTNAME', 11311,'safeMode', true) The following command creates a node that connects
to a master running on http://HOSTNAME:11311 using the loopback interface: node
= rosmatlab.node('NODE', 'HOSTNAME', 11311, 'rosIP', '<IP_ADDRESS>') The following command creates a node that connects
to a master running on http://localhost:11311 with a setup to execute preShutdown and postShutdown functions when the node is shut down: node
= rosmatlab.node('NODE', [], [], 'onShutdown', @preShutdown, ... |
|
Method Summary |
|
Syntax: publisher
= node.addPublisher(topic, type) Description: Create a new publisher of the specified topic and attach it to the node for
sending messages of the given type.
The input arguments topic and type must each be a char array. Note that type must be the name of a valid
message type that implements org.ros.internal.message.Message.
You can also use the constructor of rosmatlab.publisher
to create a publisher as an alternative. See the documentation of rosmatlab.publisher for details on
publishing messages. Example: publisher = node.addPublisher('/TOPIC',
'std_msgs/String') |
|
Syntax: subscriber
= node.addSubscriber(topic, type, limit) Description: Create a new subscriber to the specified topic and attach it to the node for
receiving messages of the given type;
with a buffer that can queue new
messages up to the specified limit.
The input arguments topic and
type must each be a char array. The input argument limit must be a double. Note that type
must be the name of a valid message type that implements org.ros.internal.message.Message. If a message listener of the subscriber
processes new messages slower than they are received, older messages in the
queue are removed from the buffer when the buffer limit is exceeded. If the
subscriber is expecting messages that are published repeatedly at high
frequencies, increase the buffer limit to minimize chances of experiencing
dropped messages. You can also use the constructor of rosmatlab.subscriber to create a subscriber as an alternative.
See the documentation of rosmatlab.subscriber
for details on receiving messages. Example: subscriber = node.addSubscriber('/TOPIC',
'std_msgs/String', 1) |
|
Syntax: node.newMessage(type) Description: Create a new message of the given type. The input argument type must be a char array. Note that type
must be the name of a valid message type that implements org.ros.internal.message.Message. You can also use the
constructor of rosmatlab.message to
create a message as an alternative. Example: message =
node.newMessage('std_msgs/String') |
|
Syntax: node.removePublisher(publisher) Description: Remove the given publisher from the node. The input argument publisher must be a rosmatlab.publisher
object that is attached to the node. Note that this method automatically
deletes the corresponding rosmatlab.publisher
object in the caller workspace. Example: node.removePublisher(publisher) |
|
Syntax: node.removeSubscriber(subscriber) Description: Remove the given subscriber from the node. The input argument subscriber must be a rosmatlab.subscriber
object that is attached to the node. Note that this method automatically
deletes the corresponding rosmatlab.subscriber
object in the caller workspace. Example: node.removeSubscriber(subscriber) |
|
Syntax: node.setOnShutdownListener(function) Description: Set the given function to carry out user defined tasks when the node has
started to shut down. The input argument function
must be a handle to a function with a signature of functionName(handle, event). Note that this method is used for
binding a user defined function that executes at the start of the shutdown
process. Example: node.setOnShutdownListener(@preShutdown) |
|
Syntax: node.setOnShutdownCompleteListener(function) Description: Set the given function to carry out user defined tasks when the node has shut
down. The input argument function must
be a handle to a function with a signature of functionName(handle, event). Note that this method is used for
binding a user defined function that executes at the end of the shutdown
process. Example: node.setOnShutdownCompleteListener(@postShutdown) |
|
Syntax: node.delete () Description: Destructor. Note that this method
automatically deletes all rosmatlab.publisher
and rosmatlab.subscriber objects
that are attached to the node in the caller workspace. This method is
automatically called when all references to the object are deleted. Example: node.delete() |
|
Property Summary |
|
|
Publisher |
Default
publisher as returned by rosjava. |
|
TopicMessageType |
Type of
message to be sent to the advertised topic. |
|
TopicName |
Name of
the advertised topic. |
|
Constructor Summary |
|
Syntax: publisher
= rosmatlab.publisher(topic, type, node) Description: Create a new publisher of the specified topic and attach it to node for sending messages of the given
type. The input arguments topic and type must each be a char
array. The input argument node must
be a rosmatlab.node object. Note
that type must be the name of a valid
message type that implements org.ros.internal.message.Message.
You can also use the addPublisher
method of rosmatlab.node to create
a publisher as an alternative. Example: publisher
= rosmatlab.publisher ('/TOPIC', 'std_msgs/String', node) |
|
Method Summary |
|
Syntax: publisher.publish(message) Description: Publish the given message to the advertised topic. The input argument message must be a message object that
implements org.ros.internal.message.Message.
Note that the type of message must
match the expected topic message type. Example: publisher.publish(message) |
|
Syntax: publisher.delete () Description: Destructor. This method is automatically
called when all references to the object are deleted. Example: publisher.delete() |
|
Property Summary |
|
|
Subscriber |
Default
subscriber as returned by rosjava. (org.ros.internal.node.topic.DefaultSubscriber) |
|
BufferLimit |
The
maximum number of messages to queue. |
|
TopicMessageType |
Type of
message to be received from the subscribed topic. |
|
TopicName |
Name of
the subscribed topic. |
|
OnNewMessageListeners |
Listeners
binding the MATLAB functions that execute when messages are received via the
subscribed topics. |
|
Constructor Summary |
|
Syntax: subscriber
= rosmatlab.subscriber(topic, type, limit, node) Description: Create a new subscriber to the specified topic and attach it to node for receiving messages of the given
type, with a buffer that can queue new messages up to
the specified limit. The
input arguments topic and type must each be a char array. The input argument limit must be a double. The input argument node
must be a rosmatlab.node object. Note
that type must be the name of a valid
message type that implements org.ros.internal.message.Message.
If a Example: subscriber = rosmatlab.subscriber
('/TOPIC', 'std_msgs/String', 1, node) |
|
Method Summary |
|
Syntax: subscriber.addCustomMessageListener(function) Description: Set the given function that operates on an arbitrary number of arguments to
carry out user defined tasks when a valid message is published to the
subscribed topic. The input argument function
must be a cell array in which the
first entry is a function handle while the remaining entries are additional function
arguments. Note that the function that is associated with this handle must
have a signature of functionName(handle,
event, arguments). Example: subscriber.addCustomMessageListener({@custom_function,
extra_argument}) |
|
Syntax: subscriber.setOnNewMessageListeners(functions) Description: Set the given functions that operate on a received message to carry out user
defined tasks when a valid message is published to the subscribed topic. The
input argument functions must be a cell array of function handles. Note
that each function that is associated with these handles must have a
signature of functionName(message). Example: subscriber.setOnNewMessageListeners({@function1,
@ function2}) |
|
Syntax: subscriber.delete () Description: Destructor. This method is automatically
called when all references to the object are deleted. Example: subscriber.delete() |
|
Constructor Summary |
|
Syntax: rosmatlab.message(type, node) Description: Create a new message of the given type using a message factory of node. The input argument type must be a char array. The input argument node must be a rosmatlab.node
object. Note that type must be the
name of a valid message type that implements org.ros.internal.message.Message. You can also use the newMessage method of rosmatlab.node to create a message as
an alternative. Example: message = rosmatlab.message('std_msgs/String',
node) Remarks: In order
to use a specific type of message, you must have exposure to its message
definition. This information is available by inspecting either the msg file or
documentation of the message. You can use http://wiki.ros.org to lookup
documentation for standard ROS messages. For example, documentation for the std_msgs package can be found at http://wiki.ros.org/std_msgs. Note
that rosjava automatically generates a pair of get and set methods for
every field in each message definition. For example, std_msgs/String contains a field named data. Upon creating a message object of type std_msgs/String, you can read and write its data field using its getData
and setData methods, respectively. |
·
http://wiki.ros.org is the wiki
page for ROS documentation. Use this site to access installation and user
instructions for ROS.
·
http://wiki.ros.org/rosjava is the
wiki page for rosjava documentation. Use this site to access installation and
user instructions for rosjava.
·
http://rosjava.github.io/rosjava_core/hydro/index.html is the link
to the documentation for rosjava_core.
·
http://rosjava.github.io/rosjava_core/hydro/javadoc/index.html is the link
to the generated API documentation for rosjava_core. Use this site to access the
summary of each class/interface in every package under rosjava_core.
·
https://github.com/rosjava/rosjava_mvn_repo is the maven
artifact repository for rosjava dependencies and builds. Use this site to
download the latest rosjava distribution.
·
http://wiki.ros.org/turtlebot_simulator?distro=hydro is the
wiki page for the Turtlebot Simulator. Use this site to access installation and
user instructions for the turtlebot_simulator
package.


Blog post published at: http://memkite.com/blog/2014/09/09/memkite-announces-deep-learning-and-search-for-education/
Deep Learning is setting new records in AI-based image recognition, and we've combined Deep Learning with Memkite (Offline) Search for mobile in an educational context.
Check out http://deeplearning.education for a demo video of Deep Learning for Education.
The basic idea is that kids get used to working with Artificial Intelligence since it is highly likely they will in the future. The task the kids is as follows: 1) read and find an object (e.g. using Wikipedia or a curriculum such as Common Core others that is indexed and searchable using Memkite)
2) film the object from various angles in order to build a Deep Learning based Image classifier for it
3) share the classifier with other kids and teacher, e.g. using a mesh network between mobile devices if there is no or poor network available
4) use a set of deep learning classifiers to detect objects in nature and learn about them
This can of course be adapted to other settings than nature (e.g. urban areas, museums, healthcare, inside classroom).
Please let us know if this is of interest.
Best regards,
Amund Tveit
amund@memkite.com


Post edited 3 x times, last by
BrainFooLong
Administrator
Topicstarter
BrainFooLong
Administrator
Well, that does not happen often.
1 month after game release already 40% off on the home store of BF4!
But one thing that make me still happy, i#ve paid even less :)
What i interpret?
To less sells for BF4 because of the bad bug feedback :)
I wonder if Premium will have a discount.
US peeps with this discount code
http://www.dpgamer.com/
can get it for $20 :D


|
About AirCondor. The Project |
|
we do things for you to find the perfect airconditioner! We match up your climate from your postcode and find the best results of air conditioners rated by their efficiency
Govhack Tasmania 2015. The beginning of our team. We're awesome.
Jess Clarke has a background in software development and GIS, and enjoys learning more about data visualisation techniques. Jess was responsible for the research, development, and implementation of a clear cut mapping interface for the project.
Jess Lethbridge is post-graduate student with a background in sensor technology. She was responsible for sourcing data sets, worked on prototype design, and coordinated and directed the team video.


Physical Properties of Novel Two-dimensional Materials and Their Heterostructures: Calculation and Design from First-Principles Studies
I .
Introduction: The rise of two-dimensional materials
I.1 .
Graphene
I.1.1
History and prediction
I.1.2
Physical properties
I.2 .
Post-graphene Materials
I.2.1
Functionized Graphene
Graphane
Fluorographene
I.2.2
Boron Nitride
I.2.3
Silicene and Germanene
I.2.4
Transition Metal Dichalcogenides
I.3 .
1D from 2D: nanotube and nanoribbon
I.4 .
Synthesis methods
II .
Computational Methodology
II.1
Theory
II.1.1
Density Functional Theory
II.1.2
Exchange-correlation functional
II.1.3
Jocob's ladder
II.2
Implementation
II.2.1
Basis set, Plane wave energy cut-off, K-points
II.2.2
Software Packages
III .
General physical properties 2D materials
III.I
Structural properties
III.I.I
Layer structure (intralayer:covalent & interlayer: vdW)
graphite to graphene
III.I.II
sp hybirdization
Coulson’s theorem
III.I.III
Isotropic v.s. Anisotropic monolayer (graphene v.s. Bp or TiS3)
III.I.IV
Multiphase allotropes (Carbon;phosphorene;TMD;silicene)
III.II
Electronic properties
III.II.I
Introduction
III.II.II
Polar bond
III.II.III
Importance of crystal symmetry
Clar’s theory
III.II.IV
Importance of interlayer interaction
III.II.V
Accurate description from DFT
III.III
Vibrational properties
III.III.I
Introduction
III.III.II
Phonon dispersion of 2D materials
III.III.III
Dynamic stability from phonon dispersion
III.IV
Mechanical properties
III.IV.I
Introduction
III.IV.II
Elastic and engineering constants
III.IV.III
Mechanical stability: Born stability criteria
IV .
Results of Physical Properties Calculations on Novel 2D materials
IV.1
Thermal properties (2)
IV.1.1
Introduction
IV.1.2
Thermal expansion and anharmonic oscillations
IV.1.3
Quasi-harmonic approximation
IV.1.4
Helmholtz free energy and specific heat
IV.2
Piezoelectric properties (4)
IV.2.1
Introduction
IV.2.2
Piezoelectric constants
IV.2.3
Importance of internal relaxation
IV.3
Transport properties (5)
IV.3.1
Introduction
IV.3.2
Carrier mobility
IV.3.3
Deformation potential theory: non-polar materials
IV.3.4
Deformation potential theory: polar materials
IV.3.5
Electrical transport
IV.4
Magnetic properties (7)
IV.4.1
Introduction
IV.4.2
Magnetic ordering
Stoner criterion of ferromagnetism
read the book Magnetism in condensed
IV.5
Battery related properties (8)
IV.5.1
Introduction
IV.5.2
Principle of Lithium battery
IV.5.3
Key quantities
V .
Results of Physical Properties Modulation on Novel 2D materials
V.1
Number of layers and types of stackings (6)
V.1.1
Introduction
V.1.2
Electronic properties
V.1.3
Vibrational properties
V.2
Mechanical strain (5,7)
V.2.1
Introduction
V.2.2
Mobility
V.2.3
Magnetic properties
V.3
Adatom adsorption (9)
V.3.1
Introduction
V.3.2
Electronic properties
V.4
Heterostructures (10)
V.4.1
Introduction
V.4.2
Electronic properties
V.4.3
Li difusion
V.5
Defect induction (3)
V.5.1
Introduction
V.5.2
Structural properties
V.5.3
Electronic properties
V.5.4
Magnetic properties
VI .
Conclusions


|
To contact us with problems or questions, please post to this repository's GitHub issue reporting system (requires a GitHub user account).
Overview
SimpleITK is a simplified
programming interface to the algorithms and data structures of the
Insight Segmentation and Registration Toolkit (ITK).
It supports bindings for multiple programming languages including C++, Python, R,
Java, C#, Lua, Ruby and TCL. Combining SimpleITK's Python or R bindings with
the Jupyter notebook web application creates
an environment which facilitates collaborative development of biomedical image
analysis workflows.
In this tutorial, we will use a hands-on approach utilizing Jupyter notebooks to
explore and experiment with various SimpleITK features in the Python and R
programming languages. Participants will follow along using their personal
laptops, enabling them to explore the effects of code changes and parameter
settings not covered by the instructor. We will start by introducing the
toolkit's two basic data elements, Images and Transformations. We illustrate
how the two are combined to perform image resampling. We then show how to use
SimpleITK as a tool for image preparation and data augmentation for deep
learning via spatial (resampling) and intensity transformations. We will then
explore the various features available in the
toolkit's registration framework including: optimizer selection, the use of
linear and deformable transformations, the embedded multi-resolution framework,
self-calibrating optimizers and the use of callbacks for registration progress
monitoring. Time permitting, we will provide a short overview of SimpleITK's approach
to development of a maintainable collabaritve Jupyter notebook environment.
Beyond the notebooks used in this course you can find the main SimpleITK notebooks repository on GitHub.
Organizers
- Hans J. Johnson, University of Iowa.
- Bradley C. Lowekamp, Medical Science & Computing and National Institutes of Health.
- Ziv Yaniv, TAJ Technologies Inc. and National Institutes of Health.
Prerequisites
If you encounter problems or have questions, please post using this repository's GitHub issue reporting system (requires a GitHub user account).
In this course we will use the Anaconda Python distribution (required even if you intend to work in R). Please follow the instructions below to setup the environment we will use during the course. All commands below are issued on the command line (Linux/Mac - terminal, Windows - Anaconda Prompt).
-
Download and install the Fiji image viewer. This is the default image viewer used by SimpleITK:
-
On Windows: Install into your user directory (e.g. C:\Users\[your name]\Fiji.app).
-
On Linux: Install into ~/bin .
-
On Mac: Install into /Applications .
-
Download and install the Anaconda Python 3.6 version for your operating system. We assume it is installed in a directory named anaconda3.
-
- On Windows: open the Anaconda Prompt (found under the Anaconda3 start menu).
- On Linux/Mac: on the command line
source path_to_anaconda3/bin/activate base
-
Update the base anaconda environment and install the git version control system into it.
conda update conda
conda update anaconda
conda install git
-
Clone this repository:
git clone https://github.com/SimpleITK/ISBI2018_TUTORIAL.git
-
Create the virtual environment containing all packages required for the course:
conda env create -f ISBI2018_TUTORIAL/python/environment.yml
-
Activate the virtual environment. On the commandline, on Windows this is the Anaconda
Prompt found under the Anaconda3 start menu, and on Linux/Mac this is the terminal:
conda activate sitkISBI18 .
Continue With Python
-
On the command line:
jupyter nbextension enable --py --sys-prefix widgetsnbextension
-
Go over the setup notebook (requires internet connectivity). This notebook checks the environment setup and downloads
all of the required data:
jupyter notebook ISBI2018_TUTORIAL/python/setup.ipynb
Continue With R
To work with the R programming language you will
have to build SimpleITK on your computer. Currently this only works for OS X and Linux.
We assume you have the CMake
program, git (you just installed it above) and a compiler in your path.
-
Install R on your machine.
-
From the R prompt (appropriate number of parallel jobs, MAKEJ, depends on your specific machine):
install.packages(c("devtools", "rPython", "plot3D", "tidyr", "ggplot2", "purrr"))
devtools::install_github('IRkernel/IRkernel')
IRkernel::installspec()
devtools::install_github("SimpleITK/SimpleITKRInstaller", args=c('--configure-vars="MAKEJ=6"'))
-
Go over the setup notebook (requires internet connectivity). This notebook checks the environment setup and downloads
all of the required data:
jupyter notebook ISBI2018_TUTORIAL/r/setup.ipynb
Program
- [1:30PM- 2:00PM] history and overview of SimpleITK. [ppt: setup and schedule, history, overview]
- [2:00PM- 2:30PM] spatial transformations.
- [2:30PM- 3:00PM] images and resampling.
- [3:00PM - 3:15PM] (shortened) coffee break [ ] - so much material, so little time.
- [3:15PM - 3:45PM] data augmentation for deep learning.
- [3:45PM - 4:30PM] basic registration.
- [4:30PM - 5:15PM] advanced registration / segmentation.
- [5:15PM - 5:30PM] notebook development and testing, concluding remarks. [ppt: development and testing ]
* You will have to run the jupyter notebook command in the main directory of the repository, otherwise the static images shared by the Python and R
notebooks are not displayed (this is a feature not a bug).
Supplementary Material
For those interested in reading more about the design of SimpleITK and the Notebooks environmnet:
-
Z. Yaniv, B. C. Lowekamp, H. J. Johnson, R. Beare, "SimpleITK Image-Analysis Notebooks: a Collaborative Environment for Education and Reproducible Research", J Digit Imaging., 2017.
-
B. C. Lowekamp, D. T. Chen, L. Ibáñez, D. Blezek, "The Design of SimpleITK", Front. Neuroinform., 7:45., 2013.
|


Create a Data VaultCreate a container for data that can be synced between serversController (DID)Public Key (Vault Derived Key)Vault ID (Content ID/CID)Invoker (DIDs)Delegator (DIDs)
shield
Vaults
account_circle
id:PTlsaksjkluihJHjk123hf
Identity
public
<IP_ADDRESS>
Public IP Address
vpn_lock
<IP_ADDRESS>
Private IP Address
announcementRequests
Haxxors Paradiseid:PsPsadkjfdsT13Aab
IP address: <IP_ADDRESS>
Sent: 2020-05-26 12:00
Message:
I want to be your friend! PLZ!!!!
Shiba Inuid:PasdfdsT123311b
IP address: <IP_ADDRESS>
Sent: 2020-05-26 12:00
Message:
Add me if you want, or don't. See if I care. I'm just a dog.


---
layout: post
title: Learning Ruby (and why I should have learned it earlier)
date: 2015-04-17 00:06:12.000000000 -05:00
type: post
published: true
status: publish
categories:
- Ruby on Rails
tags: []
meta:
_publicize_pending: '1'
is_reblog: '1'
post_id: '85'
blog_id: '86593464'
reblog_snapshot: "O:8:\"stdClass\":7:{s:5:\"title\";s:56:\"Learning Ruby (and why
I should have learned it earlier)\";s:4:\"type\";s:4:\"post\";s:9:\"mime_type\";s:0:\"\";s:6:\"format\";b:0;s:12:\"modified_gmt\";s:19:\"2015-04-14
14:18:42\";s:9:\"permalink\";s:97:\"https://erikjenks.wordpress.com/2015/04/14/learning-ruby-and-why-i-should-have-learned-it-earlier\";s:7:\"content\";s:1672:\"
\n\nThe Internet has said it over and over. Did I
listen? Not right away. The almighty Interwebs have said “LEARN RUBY FIRST!” Nah,
I do things my way, I do what I want. I should have listened.\r\n\r\nI spent the
past week and a half sitting down, learning the basics of Ruby, and guess what.
Rails makes SO MUCH MORE SENSE NOW! So I should have listened to the wise words
of those who have come before me.\r\n\r\nActually, I think that attempting to
learn Rails before Ruby helped some. I understood some of the concepts, but then
after diving deep into Ruby it all started to click.\r\n\r\nThe use of hashes,
arrays, classes, and all the verbiage that came with Ruby became a snowball in
my mind. Once the ball began rolling I was able to comprehend even more. I went
back through some of my projects that I had done originally and just read my code.\r\n\r\nIt
sounds like a very noob-ish mistake, but I should have learned Ruby right from
the beginning. I’m a stubborn guy though sometimes, and like I said, I wanted
to do what I wanted to do. Now, I will say that I am not a Ruby expert per say,
but I think that I have enough of the basics down that I can go look at
Ruby-doc
and pick my way through them to get what I want.\r\n\r\nMy next project for myself
will be going through and refactoring my code that is just messy and not clean.
I also am working on a personal project that I will hopefully debut in the next
few months.\r\n\r\nShort post, but it’s something I felt I needed to get out.
Also, thanks to
Treehouse for their great
resources and helping me learn Ruby!
\";}"
publicize_twitter_user: bobr_az
publicize_twitter_url: http://t.co/NqGsDY21yX
_wpas_done_7641025: '1'
_publicize_done_external: a:1:{s:7:"twitter";a:1:{i:2516516912;b:1;}}
publicize_linkedin_url: ''
author:
login: broberts65
email<EMAIL_ADDRESS>display_name: Bob Roberts
first_name: ''
last_name: ''
---
I learned Rails from a Rails expert that did not know Ruby very well :( I learned so much Ruby just from messing around in Rails console.


| Contact Name | City | Country | Is Promoted |
|---|---|---|---|
| Maria Andrez | Berlin | Germany | |
| Anna Trujillo | Mexico D.F. | Mexico | |
| Antonio Moreno | Mexico D.F. | Mexico | |
| Thomas Hardy | London | UK |
| Contact Name | City | Country | Is Promoted |
|---|---|---|---|
| Maria Andrez | Berlin | Germany | |
| Anna Trujillo | Mexico D.F. | Mexico | |
| Antonio Moreno | Mexico D.F. | Mexico | |
| Thomas Hardy | London | UK |


07 August 2002
Disease Outbreak Reported
The Ministry of Health has announced that the Institut Pasteur, Madagascar has isolated influenza A (H3N2) viruses from 2 out of 39 samples taken from cases in Fianarantsoa province, an area where outbreaks of an influenza-like illness have been reported (see previous report).
The Ministry of Health has updated the epidemiological data: Since 4 July 2002, a total of 1 291 cases and 156 deaths have been reported.


Emphasis (toggles between \it and \rm).
This is version 2.09; see also LaTeX2e font selection, \emph.
See also Typefaces, Styles See also \boldmath Back to the Table of Contents


World high jump champion assails Russian track officials
by DARIA LITVINOVA and JAMES ELLINGWORTHMOSCOW (AP) - Three-time world high jump champion Mariya Lasitskene assailed Russian track leaders Friday after they were charged with using fake medical documents during an investigation, saying they have made a “doping nightmare” even worse.
Lasitskene called for swift and radical reforms, and the removal of officials appointed by track federation president Dmitry Shlyakhtin. He was one of seven Russians charged and suspended Thursday by the Athletics Integrity Unit.
Shlyakhtin took office shortly after the federation was suspended from international competition for widespread doping. The suspension remains in place four years later.
“The new team, whose task was to take us out of this doping nightmare, has turned out no better than the old one. And in some ways worse,” Lasitskene wrote on Instagram.
 And I will make sure this happens.”
Lasitskene has won two of her three world titles as a neutral athlete as a result of Russia’s suspension, which also caused her to miss the 2016 Olympics.
“Our track and field is in its death throes and we can’t procrastinate anymore,” she wrote. “We’ve lost four years already. Clean athletes are still defenseless and not sure they’ll be able to compete tomorrow.”
Sports Minister Pavel Kolobkov expressed concern about the “emergency situation” and referred the federation to a ministry commission which could officially withdraw its government recognition.
“The future fate of the track and field federation will be examined,” Kolobkov said Friday in a video statement. “For us now, the main thing is that the training process isn’t interrupted. That means all of the athletes will get the help they need to continue the training and competition process.”
Shlyakhtin and four other senior officials are accused of obstructing the investigation into 2017 world championship silver medalist Danil Lysenko, who was facing a ban last year for failing to make himself available for drug testing.
Lysenko allegedly provided fake medical documents as an alibi with help from the officials. His coach has also been suspended.
Earlier, the Kremlin said the charges against Shlyakhtin and others won’t derail the country’s preparations to compete in next year’s Olympics.
“Undoubtedly, this (situation) requires attention from the sports authorities, and I’m sure they’re dealing with it,” said Dmitry Peskov, the spokesman for Russian President Vladimir Putin. “But I don’t see a direct connection with Russia’s participation in the Olympics here.”
With Shlyakhtin suspended, the federation is set to select an interim president at a board meeting on Saturday.
Russia is also facing a World Anti-Doping Agency ruling next month on whether it manipulated data from a lab in Moscow.
Ellingworth reported from Düsseldorf, Germany.
More AP sports: https://apnews.com/apf-sports and https://twitter.com/AP_Sports
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Example Queries
The following queries are from the Player entity of the roster application, which is documented in The roster Application.
Simple Queries
If you are unfamiliar with the query language, these simple queries are a good place to start.
A Basic Select Query
SELECT p FROM Player p
Data retrieved: All players.
Description: The FROM clause declares an identification variable named p, omitting the optional keyword AS. If the AS keyword were included, the clause would be written as follows:
FROM Player AS p
The Player element is the abstract schema name of the Player entity.
See also: Identification Variables.
Eliminating Duplicate Values
SELECT DISTINCT p FROM Player p WHERE p.position = ?1
Data retrieved: The players with the position specified by the query’s parameter.
Description: The DISTINCT keyword eliminates duplicate values.
The WHERE clause restricts the players retrieved by checking their position, a persistent field of the Player entity. The ?1 element denotes the input parameter of the query.
See also: Input Parameters and The DISTINCT Keyword.
Using Named Parameters
SELECT DISTINCT p FROM Player p WHERE p.position = :position AND p.name = :name
Data retrieved: The players having the specified positions and names.
Description: The position and name elements are persistent fields of the Player entity. The WHERE clause compares the values of these fields with the named parameters of the query, set using the Query.setNamedParameter method. The query language denotes a named input parameter using a colon (:) followed by an identifier. The first input parameter is :position, the second is :name.
Queries That Navigate to Related Entities
In the query language, an expression can traverse, or navigate, to related entities. These expressions are the primary difference between the Java Persistence query language and SQL. Queries navigates to related entities, whereas SQL joins tables.
A Simple Query with Relationships
SELECT DISTINCT p FROM Player p, IN(p.teams) t
Data retrieved: All players who belong to a team.
Description: The FROM clause declares two identification variables: p and t. The p variable represents the Player entity, and the t variable represents the related Team entity. The declaration for t references the previously declared p variable. The IN keyword signifies that teams is a collection of related entities. The p.teams expression navigates from a Player to its related Team. The period in the p.teams expression is the navigation operator.
You may also use the JOIN statement to write the same query:
SELECT DISTINCT p FROM Player p JOIN p.teams t
This query could also be rewritten as:
SELECT DISTINCT p FROM Player p WHERE p.team IS NOT EMPTY
Navigating to Single-Valued Relationship Fields
Use the JOIN clause statement to navigate to a single-valued relationship field:
SELECT t FROM Team t JOIN t.league l WHERE l.sport = ’soccer’ OR l.sport =’football’
In this example, the query will return all teams that are in either soccer or football leagues.
Traversing Relationships with an Input Parameter
SELECT DISTINCT p FROM Player p, IN (p.teams) AS t WHERE t.city = :city
Data retrieved: The players whose teams belong to the specified city.
Description: This query is similar to the previous example but adds an input parameter. The AS keyword in the FROM clause is optional. In the WHERE clause, the period preceding the persistent variable city is a delimiter, not a navigation operator. Strictly speaking, expressions can navigate to relationship fields (related entities) but not to persistent fields. To access a persistent field, an expression uses the period as a delimiter.
Expressions cannot navigate beyond (or further qualify) relationship fields that are collections. In the syntax of an expression, a collection-valued field is a terminal symbol. Because the teams field is a collection, the WHERE clause cannot specify p.teams.city (an illegal expression).
See also: Path Expressions.
Traversing Multiple Relationships
SELECT DISTINCT p FROM Player p, IN (p.teams) t WHERE t.league = :league
Data retrieved: The players who belong to the specified league.
Description: The expressions in this query navigate over two relationships. The p.teams expression navigates the Player-Team relationship, and the t.league expression navigates the Team-League relationship.
In the other examples, the input parameters are String objects; in this example, the parameter is an object whose type is a League. This type matches the league relationship field in the comparison expression of the WHERE clause.
Navigating According to Related Fields
SELECT DISTINCT p FROM Player p, IN (p.teams) t WHERE t.league.sport = :sport
Data retrieved: The players who participate in the specified sport.
Description: The sport persistent field belongs to the League entity. To reach the sport field, the query must first navigate from the Player entity to Team (p.teams) and then from Team to the League entity (t.league). Because it is not a collection, the league relationship field can be followed by the sport persistent field.
Queries with Other Conditional Expressions
Every WHERE clause must specify a conditional expression, of which there are several kinds. In the previous examples, the conditional expressions are comparison expressions that test for equality. The following examples demonstrate some of the other kinds of conditional expressions. For descriptions of all conditional expressions, see WHERE Clause.
The LIKE Expression
SELECT p FROM Player p WHERE p.name LIKE ’Mich%’
Data retrieved: All players whose names begin with “Mich.”
Description: The LIKE expression uses wildcard characters to search for strings that match the wildcard pattern. In this case, the query uses the LIKE expression and the % wildcard to find all players whose names begin with the string “Mich.” For example, “Michael” and “Michelle” both match the wildcard pattern.
See also: LIKE Expressions.
The IS NULL Expression
SELECT t FROM Team t WHERE t.league IS NULL
Data retrieved: All teams not associated with a league.
Description: The IS NULL expression can be used to check whether a relationship has been set between two entities. In this case, the query checks whether the teams are associated with any leagues and returns the teams that do not have a league.
See also: NULL Comparison Expressions and NULL Values.
The IS EMPTY Expression
SELECT p FROM Player p WHERE p.teams IS EMPTY
Data retrieved: All players who do not belong to a team.
Description: The teams relationship field of the Player entity is a collection. If a player does not belong to a team, the teams collection is empty, and the conditional expression is TRUE.
See also: Empty Collection Comparison Expressions.
The BETWEEN Expression
SELECT DISTINCT p FROM Player p WHERE p.salary BETWEEN :lowerSalary AND :higherSalary
Data retrieved: The players whose salaries fall within the range of the specified salaries.
Description: This BETWEEN expression has three arithmetic expressions: a persistent field (p.salary) and the two input parameters (:lowerSalary and :higherSalary). The following expression is equivalent to the BETWEEN expression:
p.salary >= :lowerSalary AND p.salary <= :higherSalary
See also: BETWEEN Expressions.
Comparison Operators
SELECT DISTINCT p1 FROM Player p1, Player p2 WHERE p1.salary > p2.salary AND p2.name = :name
Data retrieved: All players whose salaries are higher than the salary of the player with the specified name.
Description: The FROM clause declares two identification variables (p1 and p2) of the same type (Player). Two identification variables are needed because the WHERE clause compares the salary of one player (p2) with that of the other players (p1).
See also: Identification Variables.
Bulk Updates and Deletes
The following examples show how to use the UPDATE and DELETE expressions in queries. UPDATE and DELETE operate on multiple entities according to the condition or conditions set in the WHERE clause. The WHERE clause in UPDATE and DELETE queries follows the same rules as SELECT queries.
Update Queries
UPDATE Player p SET p.status = 'inactive' WHERE p.lastPlayed < :inactiveThresholdDate
Description: This query sets the status of a set of players to inactive if the player’s last game was longer than the date specified in inactiveThresholdDate.
Delete Queries
DELETE FROM Player p WHERE p.status = 'inactive' AND p.teams IS EMPTY
Description: This query deletes all inactive players who are not on a team.


Hi there investors and welcome to this third installment of our ICO review series brought to you by Dean (@deanliu) and Dan (@tradealert), today we’re looking at an exciting project called Futourist.
In a Nutshell.
Futourist is:
“The first block-chain based review platform that rewards you for your content. You create reviews, share and get paid”.
Futourist intends to tap into the fast growing content industry, which is expected to be worth more than US $313 billion by the year 2019.
Their goal is to create a thriving ecosystem where businesses, content creators, curators and advertisers can mutually benefit and use the network to exchange value seamlessly via the platform’s native currency: the FTR token.
Users are incentivized to create content through contests. A contest is a content driven campaign launched by a business participating on the platform or by the platform (Futourist) itself. Futourist can enable multiple contests at the same time.
Each contest has a budget (expressed in FTR tokens) which will be allocated to reward content creators for creating reviews. The reviews will then be monitored by a community of curators who can upvote the good and flag the spamming. The more upvotes a review creator gets, the more “power” they can accumulate and in turn the more valuable (and profitable) their contribution to the community becomes in the form of more content creation or more curation work.
You can think of the project as a cross between Yelp (reviews) and Steemit (rewards).
The problem Futourist is trying to solve is the following:
“At the moment the majority of users do not receive any kind of payment for creating content on the most popular review websites. Those reviews are converted into revenue, while users are not paid. We are here to change that! We will give you the power and the value of your content!“
Futourist is currently being developed on top of the Ethereum blockchain and plans on having an ICO on the 15th of February.
The purpose of this article is to try to determine whether or not the team behind Futourist can actually deliver on this vision. We’ll first look at the team (I), the product (II) and the role of the blockchain in the project (III) before giving you our conclusion (IV).
I - The Team.
The co-founders of the start-up are three long-time friends from Slovenia. The CEO, Ziga Lukša, is also the founder and former head of Sailbrace an international brand of fashionable anchor bracelets who has proven experience in brand development and business building.
Futourist’s core technical team is composed of a CTO, 2 full stack developers, a front-end developer and an A.I. specialist with experience working on A.I. for the United Nations. This team is led by Nino Kutnjak, a web developer with over 10 years of experience ranging from IT integrations, servers and client level to pure development. Nino is also very active on the project’s Telegram channel.
Interestingly, the team is advised by Tim M. Zagar, the CEO of ICONOMI which is one of the earliest digital asset management platform built on the Ethereum blockchain and a very successful blockchain fin-tech company in Slovenia.
The team is also partnered with CoFound.it, a Slovenian VC platform with international reach responsible for launching many successful ICOs such as MAECENAS or SANTIMENT. Futourist initially planned to have its ICO through the CoFound.it platform but ultimately decided to crowdfund on its own. The two entities haven’t severed ties though and CoFound.it is still involved in the project as an adviser.
Our impression is that the team is a good first look for the project and, given their experience, seems entirely capable of delivering on its vision. It’s also worth noting that the project is being developed in Slovenia which is considered one of the friendliest countries in the world towards crypto currencies and blockchain innovation.
II-Product maturity and Competition.
Futourist’s core proposition is to be a review dApp with a focus on video content (similar to Instagram Stories). Unlike many other projects built on Ethereum though, Futurist already have a working product to show for.
The Futourist dApp is being built on top of an existing platform called OpenHours. Open hours is “a hybrid service between Yelp and Tripadvisor that provides information about different businesses and services“, the service has been in business for over 4 years now and already boasts a pretty solid network of users.
The first advantage of building on top of an existing app is that Futourist will be able to mine directly into Open Hour’s user pool which spans over 20 countries and has nearly a million services and users in its database.
The second advantage is that Futourist gets to benefit from the expertise of the OpenHours dev team.Both start-ups are actually meant to merge soon under the Futourist umbrella.
As far as competition is concerned, Futourist’s main competitors on the review app market will be giants like Google or Instagram but Futourist disposes of an unfair advantage over those two: its blockchain.
III- Blockchain role in the Project.
As we mentioned in the introduction, Futourist is based on the Ethereum blockchain and possess its own currency: the FTR tokens, a billion of which will be created during the ICO to provide liquidity to the platform’s economy.
The question here is to determine why the blockchain was chosen by the developers and what value it adds to the project over traditional methods of storing data. After all, existing review apps like Yelp or TripAdvisor have been in business for over a decade without the help of a blockchain.
In the case of Futourist, the blockchain will be used to automate and secure an economy in which participants will issue and receive rewards in the form of FTR tokens for creating and curating reviews.
This economy is designed to be very inclusive and will involve many actors, ranging from businesses to content creators and advertisers, all of which will use the FTR token as a mean of exchange.
The in-built reward system for content creators is, in our opinion, the most attractive aspect of the Futourist project. First because the blockchain will allow the reward system to be trusted and auditable across the whole network. Second because it will remove the possibility of a central agent tampering with the reward pool (including Futourist itself). Finally because it provides a healthy incentive for the community to create good content in order to receive rewards.
However a reward system can only strive if it allows transparency and fairness; and that is in essence the reason behind the use of a blockchain.
If the reward will be distributed in a decentralized and transparent fashion, it’s important to note that the content itself (reviews) will not be secured onto a blockchain (unlike Steemit for example) since the Ethereum network does not (yet?) allow for the storage of that much data. Instead, the content will be stored in traditional databases and subject to centralization which seems like a necessary compromise at this stage of development. It’s worth wondering though if the project wouldn’t be better suited for a more immediately scalable blockchain like Steem or EOS.
Despite this minor caveat, it seems like the scope of the project mostly justifies the use of a blockchain.
IV- The Community.
Futourist community is still small but it’s likely this number will grow quickly once the app rolls out and the word of mouth starts spreading. Their telegram channel currently has around 800 members and the devs are responsive and eager to answers the questions of potential investors.
The team seems to take community building seriously as the crowdsale webpage indicates that 45% of the tokens will be reserved for this purpose with possibility to audit the management of this reserve via the blockchain.
V- Conclusion.
Futourist is an ambitious project which benefits from the experience of a stellar development and advisory team and strong economic principles. The community around the project, though small is enthusiastic and the project is ideally developed in a country favorable to crypto and blockchain innovation.
In our opinion this project deserves your full attention.
To learn more about Futourist, you can head over to their website to read their whitepaper or get to know more about their soon-coming ICO.
So that’s it for today folks and we hope you’ve learned something new, don’t forget to re-steem, upvote and follow @tradealert and @deanliu if you like our featured content.
Cheers,
Dan & Dean.
This page is synchronized from the post: ‘Token Review - Travel, write reviews and get paid with FUTOURIST’


Fruits I like
How I learned to love Citus
I like apples and orangea.
Additional fruits
I alse like bananas, mangoes,cherries,apricots,plums,peaches,and grapes
More information
You can see other fruits I like here
I like apples and orangea.
I alse like bananas, mangoes,cherries,apricots,plums,peaches,and grapes
You can see other fruits I like here
I like to swim,cycle and run. I am in training for my first triathlon, but it is hard work.
There are different kinds of triathlon - sprint, Olympic an so on.
I am aiming for Olympic, which consists of the fllowing:


Big cat fear after foal found dead in field
The horse appears to have been partially eaten
by Neil ShawExperts fear a big cat could be on the loose after a foal was found dead in a field - with a huge wound in his stomach.
A ferocious feline may be responsible for killing the colt and disembowelling it, after he was found dead in a field in Kent with a giant hole in its stomach.
The young horse was found lying on his side in his field in Greenhithe last week.
The foal was seen alive the day before when he was in good health.
Rik Snook, formerly of Big Cats of Britain, has a long history of tracking big cats across Kent and Sussex.
He says the foal was probably killed and eaten by a big cat, but would not like to speculate which type.
Rik said: “It is definitely possible a big cat is responsible.
“There have been reported sightings in the area.
“It is pretty common a big cat would want to go after a young horse. It would be the upper size of what the cat would go after, but it’s definitely not unusual.”
The RSPCA was alerted after a four-month-old piebald foal was found gutted in a field in Greenhithe on November 10.
RSPCA inspector Kirsten Ormerod said: “There was no obvious signs of ill health from what I could see looked in good body condition.
“It is possible he had died from natural causes and then unfortunately been scavenged on but his owner is understandably concerned so we are appealing for anyone with information to come forward.
“We urge anyone with information to contact our appeals line in complete confidence.”
Many believe Britain has an elusive population of wild big cats, with many people reporting sightings in rural areas.
Often described as panthers or pumas, others are unconvinced with many sightings often turning out to be misidentified large domestic cats.
However on several occasions, genuine big cats have been captured and identified in Britain.
Sceptics say these were likely animals that had been kept illegally and escaped, or even released after the animals became too difficult to manage.


MIMIC
***1/2 (out of ****)
Dimension / 1:40 / 1997 / R Cast: Mira Sorvino; Jeremy Northam; Charles Dutton; Giancarlo Giannini; F. Murray Abraham; Josh Brolin; Alexander Goodwin Director: Guillermo Del Toro Screenplay: Matthew Robbins; John Sayles; Steven Soderbergh
Okay, check this out -- you know those craggy, mysterious, trenchcoat-clad figures that skulk around the alleys and transit systems of New York City? As it turns out, they're really genetically-evolved mutant bug-like monsters. Who'd have thought?
Well, there's actually an answer to that second question, and it's John Sayles, Steven Soderbergh and Matthew Robbins, who use the strange premise to a solid effect in the new horror flick "Mimic." Credit Dimension Films (a subdivision of Miramax) with single-handedly reviving the genre -- they're the movie company behind this, last winter's hit "Scream" and the looks-like-a-winner "Nightwatch," to be released this fall. "Mimic" has its flaws, but its a nonetheless a strong entry in an until-recently dead film category, boasting a sturdy dramatic turn by Mira Sorvino and some of the frightening special effects of the year.
Sorvino plays expert entomologist Susan Tyler. When New York City is seized by an unusual plague that effects only children, Tyler targets the source -- cockroaches. She engineers the creation of the Judas Breed, a ferocious DNA-spliced insect to be released in the city's sewers; their purpose is to secrete a substance that will attract and destroy the disease carriers and then keel over themselves when their six-month life expectancy has been exhausted. Everything is pulled off ... or so it seems, until three years later when bizarre murders begin in the area.
It seems as though the Judas Breed didn't die out as thought. One scientist says, "Evolution has a way of keeping things alive," and in the Judas Breed's case, it has also caused maturity in physical stature, as they can "mimic" their prey in order to infiltrate them.  Together with disease researcher husband Peter (Jeremy Northam of "Emma" and "The Net") and a quirky secondary cast that includes a tough cop (Charles Dutton) and a sarcastic investigator (Josh Brolin), Tyler takes to the sewers to uncover the nest and find a way to exterminate the Judas Breed once and for all.
I could carp about certain problematic areas of "Mimic" (and I will momentarily), but the movie provides such a high level of gnaw-off-your-fingers fun that it's somewhat useless to even bother. The story background is both interesting and creative, but "Mimic" doesn't spend more time than it should on it. In fact, "Mimic" moves incredibly fast, with dazzling opening credits a la "Seven," a first half that's engrossing, exciting setup and a second part that satisfies with much creepy-crawly impact. Director Guillermo Del Toro toys well with audience expectation, and waits until exactly the right moment to unleash the first full-view of the monster. From then on, the shocks are plenty, the scares are amusing and the terror is palpable.
Sorvino has fashioned a career -- and a great one -- by dazzlingly portraying vacuous airheads in "Mighty Aphrodite" and "Romy and Michele's High School Reunion." The surprise here is that Sorvino is as good playing the brain as she is the bimbo. The dashing Northam offers solid support, as does Dutton in the small but heroic role he normally plays. Giancarlo Giannini, as a local shoeshiner whose seemingly autistic grandson has disappeared after encountering the Judas Breed, is properly eccentric even if the subplot devoted to him is Mimic's most uninteresting one. Brolin ("Flirting With Disaster"), a little-known but appealing actor, is not given much to do but compensates with an engaging performance.
Del Toro, the man behind the Mexican vampire film "Cronos," doesn't skimp when it comes to shocking in the first hour (basically, he's not afraid to kill off children), but my main gripe about "Mimic" is that its concluding 50 minutes isn't so daring, relying more on slick convention than daring innovation to tell its story. At no time was I not entertained, but "Mimic" ends up being a patchwork rip-off of the "Alien" trilogy, "Jurassic Park" and other sci-fi landmarks. Still, that's not something that you don't exactly think about going in, and besides, if "Mimic" mimics other movies, it smartly mimics the best.
© 1997 Jamie Peck E-mail<EMAIL_ADDRESS>Website: http://www.gl.umbc.edu/~jpeck1/
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