#
Redux Essentials, Part 4: Using Redux DataWhat You'll Learn
- Using Redux data in multiple React components
- Organizing logic that dispatches actions
- Writing more complex update logic in reducers
Prerequisites
- Understanding the Redux data flow and React-Redux APIs from Part 3
-
Familiarity with
the React Router
<Link>
and<Route>
components for page routing
#
IntroductionIn Part 3: Basic Redux Data Flow, we saw how to start from an empty Redux+React project setup, add a new slice of state, and create React components that can read data from the Redux store and dispatch actions to update that data. We also looked at how data flows through the application, with components dispatching actions, reducers processing actions and returning new state, and components reading the new state and rerendering the UI.
Now that you know the core steps to write Redux logic, we're going to use those same steps to add some new features to our social media feed that will make it more useful: viewing a single post, editing existing posts, showing post author details, post timestamps, and reaction buttons.
info
As a reminder, the code examples focus on the key
concepts and changes for each section. See the
CodeSandbox projects and the
tutorial-steps
branch in the
project repo
for the complete changes in the application.
#
Showing Single PostsSince we have the ability to add new posts to the Redux store, we can add some more features that use the post data in different ways.
Currently, our post entries are being shown in the main feed page, but if the text is too long, we only show an excerpt of the content. It would be helpful to have the ability to view a single post entry on its own page.
#
Creating a Single Post Page
First, we need to add a new
SinglePostPage
component to our
posts
feature folder. We'll use
React Router to show this component when the page URL
looks like /posts/123
, where the
123
part should be the ID of the post we
want to show.
React Router will pass in a match
object
as a prop that contains the URL information we're
looking for. When we set up the route to render this
component, we're going to tell it to parse the
second part of the URL as a variable named
postId
, and we can read that value from
match.params
.
Once we have that postId
value, we can
use it inside a selector function to find the right
post object from the Redux store. We know that
state.posts
should be an array of all
post objects, so we can use the
Array.find()
function to loop through the
array and return the post entry with the ID we're
looking for.
It's important to note that
the component will re-render any time the value
returned from useSelector
changes to a
new reference. Components should always try to select the smallest
possible amount of data they need from the store,
which will help ensure that it only renders when it
actually needs to.
It's possible that we might not have a matching
post entry in the store - maybe the user tried to type
in the URL directly, or we don't have the right
data loaded. If that happens, the
find()
function will return
undefined
instead of an actual post
object. Our component needs to check for that and
handle it by showing a "Post not found!"
message in the page.
Assuming we do have the right post object in the
store, useSelector
will return that, and
we can use it to render the title and content of the
post in the page.
You might notice that this looks fairly similar to the
logic we have in the body of our
<PostsList>
component, where we
loop over the whole posts
array to show
post excerpts the main feed. We could try to
extract a Post
component that could be
used in both places, but there are already some
differences in how we're showing a post excerpt
and the whole post. It's usually better to keep
writing things separately for a while even if
there's some duplication, and then we can decide
later if the different sections of code are similar
enough that we can really extract a reusable
component.
#
Adding the Single Post Route
Now that we have a
<SinglePostPage>
component, we can
define a route to show it, and add links to each post
in the front page feed.
We'll import SinglePostPage
in
App.js
, and add the route:
Then, in <PostsList>
, we'll
update the list rendering logic to include a
<Link>
that routes to that specific
post:
And since we can now click through to a different
page, it would also be helpful to have a link back to
the main posts page in the
<Navbar>
component as well:
#
Editing PostsAs a user, it's really annoying to finish writing a post, save it, and realize you made a mistake somewhere. Having the ability to edit a post after we created it would be useful.
Let's add a new
<EditPostForm>
component that has
the ability to take an existing post ID, read that
post from the store, lets the user edit the title and
post content, and then save the changes to update the
post in the store.
#
Updating Post Entries
First, we need to update our
postsSlice
to create a new reducer
function and an action so that the store knows how to
actually update posts.
Inside of the createSlice()
call, we
should add a new function into the
reducers
object. Remember that the name
of this reducer should be a good description of
what's happening, because we're going to see
the reducer name show up as part of the action type
string in the Redux DevTools whenever this action is
dispatched. Our first reducer was called
postAdded
, so let's call this one
postUpdated
.
In order to update a post object, we need to know:
- The ID of the post being updated, so that we can find the right post object in the state
-
The new
title
andcontent
fields that the user typed in
Redux action objects are required to have a
type
field, which is normally a
descriptive string, and may also contain other fields
with more information about what happened. By
convention, we normally put the additional info in a
field called action.payload
, but
it's up to us to decide what the
payload
field contains - it could be a
string, a number, an object, an array, or something
else. In this case, since we have three pieces of
information we need, let's plan on having the
payload
field be an object with the three
fields inside of it. That means the action object will
look like
{type: 'posts/postUpdated', payload: {id,
title, content}}
.
By default, the action creators generated by
createSlice
expect you to pass in one
argument, and that value will be put into the action
object as action.payload
. So, we can pass
an object containing those fields as the argument to
the postUpdated
action creator.
We also know that the reducer is responsible for
determining how the state should actually be updated
when an action is dispatched. Given that, we should
have the reducer find the right post object based on
the ID, and specifically update the
title
and content
fields in
that post.
Finally, we'll need to export the action creator
function that createSlice
generated for
us, so that the UI can dispatch the new
postUpdated
action when the user saves
the post.
Given all those requirements, here's how our
postsSlice
definition should look after
we're done:
#
Creating an Edit Post Form
Our new <EditPostForm>
component
will look similar to the
<AddPostForm>
, but the logic needs
to be a bit different. We need to retrieve the right
post
object from the store, then use that
to initialize the state fields in the component so the
user can make changes. We'll save the changed
title and content values back to the store after the
user is done. We'll also use React Router's
history API to switch over to the single post page and
show that post.
Like with SinglePostPage
, we'll need
to import it into App.js
and add a route
that will render this component. We should also add a
new link to our SinglePostPage
that will
route to EditPostPage
, like:
#
Preparing Action Payloads
We just saw that the action creators from
createSlice
normally expect one argument,
which becomes action.payload.
This
simplifies the most common usage pattern, but
sometimes we need to do more work to prepare the
contents of an action object. In the case of our
postAdded
action, we need to generate a
unique ID for the new post, and we also need to make
sure that the payload is an object that looks like
{id, title, content}
.
Right now, we're generating the ID and creating
the payload object in our React component, and passing
the payload object into postAdded
. But,
what if we needed to dispatch the same action from
different components, or the logic for preparing the
payload is complicated? We'd have to duplicate
that logic every time we wanted to dispatch the
action, and we're forcing the component to know
exactly what the payload for this action should look
like.
caution
If an action needs to contain a unique ID or some other random value, always generate that first and put it in the action object. Reducers should never calculate random values, because that makes the results unpredictable.
If we were writing the postAdded
action
creator by hand, we could have put the setup logic
inside of it ourselves:
But, Redux Toolkit's createSlice
is
generating these action creators for us. That makes
the code shorter because we don't have to write
them ourselves, but we still need a way to customize
the contents of action.payload
.
Fortunately, createSlice
lets us define a
"prepare callback" function when we write a
reducer. The "prepare callback" function can
take multiple arguments, generate random values like
unique IDs, and run whatever other synchronous logic
is needed to decide what values go into the action
object. It should then return an object with the
payload
field inside. (The return object
may also contain a meta
field, which can
be used to add extra descriptive values to the action,
and an error
field, which should be a
boolean indicating whether this action represents some
kind of an error.)
Inside of the reducers
field in
createSlice
, we can define one of the
fields as an object that looks like
{reducer, prepare}
:
Now our component doesn't have to worry about
what the payload object looks like - the action
creator will take care of putting it together the
right way. So, we can update the component so that it
passes in title
and
content
as arguments when it dispatches
postAdded
:
#
Users and Posts
So far, we only have one slice of state. The logic is
defined in postsSlice.js
, the data is
stored in state.posts
, and all of our
components have been related to the posts feature.
Real applications will probably have many different
slices of state, and several different "feature
folders" for the Redux logic and React
components.
You can't have a "social media" app if there aren't any other people involved. Let's add the ability to keep track of a list of users in our app, and update the post-related functionality to make use of that data.
#
Adding a Users Slice
Since the concept of "users" is different
than the concept of "posts", we want to keep
the code and data for the users separated from the
code and data for posts. We'll add a new
features/users
folder, and put a
usersSlice
file in there. Like with the
posts slice, for now we'll add some initial
entries so that we have data to work with.
For now, we don't need to actually update the
data, so we'll leave the
reducers
field as an empty object.
(We'll come back to this in a later section.)
As before, we'll import the
usersReducer
into our store file and add
it to the store setup:
#
Adding Authors for Posts
Every post in our app was written by one of our users,
and every time we add a new post, we should keep track
of which user wrote that post. In a real app,
we'd have some sort of a
state.currentUser
field that keeps track
of the current logged-in user, and use that
information whenever they add a post.
To keep things simpler for this example, we'll
update our <AddPostForm>
component
so that we can select a user from a dropdown list, and
we'll include that user's ID as part of the
post. Once our post objects have a user ID in them, we
can use that to look up the user's name and show
it in each individual post in the UI.
First, we need to update our
postAdded
action creator to accept a user
ID as an argument, and include that in the action.
(We'll also update the existing post entries in
initialState
to have a
post.user
field with one of the example
user IDs.)
Now, in our <AddPostForm>
, we can
read the list of users from the store with
useSelector
and show them as a dropdown.
We'll then take the ID of the selected user and
pass that to the postAdded
action
creator. While we're at it, we can add a bit of
validation logic to our form so that the user can only
click the "Save Post" button if the title
and content inputs have some actual text in them:
Now, we need a way to show the name of the post's
author inside of our post list items and
<SinglePostPage>
. Since we want to
show this same kind of info in more than one place, we
can make a PostAuthor
component that
takes a user ID as a prop, looks up the right user
object, and formats the user's name:
Notice that we're following the same pattern in
each of our components as we go. Any component that
needs to read data from the Redux store can use the
useSelector
hook, and extract the
specific pieces of data that it needs. Also, many
components can access the same data in the Redux store
at the same time.
We can now import the
PostAuthor
component into both
PostsList.js
and
SinglePostPage.js
, and render it as
<PostAuthor userId={post.user} />
,
and every time we add a post entry, the selected
user's name should show up inside of the rendered
post.
#
More Post FeaturesAt this point, we can create and edit posts. Let's add some additional logic to make our posts feed more useful.
#
Storing Dates for Posts
Social media feeds are typically sorted by when the
post was created, and show us the post creation time
as a relative description like "5 hours
ago". In order to do that, we need to start
tracking a date
field for our post
entries.
Like with the post.user
field, we'll
update our postAdded
prepare callback to
make sure that post.date
is always
included when the action is dispatched. However,
it's not another parameter that will be passed
in. We want to always use the exact timestamp from
when the action is dispatched, so we'll let the
prepare callback handle that itself.
caution
Redux actions and state should only contain plain JS values like objects, arrays, and primitives. Don't put class instances, functions, or other non-serializable values into Redux!.
Since we can't just put a Date
class
instance into the Redux store, we'll track the
post.date
value as a timestamp string:
Like with post authors, we need to show the relative
timestamp description in both our
<PostsList>
and
<SinglePostPage>
components.
We'll add a
<TimeAgo>
component to handle
formatting a timestamp string as a relative
description. Libraries like date-fns
have
some useful utility functions for parsing and
formatting dates, which we can use here:
#
Sorting the Posts List
Our <PostsList>
is currently
showing all the posts in the same order the posts are
kept in the Redux store. Our example has the oldest
post first, and any time we add a new post, it gets
added to the end of the posts array. That means the
newest post is always at the bottom of the page.
Typically, social media feeds show the newest posts
first, and you scroll down to see older posts. Even
though the data is being kept oldest-first in the
store, we can reorder the data in our
<PostsList>
component so that the
newest post is first. In theory, since we know that
the state.posts
array is already sorted,
we could just reverse the list. But,
it's better to go ahead and sort it ourselves
just to be sure.
Since array.sort()
mutates the existing
array, we need to make a copy of
state.posts
and sort that copy. We know
that our post.date
fields are being kept
as date timestamp strings, and we can directly compare
those to sort the posts in the right order:
We also need to add the date
field to
initialState
in
postsSlice.js
. We'll use
date-fns
here again to subtract minutes
from the current date/time so they differ from each
other.
#
Post Reaction ButtonsWe have one more new feature to add for this section. Right now, our posts are kind of boring. We need to make them more exciting, and what better way to do that than letting our friends add reaction emoji to our posts?
We'll add a row of emoji reaction buttons at the
bottom of each post in
<PostsList>
and
<SinglePostPage>
. Every time a user
clicks one of the reaction buttons, we'll need to
update a matching counter field for that post in the
Redux store. Since the reaction counter data is in the
Redux store, switching between different parts of the
app should consistently show the same values in any
component that uses that data.
Like with post authors and timestamps, we want to use
this everywhere we show posts, so we'll create a
<ReactionButtons>
component that
takes a post
as a prop. We'll start
by just showing the buttons inside, with the current
reaction counts for each button:
We don't yet have a
post.reactions
field in our data, so
we'll need to update the
initialState
post objects and our
postAdded
prepare callback function to
make sure that every post has that data inside, like
reactions: {thumbsUp: 0, hooray: 0}
.
Now, we can define a new reducer that will handle updating the reaction count for a post when a user clicks the reaction button.
Like with editing posts, we need to know the ID of the
post, and which reaction button the user clicked on.
We'll have our action.payload
be an
object that looks like {id, reaction}
.
The reducer can then find the right post object, and
update the correct reactions field.
As we've seen already,
createSlice
lets us write
"mutating" logic in our reducers. If we
weren't using createSlice
and the
Immer library, the line
existingPost.reactions[reaction]++
would
indeed mutate the existing
post.reactions
object, and this would
probably cause bugs elsewhere in our app because we
didn't follow the rules of reducers. But, since
we are using createSlice
, we can
write this more complex update logic in a simpler way,
and let Immer do the work of turning this code into a
safe immutable update.
Notice that our action object just contains the minimum amount of information needed to describe what happened. We know which post we need to update, and which reaction name was clicked on. We could have calculated the new reaction counter value and put that in the action, but it's always better to keep the action objects as small as possible, and do the state update calculations in the reducer. This also means that reducers can contain as much logic as necessary to calculate the new state.
info
When using Immer, you can either "mutate" an existing state object, or return a new state value yourself, but not both at the same time. See the Immer docs guides on Pitfalls and Returning New Data for more details.
Our last step is to update the
<ReactionButtons>
component to
dispatch the reactionAdded
action when
the user clicks a button:
Now, every time we click a reaction button, the
counter should increment. If we browse around to
different parts of the app, we should see the correct
counter values displayed any time we look at this
post, even if we click a reaction button in the
<PostsList>
and then look at the
post by itself on the
<SinglePostPage>
.
#
What You've LearnedHere's what our app looks like after all these changes:
It's actually starting to look more useful and interesting!
We've covered a lot of information and concepts in this section. Let's recap the important things to remember:
Summary
-
Any React component can use data from the
Redux store as needed
- Any component can read any data that is in the Redux store
- Multiple components can read the same data, even at the same time
- Components should extract the smallest amount of data they need to render themselves
- Components can combine values from props, state, and the Redux store to determine what UI they need to render. They can read multiple pieces of data from the store, and reshape the data as needed for display.
- Any component can dispatch actions to cause state updates
-
Redux action creators can prepare action
objects with the right contents
-
createSlice
andcreateAction
can accept a "prepare callback" that returns the action payload - Unique IDs and other random values should be put in the action, not calculated in the reducer
-
-
Reducers should contain the actual state
update logic
- Reducers can contain whatever logic is needed to calculate the next state
- Action objects should contain just enough info to describe what happened
#
What's Next?By now you should be comfortable working with data in the Redux store and React components. So far we've just used data that was in the initial state or added by the user. In Part 5: Async Logic and Data Fetching, we'll see how to work with data that comes from a server API.


Constructor to create a TCData object from a TCModel
is optional
if not undefined, will be used to filter vendor ids
Returns this with fields only
Creates a restrictions object given a TCModel
Creates a string bit field with a value for each id where each value is '1' if its id is in the passed in vector Can be overwritten to return a string
filter
Generated using TypeDoc
TCData response builder


| Class name | Description |
|---|---|
| AssigningClosure |
sealed Class AssigningClosure
|
| ClosureClass |
Class ClosureClass
|
| ClosureTape |
Class ClosureTape
|
| ConstantClosure |
Class ConstantClosure
|
| DynamicClosure |
Interface DynamicClosure
|
| DynamicMessageClosure |
sealed Singleton DynamicMessageClosure
|
| DynamicStruct |
Class DynamicStruct
|
| FunctionClosure |
sealed Class FunctionClosure
|
| GoToClosure |
sealed Class GoToClosure
|
| Group |
Class Group
|
| JumpIfClosure |
sealed Class JumpIfClosure
|
| JumpIfNotClosure |
sealed Class JumpIfNotClosure
|
| JumpToEnd |
sealed Singleton JumpToEnd
|
| LocalClosure |
sealed Class LocalClosure
|
| MessageClosure |
sealed Class MessageClosure
|
| ReleaseClosure |
sealed Class ReleaseClosure
|
| StreamTapeInterpreter |
sealed Singleton StreamTapeInterpreter
|
| Struct |
Class Struct
|
| Symbol name | Description |
|---|---|
| #initializer |
#initializer
|
| Extended class name | Description |
|---|---|
| Object |
Object
|


The goal is to move as fast as possible from start position q_begin to end position q_end under given kinematical constraints. The positions can be translational or rotational definitions (i.e., q_begin/q_end is given). In robotics such a movement is called PTP (Point-To-Point). This source block generates the position q(t), the speed qd(t) = der(q), and the acceleration qdd = der(qd) as output. The signals are constructed in such a way that it is not possible to move faster, given the maximally allowed velocity qd_max and the maximally allowed acceleration qdd_max:
If vectors q_begin/q_end have more than 1 element, the output vectors are constructed such that all signals are in the same periods in the acceleration, constant velocity and deceleration phase. This means that only one of the signals is at its limits whereas the others are synchronized in such a way that the end point is reached at the same time instant.
This element is useful to generate a reference signal for a controller which controls, e.g., a drive train, or to drive a flange according to a given acceleration.


new SFTPClient(config)
Constructor for creating SFTPClient
Parameters:
| Name | Type | Description |
|---|---|---|
config |
* |
Methods
createReadStream()
get a readable stream to remote file
createWriteStream()
get a writable stream to remote file
get(remotepath, localpath, sessionopt)
get remote file and save it locally
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
remotepath |
string | path to remote file | |
localpath |
string | destination path on local filesystem | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
getBuffer(path, sessionopt) → {Promise}
get remote file contents into a Buffer
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
path |
string | on filesystem to stat | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
Returns:
Promise with Buffer on resolve
- Type
- Promise
getStream()
stream file contents from remote file
ls(path, sessionopt) → {Promise}
unix ls -l style return
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
path |
string | on filesystem to stat | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
Returns:
Promise with object describing path
- Type
- Promise
mkdir(path, sessionopt)
makes a directory
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
path |
string | remote directory to be created | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
mv(source, destination, sessionopt)
move remote file from one spot to another
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
source |
string | remote filesystem source path | |
destination |
string | remote filesystem desitnation path | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
put(localpath, remotepath, sessionopt)
put local file in remote path
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
localpath |
string | path to local file | |
remotepath |
string | destination path on remote filesystem | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
putBuffer(buffer, path, sessionopt) → {Promise}
put buffer to remote file
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
buffer |
Buffer | Buffer containing file contents | |
path |
string | on filesystem to stat | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
Returns:
Promise with boolean true if tranfer was successful
- Type
- Promise
putStream()
stream file contents from local file
rm(path, sessionopt)
remove remote file
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
path |
string | remote file to remove | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
rmdir(path, sessionopt)
removes and empty directory
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
path |
string | remote directroy to remove | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
session() → {Promise}
creates a new ssh2 session, short cut for
sshClient = require('ssh2')sshClient
session = new SFTPClient(config)
Returns:
returns a Promse with an ssh2 connection object if resovled
- Type
- Promise
sftpCmd(cmdCB, sessionopt)
Creates connection and promise wrapper for sftp commands
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
cmdCB |
callback | callback for sftp, takes connection, reject and resolve cmb_cb(con, reject,resolve) | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
stat(path, sessionopt) → {Promise}
stat a file or directory
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
path |
string | on filesystem to stat | |
session |
ssh2.Client |
<optional> |
existing ssh2 connection, optional |
Returns:
Promise with object describing path
- Type
- Promise


If you need the what(1) command but it is not available on your platforms, this download contains a Fortran-based version in source form.
What does the what(1) command do? It lets you extract descriptions of files from almost any file type if you place the data in the files using a simple standard convention. This metadata would usually include such information as a short description of the file, an author or originator, a version number, and a revision date. The what(1) command lets you see that metadata even when making a query from a non-compatible system -- without having to execute applications (such as a --help or --version switch on an executable command might provide).
That is, just as you use the file(1) command along with magic(5) strings in your files to identify what types of files you have, you can use the what(1) command to see file-specific information that has been placed in the file.
More specifically, the what(1) command searches through files to find "SCCS identification strings". An SCCS identification string begins with "@(#)" and continues until a non-printable character (including a new-line) is found, or one of the following characters are found: ", > or \,
To get a taste for the power of such a standard as the SCCS identification string, take a directory with some simple scripts or source files in it, enter a short description in a comment of the form
@(#)name - short description
in the script files, and then use what(1) or even "grep '@(#)' *" on the directory. you will get a taste of why adapting a standard description key such as '@(#)' is useful.
If you have built the what(1) command contained in this document, you can display a nicely formatted display in most terminal windows using a command like ...
cd scripts_programming # generate HTML and format it in a terminal window with w3m(1) (or links(1), lynx(1), ...) what * -html -q|w3m -dump -T text/html|more
Or, you could redirect the output into a file and launch a browser to see the file. A sample output run in a small directory of bash(1) shell scripts follows (Note that the files are created as links so you could normally click on the files)):
| ccall |
ccall.sh 1.10 compile,load and install a main program
(C,C++,Fortran, man page, ..). Aware of many programming
environments. |
| errno |
Display C error message 'ENAME' corresponding to number or all
'ENAME's if no number specified. |
| f2f |
call f2f.pl script; which updates F77 with some F90 syntax |
| f90doc |
f90doc(1) wrapper |
| f90tohtml |
call f90tohtml to convert Fortran source to HTML |
| fb90 |
Use emacs(1) to auto-ident free-form Fortran files like cb(1) for C |
| fileinfo |
do an ls(1), file(1), what(1), numdiff(1), size(1), ar(1) and ldd(1) on a file |
| fmkmf |
This is a utility to generate make files for Fortran 90. |
| generate_make |
Program to generate Makefile from *.f and *.f90 files found in the current working directory. |
| html2C |
html2C.sh Strip C from a specially formatted HTML-2 document : 1.0 19960517 John S. Urban |
| html2f |
Strip FORTRAN from specially-formatted HTML document (1.0 19960517 John S. Urban) |
| html2f90 |
Strip FORTRAN90 from specially-formatted HTML document(1.0 19960517 John S. Urban) |
| html2py |
Strip python from specially-formatted HTML document(1.0 20150113 John S. Urban) |
| ldds |
recursive list of dynamic library loads |
| makemake |
Generate a Makefile from the sources in the current directory.
The source files may be in either C, FORTRAN 77, Fortran 90 or
some combination of these languages. Usage: makemake [program_name [F90 compiler or fc or f77 or cc or c]] |
| manf |
edit the Fortran reference manual in text form |
| myflint |
run flint(1) if you have it, or use compiler to emulate it as
much as possible (flint(1) is a Fortran code static checker) |
The what(1) command originated as a part of the source code management system SCCS. When SCCS was the dominant source code management system, the SCCS ID strings automatically generated by the SCCS get(1) command and displayed by the what(1) command became a de-facto standard.
Importantly, because the what(1) command was so useful it was frequently used outside of SCCS.
So the what(1) command was available pre-installed on most Unix platforms for years, as SCCS was once nearly ubiquitous. Unfortunately, the what(1) command is getting harder to find, as the use of SCCS on Linux platforms is not all that common. You can typically install SCCS or a SCCS-like program that comes with what(1) but that is overkill if all you want is what(1). (This is particularly true if you do not use code history utilities, or are already using an alternative (RCS, SVN, git(1), hg(1), ...).
regrettably no strongly supported standard for embedding descriptive information into (almost) all file types (especially object files, libraries, executables and binary data files) has emerged as the availability of the what(1) command has declined.
The related ident(1) command is really part of RCS, and so suffers from the same availability issues as what(1).
The C/C++ "#ident" and "#pragma ident" directives try to provide similar functionality for C, but implementation varies (a lot) between different PE(Programming Environments), and this feature only works for C/C++ code.
Such a standard as the SCCS identification string provides is indispensable for building utilities that allow you to universally track the pedigree of files. It lets you embed keys that a system of other custom utilities can then use to automatically generate file inventories; create indices for software source files, and tie information together via a database that lets you track project releases even when sources are in a variety of languages (Fortran, C/C++, bash, perl, python, javascript, HTML, ...) maintained with a variety of revision control products. That is, essentially every source code and critical data file has a lot of information embedded in it, including a unique key that can be used with a centralized database that lets you quickly tie a file to documentation, contact information, revision history, and so on.
Such stringent tracking requirements are rare, but it is still nice to cd(1) into a directory of scripts, code, and binaries and get a quick TOC(Table of Contents) just by entering something like the what(1) command.
There are other sources for the original what(1) command or look-alikes. My own version is written in Fortran. The major difference between it and the original is that it can generate HTML output. It is a PD (Public Domain) source. It has been tested with gfortran( GNU Fortran (GCC) 4.9.3). It displays user documentation with the --help switch. So you need to grab the WHAT code and M_KRACKEN, M_STRINGS, and M_VERIFY Fortran modules from this site as well to build the application.
Pure metadata is information not used by the system to use the file. Metadata (metacontent) is typically defined as the data providing information about one or more aspects of the data, such as:
It is typically easy to embed SCCS ID strings into text files, often as comments in interpreted files. Compiled programs can be more difficult, as unused strings are often eliminated by compilers during optimization. The help text for the what(1) command gives some tips on working with compiled files.
It is not too difficult to locate and change the metadata string without otherwise changing the file (this will typically work even with binary files). But some files contain checksums or for other reasons cannot easily be changed once created. So if you want to track and update file data that is subject to frequent change consider including a "signature" in the sense of a UUID (Universally Unique ID); and keeping the metadata that has changed in a repository such as an SQLite file. This is particularly useful if ownership or contact information, or production status changes frequently, for example.
The original Dublin Core Metadata Element Set consists of 15 metadata elements:
Wikipedia contains links to more information on the intended meanings of the keywords.
MSWindows executable metadata includes the names:
Other common metadata formats include EXIF, GPS, and IPTC.
Embedding metadata into executable and relocatable files is currently very dependent on the programming environment. When investigating how best to include metadata into such files note that ELF-format files have a metadata section, and many compiled file formats contain a fixed-string section which is often where metadata is stored.
Most Fortran programming environments will process source files through the cpp(1) program or very similar pre-processors if the source files end in ".F90". You may have a Fortran-friendly pre-processor where you do not have to be as careful with quotes and double-slashes ("//"); but even using cpp(1) (which was designed for C and/or C++) you can use the pre-defined __FILE__, __DATE__, __TIME__ macros and the -D switch on cpp(1) to "automatically" generate an up-to-date SCCS ID string. For example:
!=================================================================================================================================== program testit implicit none ! INFO string might be optimized away if not "used" ! uses (predefined) cpp(1) preprocessor macros; ! assumes used -DVERSION='"VALUE"' preprocessor switch character(len=:),parameter ::info='<@(#)'/& &/__FILE__/& &/'::'/& &/__DATE__/& &/' '/& &/__TIME__/& &/'::V'/& &/VERSION/& &/'>' write(*,*)'Hello World!' write(*,*)info end program testit !=============================================================================== ! $ gfortran -DVERSION='"1.2.3"' cpp.F90 -o a.out # note quoting for VERSION ! $ ./a.out # execute program ! Hello World! ! <@(#)cpp.F90::Feb 1 2016 20:00:04::V1.2.3> ! $ what a.out # Run what(1) command on executable ! a.out: ! cpp.F90::Feb 1 2016 20:00:04::V1.2.3 !===================================================================================================================================
The ar(1) command lets you see what files are in an archive file, which is typically the format static libraries take. A simple script lets you combine the output from ar(1) and what(1):
#!/bin/sh #@(#)arwhat.sh:run what(1) on each record in an archive file individually for NAME in $* do ar t $NAME|while read FILE do echo \ ========================================================================================== echo $(ar tv $NAME $FILE) ar p $NAME $FILE|what done done exit


Customizing the License Field¶
In order to add options to the existing ones you need to implement hook_license_subscribe in the following fashion:
// Let's assume we want to do this as part of the fictitious license_options_extra module
function license_options_extra_license_subscribe() {
return array(
'tcl' => array(
'label' => 'Talis Community License (TCL)',
'uri' => 'http://opendefinition.org/licenses/tcl/',
),
);
}
The code above add the Talis Community License (TCL) license referencing it to the tcl key. It also provides a link to the license (optional). You can provide as many options as you want through the array being returned.
Removing License Options¶
In order to remove options from the existing ones you need to implement hook_license_unsubscribe in the following fashion:
// Let's assume we want to do this as part of the fictitious license_options_extra module
function license_options_extra_license_unsubscribe() {
return array(
'notspecified',
);
}
The code above removes the notspecified option. You can provide as many options as you want through the array being returned.
Additional notes about the behavior of both hooks¶
- The options provided through the license drupal field configuration are COMPLETELY ignored.
hook_license_subscribe()
implementations are of course called beforehook_license_unsubscribe()
implementations.- Options subscribed through
hook_license_subscribe()
are processed as they come through the order of modules provided by the drupal registry. - If multiple options are provided using the same key then it grabs the first one that comes in and ignores the rest
- If you want to replace and item that already exists, unsubscribe the existing key and provided an alternative one for your option


last reviewed October 9, 2008
This documents the data files included in the Cloudy data distribution. Those instructions for setting up the code are on the web site.
Three types of files are present in this directory.
*.ini These are files that are used to set up Cloudy. You can change these files to alter the code's default behavior. These can, for instance, change the continuum resolution or add new entries into the main emission-line output.
*.dat These are the foundation atomic/molecular data files that are needed for the code to operate. Do not change these files.
*.in These are input scripts that are used to compile various helper files such as stellar atmospheres or types of grains.
The download includes all the files you will need to get Cloudy running. The download does not include the stellar continua file that are needed for the table stars command to work. The web site describes how to set up these continua and this only needs to be done if you want to use the table stars command. Several input files (names like compile*.in) are examples of compiling some of the stellar continua.
It is easy to create new grain tipes. Compiled opacities are already included in the data files (the *.opc files), so nothing need be done if you are happy with the default setup. They would need to be recompiled if you change the energy grid of the code, or wish to use a different grain refractive index or size distribution. Distributed grains are new in C96 and were added in collaboration with Peter van Hoof and Peter G. Martin. These use optical properties for each grain material (the *.rfi files) and size distribution files (the *.szd files) to create grain opacities (the *.opc files) that are a function of grain material and size. The code can then do a more realistic simulation of the grain emission and physics
compilegrains.in - This will compile all the standard grains.
compile1grain.in - example of compiling a single grain type for the pgrains command to use.
vanhoof_grain_model.pdf - is a document written by Peter van Hoof which describes the file formats esed to specify grain properties.
These files specify the size distribution (*.szd) and refractive indices (*.rfi) for the new treatment of grain physics that is used with the pgrains command. The *.opc files give the actual opacities used by the code.
These are a series of files that add commands to the input stream when you run a model. They are added by including an init command that names one of the following files.
c84.ini - makes code behave
more like version 84
fast.ini - this includes several commands that make the code run faster, at the
expense of a less accurate simulation
honly.ini - hydrogen only init
file
hheonly.ini - init file for H,
He only
ism.ini turns off level 2
lines and only includes prominent elements for depleted mixture. NB
This does not
add grains to the mix even though many elements are strongly depleted. This is not consistent, and so grains should be added separately.
pdr_leiden.ini and pdr_leiden_hack.ini are used to compute the PDR models given
in Roellig et al.,
The data file FeII_bands.ini is used to specify a series of FeII bands that are entered into the main emission line output. These bands are described further in the dat file and in the part of Hazy where FeII is discussed.
The data file continuum_bands.ini is used to define a series of wavelength bands. Each band has a lower and upper wavelength and the code will integrate all emission over these bands. The total luminosity or intensity is entered into the main emission line output.
These are the default lists of emission lines that can be read into arrays of emission lines by calling cdGetLineList. This is useful when the code is being called as a subroutine of other larger codes, as a way to obtain a list of emission lines whose intensities are to be extracted from the calculation. This process is described in the section of a later part of Hazy on calling Cloudy as a subroutine. These files are meant to be changed by the user.
The files have names LineList*.dat and the end of the filename indicates the purpose. At present the lists are the following:
LineList_BLR.dat - lines seen in the spectra of BLR of AGN
LineList_NLR.dat - lines seen in the spectra of NLR of AGN
LineList_HII.dat - lines for HII Regions
LineList_strong.dat - a minimarl list of emission lines
LineList_PDR.dat - a list of PDR lines
LineList_PDR_H2.dat - a PDR line list with many H2 lines from the large molecule
LineList_HeH.dat - a set of H and He emission lines
LineList_He_like.dat - lines for the He-like iso sequence
Some line wavelengths may change over time as the accuracy of energy levels improve. The "table lines name.dat" command is used to check that that the lines in the file name.dat are still correct. Any line list file that is included here in the data director should also be included in an one of the test cases in the test suite.
The file continuum_mesh.ini contains data the defines the continuum mesh used during a calculation. It is possible to make the continuum have any resolution at all by changing this file. The continuum resolution largely sets the execution time so be careful. The file contains documentation of its use.
The files HS_e1b.dat through HS_e8b.dat, and HS_e1a.dat through HS_e8a.dat are from Storey P.J., Hummer D.G.
1995, MNRAS 272, 41
http://adc.gsfc.nasa.gov/adc-cgi/cat.pl?/catalogs/6/6064/
The files mewe_fluor.dat and mewe_nelectron.dat are tables 2 and 3 of the atomic data from Kaastra, J.S., & Mewe, R., 1993, A&AS, 97, 443
The file mewe_gbar.dat is the Mewe data files for g-bar collision strengths.
Three files contain the data needed to set up the large FeII model ion, described in Verner et al. (1999, ApJS 120, 101. The data formats are described following the name of the file and the reference for the data it contains.
This file contains Einstein transition probabilities. The original data sources are given in the header of this file.
lower level number
upper level number
lower level statistical weight
upper level statistical weight
Einstein A coefficient, s**(-1)
Energy, cm**(-1)
type of transition (1 - allowed, 2 - semiforbidden, 3 - forbidden)
This file contains collision data. These data are from Zhang & Pradhan (1995; A&A 293, 953), Bautista (private communication), and the g-bar approximation (Mewe 1972; A&AS 20, 215).
lower level number in Zhang and Pradhan notation, from 1 to 141
upper level number in Zhang and Pradhan notation, from 2 to 142
collision strengths at 20 temperatures,
1e3,3e3,5e3,7e3,1e4,12e3,15e3,17e3,2e4,25e3,3e4,35e3,4e4,45e3,5e4,6e4,7e4,8e
4,9e4,1e5
nn(142) - actual level numbers for each of Zhang and Pradhan levels
This gives the energy levels in increasing order.
collision rates for various projectiles striking H2
H2_coll_H.dat
H2_coll_H2ortho.dat
H2_coll_H2para.dat
H2_coll_He.dat
H2_coll_He_Stancil.dat
H2_coll_Hp.dat
dissociation probabilities for various electronic configurations of H2
H2_dissprob_B.dat
H2_dissprob_B_primed.dat
H2_dissprob_C_minus.dat
H2_dissprob_C_plus.dat
H2_dissprob_D_minus.dat
H2_dissprob_D_plus.dat
energies for various electronic configurations of H2
H2_energy_B.dat
H2_energy_B_primed.dat
H2_energy_C_minus.dat
H2_energy_C_plus.dat
H2_energy_D_minus.dat
H2_energy_D_plus.dat
H2_energy_X.dat
distribution functions for populating levels of H2 following
formation from H-
H2_hminus_deposit.dat
transition probabilities between various configurations of H2
H2_transprob_B.dat
H2_transprob_B_primed.dat
H2_transprob_C_minus.dat
H2_transprob_C_plus.dat
H2_transprob_D_minus.dat
H2_transprob_D_plus.dat
H2_transprob_X.dat
There are three, all with names UTA*.dat. These are the following
UTA_Behar.dat - from Behar et al. 2001, ApJ, 563, 497. These had been
the default for Fe0 through Fe+12.
UTA_Gu06.dat - from Gu et al. ApJ, 641, 1227. These are now the default
for Fe0 through Fe+12.
UTA_Kisielius.dat - from Kisielius et al. MNRAS 344, 696, used for Fe+13
- Fe+15.
level1.dat, the main set of level 1 lines, this file is designed to be edited by humans.
level2.dat, the level 2 lines, do not edit this file!
Visit www.nublado.org for more details and the latest updates.
Good luck!
Gary J. Ferland


Nipin Varshney
SAP Solution Architect
Nipin Varshney is a Solution Architect with Ketch and is responsible for leading our teams to deliver client solutions including mobility, HANA with their applications in supply chain of an organization. Mr. Varshney has over 20 years of experience in diverse industries and brings a unique blend of methodology, experience and expertise in multiple areas of SAP.


this chart
, {{packageItem}}
No packages selected.
Why not try
compare fetching package release dates.. {{ moduleName }} ({{ packagesBundleSizesResponse[moduleName]["gzip"] }} gzipped)
No packages selected.
Why not try


MEET THE TEAM
APP-LEGENDS TEAM
A perfect blend of creativity and technical wizardry. The best people
formula for great websites! We are a mix of geeks and very creative
people.
WHO WE ARE?
we are 201 coarse students of web development at ASAC , we believe
that good design is powerful, hard work is essential, and exploring
the unknown is important.
We've had an amazing journey coming to where are today, and now feel confident that we can provide you a professional and effective sites in a timely manner . we have extensive skills in the following areas:
- 1. creating clean, accessible HTML
- 2. writing CSS to make your site look beautiful
- 3. writing functional, useful, innovative web applications from the ground up using these skills.
The Experience Of Working Together As A Team
During this 201 project,, We all worked together to plan and manage
the implementation schedule, We were each assigned different sectors
to focus on, and we helped each other out if we were having any
difficulties. we really appreciated the way we worked together. Our
team always completed our tasks ahead of schedule with very positive
reviews from our instructor. Our ability to communicate effectively
was what made us such a good team. People expressed concerns clearly
and openly, so we resolved issues as soon as they arose.


TriggerAdapter
An adapter for the trigger interface that allows to use the ResultSet
interface instead of a row array.
| Methods |
| void |
close()
This method is called when the trigger is dropped.
|
| void |
close() throws SQLException
This method is called when the trigger is dropped.
The default implementation does nothing.
Throws:
SQLException
|
| void |
fire(Connection conn, Object[] oldRow, Object[] newRow)
This method is called for each triggered action.
|
| void |
fire(Connection conn, Object[] oldRow, Object[] newRow) throws SQLException
This method is called for each triggered action. The method is called
immediately when the operation occurred (before it is committed). A
transaction rollback will also rollback the operations that were done
within the trigger, if the operations occurred within the same database.
If the trigger changes state outside the database, a rollback trigger
should be used.
The row arrays contain all columns of the table, in the same order
as defined in the table.
The default implementation calls the fire method with the ResultSet
parameters.
Parameters:
conn - a connection to the database
oldRow - the old row, or null if no old row is available (for
INSERT)
newRow - the new row, or null if no new row is available (for
DELETE)
Throws:
SQLException - if the operation must be undone
|
| void |
fire(Connection conn, ResultSet oldRow, ResultSet newRow)
This method is called for each triggered action by the default
fire(Connection conn, Object[] oldRow, Object[] newRow) method.
|
| void |
fire(Connection conn, ResultSet oldRow, ResultSet newRow) throws SQLException
This method is called for each triggered action by the default
fire(Connection conn, Object[] oldRow, Object[] newRow) method.
ResultSet.next does not need to be called (and calling it has no effect;
it will always return true).
For "before" triggers, the new values of the new row may be changed
using the ResultSet.updateX methods.
Parameters:
conn - a connection to the database
oldRow - the old row, or null if no old row is available (for
INSERT)
newRow - the new row, or null if no new row is available (for
DELETE)
Throws:
SQLException - if the operation must be undone
|
| void |
init(Connection conn, String schemaName, String triggerName, String tableName, boolean before, int type)
This method is called by the database engine once when initializing the
trigger.
|
| void |
init(Connection conn, String schemaName, String triggerName, String tableName, boolean before, int type) throws SQLException
This method is called by the database engine once when initializing the
trigger. It is called when the trigger is created, as well as when the
database is opened. The default implementation initialized the result
sets.
Parameters:
conn - a connection to the database
schemaName - the name of the schema
triggerName - the name of the trigger used in the CREATE TRIGGER
statement
tableName - the name of the table
before - whether the fire method is called before or after the
operation is performed
type - the operation type: INSERT, UPDATE, DELETE, SELECT, or a
combination (this parameter is a bit field)
|
| void |
remove()
This method is called when the database is closed.
|
| void |
remove() throws SQLException
This method is called when the database is closed.
If the method throws an exception, it will be logged, but
closing the database will continue.
The default implementation does nothing.
Throws:
SQLException
|
|


GOOGLE INC
Location:
Duration:
Company:
Title: Full Stack Developer
Posted: 25days
Reference: Directory Jobs
Contact: Directory Jobs
Job ID: 45676536
Tel: +2348092205000 | Website: ST.com | E-mail<EMAIL_ADDRESS>Due to industry growth, we now have a requirement for 3 Full Stack developers to come in and build on their expertise in the Industry and complement the existing team. Key responsibilities: ·work within a team environment ·stay up to date with the latest technological developments ·Assist in software deployments and releases


I talked to Sarah B at The Hechinger Report about who’s building and how schools are buying ed-tech
I voted
I talked to Chuck R for an upcoming episode of his and Ryan A’s podcast
I started working on a talk I’ll deliver in Edinburgh
Travel
Nope, although Kin was out-of-town
Upcoming week: No travel
Reading and Viewing
I read Binti and Binti: Home
I watched Captain Fantastic and Moana
I watched my friend Tressie on The Daily Show
We were supposed to go hear live music last night, but we decided we were old and there was a bit of weird drama that neither of us had the stamina for
"Tweet of the Week"
I tweeted a story about my experiences dealing with a medical crisis in a pre-Affordable Care Act world. I’m going to create a separate article with all these tweets – screenshotted. I’m debating nuking my all my tweets. That’s a story for another article too.


|
BTK
0.3dev.0
Open-source library to visualize/process biomechanical data
|
Functional calibration procedure based on Gamage and Lasenby (2002). More...
Public Types | |
| typedef SharedPtr< const Gamage2002FunctionalJointCalibrationProcedure > | ConstPointer |
| typedef SharedPtr < Gamage2002FunctionalJointCalibrationProcedure > | Pointer |
| Public Types inherited from btk::CalibrationProcedure | |
| typedef SharedPtr< const CalibrationProcedure > | ConstPointer |
| typedef SharedPtr < CalibrationProcedure > | Pointer |
Public Member Functions | |
| virtual BTK_MODELS_EXPORT void | Run (Model::Pointer output, Acquisition::Pointer input, LandmarksTranslator::Pointer lt, bool risd=false) const |
Static Public Member Functions | |
| static Pointer | New (const std::string &jointLabel, const std::vector< std::string > &markers) |
| static Pointer | New (const std::string &jointLabel, const char **markersLabel, int markersNum) |
Protected Member Functions | |
| Gamage2002FunctionalJointCalibrationProcedure (const std::string &jointLabel, const std::vector< std::string > &markers) | |
| Gamage2002FunctionalJointCalibrationProcedure (const std::string &jointLabel, const char **markersLabel, int markersNum) | |
| Protected Member Functions inherited from btk::CalibrationProcedure | |
| CalibrationProcedure () | |
Functional calibration procedure based on Gamage and Lasenby (2002).
This calibration procedure use the motion of the proximal segment and the markers attached on the distal segment. The proximal segment used is selected by the joint's label given to the static methods New. The markers used are selected by the given labels to the static methods New.
Smart pointer associated with a const Gamage2002FunctionalJointCalibrationProcedure object.
Smart pointer associated with a Gamage2002FunctionalJointCalibrationProcedure object.
|
inlineprotected |
Constructor.
|
inlineprotected |
Constructor.
|
inlinestatic |
Creates a smart pointer associated with a Gamage2002FunctionalJointCalibrationProcedure object.
|
inlinestatic |
Creates a smart pointer associated with a Gamage2002FunctionalJointCalibrationProcedure object.
|
virtual |
Calibrate the model.
Reimplemented from btk::CalibrationProcedure.


Login
Sign Up
Enter your personal details
to create an acount
Create Account
Enter your email and password
to sign in
Show
Login


Address: No.100, Pingleyuan, Chaoyang District, Beijing City, China
Email<EMAIL_ADDRESS><EMAIL_ADDRESS>Phone: +86-18310490075
Ke Gu received the B.S. and Ph.D. degrees in electronic engineering from Shanghai Jiao Tong University, Shanghai, China, in 2009 and 2015, respectively. He is currently a Professor with the Beijing University of Technology, Beijing, China.
His research interests include image analysis, environmental perception, quality assessment, and machine learning. He received the Best Paper Award from the IEEE Transactions on Multimedia (T-MM), the Best Student Paper Award at the IEEE International Conference on Multimedia and Expo (ICME) in 2016, and the Excellent Ph.D. Thesis Award from the Chinese Institute of Electronics (CIE) in 2016.
He was the Leading Special Session Organizer in the VCIP2016 and the ICIP2017, and serves as a Guest Editor for the Digital Signal Processing Journal. He is currently an Associate Editor of the IEEE ACCESS and the IET Image Processing. He is a Reviewer for 20 top SCI journals.
Highly efficient picture-based prediction of PM2.5 concentration
Ke Gu, Junfei Qiao,Xiaoli Li
In IEEE Transactions on Industrial Electronics (T-IE), 2018
Objective quality evaluation of dehazed images
Xiongkuo Min, Guangtao Zhai, Ke Gu, Xiaokang Yang, Xinping Guan
In IEEE Transactions on Intelligent Transportation Systems (T-ITS), 2018
Blind quality assessment of camera images based on low-level and high-level statistical features
Yutao Liu, Ke Gu (Corresponding Author), Shiqi Wang, Debin Zhao, Wen Gao
In IEEE Transactions on Multimedia (T-MM), 2018
Analysis of textural and structural characteristics for quality assessment of hybrid distorted images
Guanghui Yue, Chunping Hou, Ke Gu(Corresponding Author), Nam Ling
In IEEE Transactions on Multimedia(T-MM), 2018
Blind quality index for multiply distorted images using bi-order structure degradation and nonlocal statistics
Yu Zhou, Leida Li, Ke Gu, Weisheng Dong, Guangming Shi
In IEEE Transactions on Multimedia (T-MM), 2018
Partial-reference sonar image quality assessment for underwater transmission
Weiling Chen, Ke Gu, Xiongkuo Min, Fei Yuan, En Cheng, Wenjun Zhang
In IEEE Transactions on Aerospace and Electronic Systems (T-AES), 2018
Blind image quality estimation via distortion aggravation
Xiongkuo Min, Guangtao Zhai, Ke Gu, Yutao Liu, Xiaokang Yang
In IEEE Transactions on Broadcasting (T-BC), 2018
Biologically inspired blind quality assessment of tone-mapped images
Guanghui Yue, Chunping Hou, Ke Gu(Corresponding Author) , Shasha Mao, Wenjun Zhang
In IEEE Transactions on Industrial Electronics(T-IE), 2018,pdf
Adaptive levenberg-marquardt algorithm based echo state network for chaotic time series prediction
Qiao Junfei, Lei Wang, Cuili Yang, Ke Gu
In Neurocomputing, 2018
Analysis of structural characteristics for quality assessment of multiply distorted images
Guanghui Yue, Chunping Hou, Ke Gu (Corresponding Author), Nam Ling
In IEEE Transactions on Multimedia (T-MM), 2018
Saliency-induced reduced-reference quality index for natural scene and screen content images
Xiongkuo Min, Ke Gu, Guangtao Zhai, Menghan Hu, Xiaokang Yang
In Signal Processing(CGA), 2018
Reduced- reference image quality assessment in free-energy principle and sparse representation
Yutao Liu, Guangtao Zhai, Ke Gu, Xianming Liu, Debin Zhao, Wen Gao
In IEEE Transactions on Multimedia(T-MM), 2018,pdf
Quality assessment of DIBR- synthesized images by measuring local geometric distortions and global sharpness
Leida Li, Yu Zhou, Ke Gu, Weisi Lin, Shiqi Wang
In IEEE Transactions on Multimedia(T-MM), 2018,pdf
Optimizing multi-stage discriminative dictionaries for blind image quality assessment
Qiuping Jiang, Feng Shao, Weisi Lin, Ke Gu, Gangyi Jiang, Huifang Sun
In IEEE Transactions on Multimedia(T-MM), 2018,pdf
Objective quality assessment and perceptual compression of screen content images
Shiqi Wang, Ke Gu, Kai Zeng, Zhou Wang, Weisi Lin
In IEEE Computer Graphics and Applications(CGA), 2018
Blind quality assessment based on pseudo reference image
Xiongkuo Min, Ke Gu, Guangtao Zhai, Jing Liu, Xiaokang Yang, Chang Wen Chang
In IEEE Transactions on Multimedia(T-MM), 2018,pdf
A prediction backed model for quality assessment of screen content and 3D synthesized images
Vinit Jakhetiya, Ke Gu(Corresponding Author), Weisi Lin, Qiaohong Li, Sunil Prasad Jaiswal
In IEEE Transactions on Industrial Informatics(T-II), 2018,pdf
Just noticeable difference for natural images using RMS contrast and feed-back mechanism
Vinit Jakhetiya, Weisi Lin, Sunil Jaiswal, Ke Gu, Sharath Chandra Guntuku
In Neurocomputing(T-II), 2018
Recurrent air quality predictor based on meteorology- and pollution-related factors
Ke Gu, Junfei Qiao, Weisi Lin
In IEEE Transactions on Industrial Informatics(T-II), 2018,pdf
Reduced-reference quality assessment of screen content images
Shiqi Wang, Ke Gu, Xinfeng Zhang, Weisi Lin, Siwei Ma, Wen Gao
In IEEE Transactions on Circuits and Systems for Video Technology(T-CSVT), 2018,pdf
A blind quality measure for industrial 2D matrix symbols using shallow convolutional neural network
Zhaohui Che, Guangtao Zhai, Jing Liu, Ke Gu, Patrick Le Callet, Jiantao Zhou, Xianming Liu
In International Conference on Image Processing (ICIP), 2018
Adaptive screen content image enhancement strategy using layer-based segmentation
Zhaohui Che, Guangtao Zhai, Ke Gu, Patrick Le Callet, Xianming Liu, Deming Zhai, Xiao Gu
In IEEE International Symposium on Circuits and Systems (ISCAS), 2018
Using multiscale analysis for blind quality assessment of DIBR-synthesized images
Ke Gu, Junfei Qiao, Patrick Le Callet, Zhifang Xia, Weisi Lin
In IEEE International Conference on Image Processing(ICIP), 2018,pdf
Reduced-reference quality metric of screen content image
Zhaohui Che, Guangtao Zhai, Ke Gu, Patrick Le Callet
In IEEE International Conference on Image Processing(ICIP), 2018
Perceptual evaluation of single-image super-resolution reconstruction
Guangcheng Wang, Leida Li, Qiaohong Li, Ke Gu, ZhaoLin Lu, Jiansheng Qian
In IEEE International Conference on Image Processing(ICIP), 2018
Foveated nonlocal dual denoising
Tao Dai, Ke Gu, Qingtao Tang, Kwok-Wai Hung, Yong-Bing Zhang, Shu-Tao Xia
In IEEE International Conference on Image Processing(ICIP), 2018
CVIQD: Subjective quality evaluation of compressed virtual reality images
Wei Sun, Ke Gu, Guangtao Zhai, Siwei Ma, Weisi Lin, Patrick Le Callet
In IEEE International Conference on Image Processing(ICIP), 2018
Blind quality assessment of multiply-distorted images based on structural degradation
Tao Dai, Ke Gu, Zhi-Ya Xu, Qingtao Tang, Haoyi Liang, Yong-bing Zhang, Shu-Tao Xia
In IEEE International Conference on Image Processing(ICIP), 2018
No-reference image quality assessment with center-surround based natural scene statistics
Jun Wu, Zhaoqiang Xia, Huifang Li, Kezheng Sun, Ke Gu, Hong Lu
In Multimedia Tools and Applications(MTAP), 2017
No-reference quality metric of contrast-distorted images based on information maximization
Ke Gu, Weisi Lin, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang, Chang Wen Chen
In IEEE Transactions on Cybernetics(T-CYB), 2017,pdf
Unified Blind Quality Assessment of Compressed Natural, Graphic, and Screen Content Images
Xiongkuo Min, Kede Ma, Ke Gu, Guangtao Zhai, Zhou Wang, Weisi Lin
In IEEE Transactions on Image Processing(T-IP), 2017,pdf
Evaluating quality of screen content images via structural variation analysis
Ke Gu, Junfei Qiao, Xiongkuo Min, Guanghui Yue, Weisi Lin, Daniel Thalmann
In IEEE Transactions on Visualization and Computer Graphics(T-VCG), 2017,pdf
No reference image blurriness assessment with local binary patterns
Guanghui Yue, Chunping Hou, Ke Gu, Nam Ling
In Journal of Visual Communication and Image Representation(JVCI), 2017
An efficient and effective blind camera image quality metric via modeling quaternion wavelet coefficients
Lijuan Tang, Leida Li, Kezheng Sun, Zhifang Xia, Ke Gu, Jiansheng Qian
In Journal of Visual Communication and Image Representation(JVCI), 2017
Quality assessment of DIBR-synthesized images by measuring local geometric distortions and global sharpness
Leida Li, Yu Zhou, Ke Gu, Weisi Lin, Shiqi Wang
In IEEE Transactions on Multimedia (T-MM), 2017
Visual attention analysis and prediction on human faces
Xiongkuo Min, Guangtao Zhai, Ke Gu, Jing Liu, Shiqi Wang, Xinfeng Zhang, Xiaokang Yang
In Information Sciences(InS), 2017
Unified blind quality assessment of compressed natural, graphic and screen content images
Xiongkuo Min, Kede Ma, Ke Gu, Guangtao Zhai, Zhou Wang, Weisi Lin
In IEEE Transactions on Image Processing (T-IP), 2017
No-reference quality assessment of screen content pictures
Ke Gu, Jun Zhou, Junfei Qiao, Guangtao Zhai, Weisi Lin, Alan Conrad Bovik
In IEEE Transactions on Image Processing(T-IP), 2017,pdf
DIBR-synthesized image quality assessment via statistics of edge intensity and orientation
Yu Zhou, Leida Li, Ke Gu, Zhaolin Lu, Beijing Chen, Lu Tang
In IEICE Transactions on Information and Systems(T-IS), 2017
Model-based referenceless quality metric of 3D synthesized images using local image description
Ke Gu, Vinit Jakhetiya, Junfei Qiao, Xiaoli Li, Weisi Lin, Daniel Thalmann
In IEEE Transactions on Image Processing(T-IP), 2017,pdf
Reduced-reference image quality assessment in free-energy principle and sparse representation
Yutao Liu, Guangtao Zhai, Ke Gu, Xianming Liu, Debin Zhao, Wen Gao
In IEEE Transactions on Multimedia (T-MM), 2017
A fast reliable image quality predictor by fusing micro- and macro-structures
Ke Gu, Leida Li, Hong Lu, Xiongkuo Min, Weisi Lin
In IEEE Transactions on Industrial Electronics(T-IE), 2017,pdf
Object tracking based on stable feature mining using intraframe clustering and interframe association
Hong Lu, Ke Gu(Corresponding Author), Weisi Lin, Wenjun Zhang
In IEEE Access, 2017
Towards efficient blind quality evaluation of screen content images based on edge-preserving filter
Jiansheng Qian, Lijuan Tang, Vinit Jakhetiya, Zhifang Xia, Ke Gu, Hong Lu
In Electronics Letters(ELL), 2017
Learning a no-reference quality assessment model of enhanced images with big data
Ke Gu, Dacheng Tao, Junfei Qiao, Weisi Lin
In IEEE Transactions on Neural Networks and Learning Systems(T-NNLS), 2017,pdf
Perceptual reduced-reference visual quality assessment for contrast alteration
Min Liu, Ke Gu(Corresponding Author), Guangtao Zhai, Patrick Le Callet, Wenjun Zhang
In IEEE Transactions on Broadcasting(T-BC), 2017,pdf
Training-free referenceless camera image blur assessment via hypercomplex singular value decomposition
Lijuan Tang, Qiaohong Li, Leida Li, Ke Gu, Jiansheng Qian
In Multimedia Tools and Applications(MTAP), 2017
No-reference quality assessment of deblurred images based on natural scene statistics
Leida Li, Ya Yan, Zhaolin Lu, Jinjian Wu, Ke Gu, Shiqi Wang
In IEEE Access(T-II), 2017
Fixation prediction through multimodal analysis
Xiongkuo Min, Guangtao Zhai, Chunjia Hu, Ke Gu
In ACM Transactions on Multimedia Computing, Communications, and Applications(TOMM), 2017,pdf
Movie piracy tracking using temporal psychovisual modulation
Yuanchun Chen, Guangtao Zhai, Zhongpai Gao, Ke Gu, Wenjun Zhang
In IEEE International Symposium on Broadband Multimedia Systems and Broadcasting(BMSB), 2017
No-reference quality assessment for JPEG compressed images
Yucheng Zhu, Guangtao Zhai, Ke Gu, Wenhan Zhu
In IEEE Workshop on Quality of Multimedia Experience(QoMEX), 2017,pdf
Stable feature mining based object representation for tracking application
Hong Lu, Ke Gu
In IEEE International Congress on Image and Signal Processing, BioMedical Engineering and Informatics(CISP-BMEI), 2017
Camera image quality assessment without reference information
Lijuan Tang, Hong Lu, Ke Gu
In IEEE International Congress on Image and Signal Processing, BioMedical Engineering and Informatics(CISP-BMEI), 2017
Information security display system on android device
Yuanchun Chen, Liu Ning, Guangtao Zhai, Zhongpai Gao, Ke Gu
In IEEE International Technical Conference of IEEE Region 10(TENCON), 2017,pdf
No-reference quality assessment for image sharpness and noise
Lijuan Tang, Xiongkuo Min, Vinit Jakhetiya, Ke Gu, Xinfeng Zhang,Shuai Yang
In APSIPA ASC, 2017,pdf
Transform-domain in-loop filter with block similarity for HEVC
Xinfeng Zhang, Weisi Lin, Ke Gu, Qiaohong Li, Shanshe Wang, Siwei Ma
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2017
Quality assessment for dual-view display system
Yuanchun Chen, Ning Liu, Guangtao Zhai, Ke Gu, Jia Wang, Zhongpai Gao, Yucheng Zhu
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2017,pdf
Exploiting neural models for no-reference image quality assessment
Cenhui Pan, Yi Xu, Yichao Yan, Ke Gu, Xiaokang Yang
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2017,pdf
A reduced-reference quality assessment scheme for blurred images
Zongxi Han, Guangtao Zhai, Yutao Liu, Ke Gu, Xinfeng Zhang
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2017,pdf
Just-noticeable difference based perceptual optimization for JPEG compression
Xinfeng Zhang, Shiqi Wang, Ke Gu, Weisi Lin, Siwei Ma, Wen Gao
In IEEE Signal Processing Letters (SPL), 2016
Naturalization of screen content images for enhanced quality evaluation
Xingge Guo, Liping Huang, Ke Gu, Leida Li, Zhili Zhou, Lu Tang
In IEICE Transactions on Information and Systems(T-IS), 2016
No-reference quality assessment of enhanced images
Leida Li, Wei Shen, Ke Gu, Jinjian Wu, Beijing Chen, Jianying Zhang
In China Communications(CC), 2016
Blind quality index for camera images with natural scene statistics and patch-based sharpness assessment
Lijuan Tang, Leida Li, Ke Gu, Xingming Sun, Jianying Zhang
In Journal of Visual Communication and Image Representation(JVCI), 2016,pdf
Subjective and objective quality assessment of compressed screen content images
Shiqi Wang, Ke Gu, Xiang Zhang, Weisi Lin, Li Zhang, Siwei Ma, Wen Gao
In IEEE Journal on Emerging and Selected Topics in Circuits and Systems(J-ETCAS), 2016,pdf
Learning a blind quality evaluation engine of screen content images
Ke Gu, Guangtao Zhai, Weisi Lin, Xiaokang Yang, Wenjun Zhang
In Neurocomputing, 2016,pdf
Content-weighted mean-squared error for quality assessment of compressed images
Ke Gu, Shiqi Wang, Guangtao Zhai, Siwei Ma, Xiaokang Yang, Wenjun Zhang
In Signal, Image and Video Processing(SIVP), 2016,pdf
Analysis of distortion distribution for pooling in image quality prediction
Ke Gu, Shiqi Wang, Guangtao Zhai, Weisi Lin, Xiaokang Yang, Wenjun Zhang
In IEEE Transactions on Broadcasting(T-BC), 2016,pdf
Saliency-guided quality assessment of screen content images
Ke Gu, Shiqi Wang, Huan Yang, Weisi Lin, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE Transactions on Multimedia(T-MM), 2016,Top 1 Cited Paper of T-MM in 2016, pdf
Blind quality assessment of tone-mapped images via analysis of information, naturalness and structure
Ke Gu, Shiqi Wang, Guangtao Zhai, Siwei Ma, Xiaokang Yang, Wei Lin, Wenjun Zhang, Wen Gao
In IEEE Transactions on Multimedia(T-MM), 2016,Top 4 Cited Paper of T-MM in 2016, pdf
The analysis of image contrast: From quality assessment to automatic enhancement
Ke Gu, Guangtao Zhai, Weisi Lin, Min Lin
In IEEE Transactions on Cybernetics(T-CYB), 2016,ESI Highly Cited Paper & Top 8 Cited Paper of T-CYB in 2016, pdf
Visual saliency detection via image complexity feature
Min Liu, Ke Gu, Guangtao Zhai, Patrick Le Callet
In IEEE International Conference on Image Processing(ICIP), 2016,pdf
Quality assessment of 3d synthesized images via disoccluded region discovery
Yu Zhou, Leida Li, Ke Gu, Yuming Fang, Weisi Lin
In IEEE International Conference on Image Processing(ICIP), 2016,pdf
No-reference quality assessment of camera-captured images
Lijuan Tang, Leida Li, Ke Gu, Jiansheng Qian, Jianying Zhang
In Pacific-Rim Conference on Multimedia(PCM), 2016,pdf
Blind quality assessment of compressed images via pseudo structural similarity
Xiongkuo Min, Guangtao Zhai, Ke Gu, Yuming Fang, Xiaokang Yang, Xiaolin Wu, Jiantao Zhou, Xianming Liu
In IEEE International Conference on Multimedia and Expo(ICME), 2016,pdf
Quality assessment of contrast-altered images
Min Liu, Ke Gu, Guangtao Zhai, Jiantao Zhou, Weisi Lin
In International Symposium on Circuits and Systems(ISCAS), 2016,pdf
Blindly evaluating stereoscopic image quality with free-energy principle
Yucheng Zhu, Guangtao Zhai, Ke Gu, Min Liu
In International Symposium on Circuits and Systems(ISCAS), 2016,pdf
Stereoscopic image quality assessment with the dual-weight model
Yucheng Zhu, Guangtao Zhai, Ke Gu, Zhaohui Che, Duo Li
In IEEE International Symposium on Broadband Multimedia Systems and Broadcasting(BMSB), 2016,pdf
Perceptually meaningful quadtree decomposition using dual-homogeneous criteria
Zhaohui Che, Guangtao Zhai, Ke Gu, Yucheng Zhu
In IEEE International Symposium on Broadband Multimedia Systems and Broadcasting(BMSB), 2016,pdf
Closing the gap: Visual quality assessment considering viewing conditions
Yucheng Zhu, Guangtao Zhai, Ke Gu, Zhaohui Che
In IEEE Workshop on Quality of Multimedia Experience(QoMEX), 2016,pdf
No-reference image quality assessment for photographic images of consumer device
Yucheng Zhu, Guangtao Zhai,Ke Gu, Zhaohui Che
In International Conference on Acoustics, Speech and Signal Processing(ICASSP), 2016,pdf
Visual attention on human face
Xiongkuo Min, Guangtao Zhai, Ke Gu
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2016,pdf
Fixation prediction through multimodal analysis
Xiongkuo Min, Guangtao Zhai, Chunjia Hu, Ke Gu
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2016,pdf
Sparse structural similarity for objective image quality assessment
Xiang Zhang, Shiqi Wang, Ke Gu, Tingting Jiang, Siwei Ma, Wen Gao
In IEEE International Conference on Systems, Man, and Cybernetics(SMC), 2016,pdf
Guided image contrast enhancement based on retrieved images in cloud
Shiqi Wang, Ke Gu, Siwei Ma, Weisi Lin, Xianming Liu, Wen Gao
In IEEE Transactions on Multimedia(T-MM), 2015,pdf
Visual Saliency Detection With Free Energy Theory
Ke Gu, Guangtao Zhai, Weisi Lin, Xiaokang Yang, Wenjun Zhang
In IEEE Signal Processing Letters(SPL), 2015,pdf
No-Reference Image Sharpness Assessment in Autoregressive Parameter Space
Ke Gu, Guangtao Zhai, Weisi Lin, Xiaokang Yang, Wenjun Zhang
In IEEE Transactions on Image Processing(T-IP), 2015,pdf
Quality assessment considering viewing distance and image resolution
Ke Gu, Min Liu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE Transactions on Broadcasting(T-BC), 2015,Top 3 Cited Paper of T-BC in 2015,pdf
Fixation prediction through multimodal analysis
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang, Chang Wen Chen
IIn IEEE Transactions on Circuits and Systems for Video Technology(T-CSVT), 2015,Top 5 Cited Paper of T-CSVT in 2015,pdf
Joint chroma downsampling and upsampling for screen content image
Shiqi Wang, Ke Gu , Siwei Ma, Wen Gao
In IEEE Transactions on Circuits and Systems for Video Technology(T-CSVT), 2015,pdf
Using free energy principle for blind image quality assessment
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE Transactions on Multimedia(T-MM), 2015,ESI Highly Cited Paper & Top 1 Cited Paper of T-MM since 2015,pdf
Perceptual screen content image quality assessment and compression
Shiqi Wang, Ke Gu, Kai Zeng, Zhou Wang, Weisi Lin
In IEEE International Conference on Image Processing(ICIP), 2015,pdf
Exploiting global and local information for image quality assessment with contrast change
Haining Gu, Guangtao Zhai, Min Liu, Ke Gu
In IEEE International Symposium on Broadband Multimedia Systems and Broadcasting(BMSB), 2015,pdf
Screen image quality assessment incorporating structural degradation measurement
Ke Gu, Shiqi Wang, Guangtao Zhai, Siwei Ma, Weisi Lin
In IEEE International Symposium on Circuits and Systems(ISCAS), 2015,pdf
An efficient color image quality metric with local-tuned-global model
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE International Conference on Image Processing(ICIP), 2015,pdf
A general histogram modification framework for efficient contrast enhancement
Ke Gu, Guangtao Zhai, Shiqi Wang, Min Liu, Jiantao Zhou, Weisi Lin
In IEEE International Symposium on Circuits and Systems(ISCAS), 2015,pdf
Learning to integrate local and global features for a blind image quality measure
Min Liu, Guangtao Zhai, Ke Gu, Xiaokang Yang
In IEEE International Conference on Smart Computing(ICSC), 2015,pdf
Deep learning network for blind image quality assessment
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE International Conference on Image Processing(ICIP), 2015,pdf
Hybrid no-reference quality metric for singly and multiply distorted images
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE Transactions on Broadcasting(T-BC), 2014,Top 4 Cited Paper of T-BC in 2014,pdf
Effective preprocessing stage in the fourier transform domain for image quality assessment
Min Liu, Guangtao Zhai, Ke Gu, Xiaokang Yang
In IEEE Workshop on Quality of Multimedia Experience(QoMEX), 2014,pdf
Using image signature for effective and efficient reduced-reference image quality assessment
Min Liu, Guangtao Zhai, Shen Tan, Zhili Zhang, Ke Gu, Xiaokang Yang
In IEEE International Conference on Multimedia and Expo Workshop(ICMEW), 2014,pdf
HDR2014 - A high dynamic range image quality database
Min Liu, Guangtao Zhai, Shen Tan, Zhili Zhang, Ke Gu, Xiaokang Yang
In IEEE International Conference on Multimedia and Expo Workshop(ICMEW), 2014,pdf
Using structural degradation and parallax for reduced-reference quality assessment of 3D images
Qi Xu, Guangtao Zhai, Min Liu, Ke Gu
In IEEE International Symposium on Broadband Multimedia Systems and Broadcasting(BMSB), 2014,pdf
Using JPEG and JPEG2000 compressions for fast image quality metrics based on free energy theory
Ke Gu, Guangtao Zhai, Min Liu, Xiaokang Yang, Wenjun Zhang
In IEEE International Symposium on Broadband Multimedia Systems and Broadcasting(BMSB), 2014,pdf
Blind image quality assessment for noise
Min Liu, Guangtao Zhai, Zhenyu Zhang, Yuntao Sun, Ke Gu
In IEEE International Symposium on Broadband Multimedia Systems and Broadcasting(BMSB), 2014,pdf
Visual attention data for image quality assessment databases
Xiongkuo Min, Guangtao Zhai, Zhongpai Gao, Ke Gu
In International Symposium on Circuits and Systems(ISCAS), 2014,pdf
Details preservation inspired blind quality metric of tone mapping methods
Ke Gu, Guangtao Zhai, Min Liu, Xiaokang Yang, Wenjun Zhang
In IEEE International Symposium on Circuits and Systems(ISCAS), 2014,pdf
Subjective and objective quality assessment for images with contrast change
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang, Min Liu
In IEEE International Conference on Image Processing(ICIP), 2014,pdf
Brightness preserving video contrast enhancement using S-shaped transfer function
Ke Gu, Guangtao Zhai, Min Liu, Xiongkuo Min, Xiaokang Yang, Wenjun Zhang
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2014,pdf
Adaptive high- frequency clipping for improved image quality assessment
Ke Gu, Guangtao Zhai, Min Liu, Qi Xu, Xiaokang Yang, Wenjun Zhang
In IEEE International Conference on Visual Communication and Image Processing(VCIP), 2014,pdf
A new psychovisual paradigm for image quality assessment: From differentiating distortion types to discriminating quality conditions
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In Signal, Image and Video Processing(SIVP), 2013,pdf
Fisblim: a five-step blind metric for quality assessment of multiply distorted images
Ke Gu, Guangtao Zhai, Min Liu, Xiaokang Yang, Wenjun Zhang
In IEEE Workshop on Signal Processing Systems(SiPS), 2013,pdf
A new image quality metric based on MIx-Scale transform
Min Liu, Guangtao Zhai, Ke Gu, Qi Xu, Xiaokang Yang
In IEEE Workshop on Signal Processing Systems(SiPS), 2013,pdf
Structural similarity weighting for image quality assessment
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang, Min Liu
In IEEE International Conference on Multimedia and Expo Workshop(ICMEW), 2013,pdf
No-reference image quality assessment metric by combining free energy theory and structural degradation model
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang, Longfei Liang
In IEEE International Conference on Multimedia and Expo(ICME), 2013,pdf
Self-adaptive scale transform for IQA metric
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE International Symposium on Circuits and Systems(ISCAS), 2013,pdf
A new reduced-reference image quality assessment using structural degradation model
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE International Symposium on Circuits and Systems(ISCAS), 2013,pdf
A new no-reference stereoscopic image quality assessment based on ocular dominance theory and degree of parallax
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE International Conference on Pattern Recognition(ICPR), 2013,pdf
An improved full-reference image quality metric based on structure compensation
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In APSIPA ASC, 2013,pdf
Robust object tracking with bidirectional corner matching and trajectory smoothness algorithm
Guoshan Wu, Yi Xu, Xiaokang Yang, Qing Yan, Ke Gu
In IEEE Workshop on Multimedia Signal Processing(MMSP), 2012,pdf
Nonlinear additive model based saliency map weighting strategy for image quality assessment
Ke Gu, Guangtao Zhai, Xiaokang Yang, Wenjun Zhang
In IEEE Workshop on Multimedia Signal Processing(MMSP), 2012,pdf
Full-reference image quality assessment via region-based analysis
Ke Gu, Wenjun Zhang, Ci Wang, Guangtao Zhai
In IEEE International Congress on Image and Signal Processing(CISP), 2011,pdf


Coverage report:
98%
Hot-keys on this page
n
s
m
x
c
change column sorting
Module
statements
missing
excluded
coverage
Total
405
7
0
98%
cms/__init__.py
0
0
0
100%
cms/apps/article/__init__.py
0
0
0
100%
cms/apps/article/migrations/0001_initial.py
6
0
0
100%
cms/apps/article/migrations/0002_article_user.py
7
0
0
100%
cms/apps/article/migrations/__init__.py
0
0
0
100%
cms/apps/article/models.py
11
0
0
100%
cms/apps/article/serializers.py
18
0
0
100%
cms/apps/article/tests.py
70
0
0
100%
cms/apps/article/urls.py
7
0
0
100%
cms/apps/article/views.py
50
1
0
98%
cms/apps/authentication/__init__.py
0
0
0
100%
cms/apps/authentication/manager.py
20
1
0
95%
cms/apps/authentication/migrations/0001_initial.py
6
0
0
100%
cms/apps/authentication/migrations/__init__.py
0
0
0
100%
cms/apps/authentication/models.py
21
1
0
95%
cms/apps/authentication/serializers.py
22
1
0
95%
cms/apps/authentication/tests.py
66
0
0
100%
cms/apps/authentication/urls.py
6
0
0
100%
cms/apps/authentication/validator.py
11
1
0
91%
cms/apps/authentication/views.py
26
0
0
100%
cms/settings.py
25
0
0
100%
cms/test_utils.py
18
0
0
100%
cms/urls.py
3
0
0
100%
manage.py
12
2
0
83%
No items found using the specified filter.


Enroute to wed his fiancée Luna on a road trip with his best friends, Prince Noctis is advised by news reports that his homeland has been invaded and taken over under the false pretense of a peace treaty – and that he, his loved one and his father King Regis, have been slain at the hands of the enemy. To gather the strength needed to uncover the truth and reclaim his homeland, Noctis and his loyal companions must overcome a series of challenges in a spectacular open world - that is filled with larger-than-life creatures, amazing wonders, diverse cultures and treacherous foes. Final Fantasy


simple elm examples, runnable in your browser
(for source code, see https://github.com/oresmus/elm-examples; most use Elm 0.17, but a few (noted below) use Elm 0.18)
dragging
-
copy of elm-lang.org/examples/drag; drag a single object, shown as an html div:
html-drag-1
-
the same code, extended to support dragging of several objects independently:
html-drag-2
-
an svg drag example, pieced together from various other examples (now upgraded to Elm 0.18):
svg-drag-1
[unexplained bug in Safari but not in Chrome, in Elm 0.17 (not yet retested in 0.18):
if user is idle for a minute or so, the next drag takes 10-30 seconds to respond]
-
a fancier svg drag example (various features to be added over time; for Elm 0.18):
svg-drag-fancy
animation and keyboard
-
Mario example by someone else (shows use of Keyboard and animationFrame in Elm 0.17; known bug: missing image):
pdamoc-Mario
other
-
the elm-lang.org "time" example (clock in svg), after doing the suggested exercise (pause button):
elmguide-time-exercise


Change Title
Change h1
Change h1 back
Change to pet
exclamation
Change picture


Assembling a Package Item
Packages, like repositories, are made completely in JSON. For a more complete outline, look at test.package.json provided on GitHub.
"results" is the array that contains the entire package information in objects.
"name" is the name of an item. "file" is what is displayed on the list.
"goto" is the link to download a file. "run" is the JavaScript that is run when something is clicked on. It is advised to leave the other blank when one is in use.


Crop Control
Data obtained from a crop management app, used for controling production and cash flow.
Rudimar Althof
Power Platform Developper | IoT Consultant | Software Developper
Want more details? Get my CV here.
Data obtained from a crop management app, used for controling production and cash flow.


Avengers: Endgame cut 'huge battle sequence' with Thanos' army
Avengers: Endgame could have had another huge battle scene featuring Thanos’ army, but had to be cut – because, you know, the film was already three hours long.
In the new artbook for the movie, concept illustrator Josh Nizzi spoke about the prospect of squeezing in another fight.
Alongside a string of drawings, he explained how it was hoped the purple one would be seen going up against a military alien race, reports Comicbook.com.
However, it didn’t come to fruition.
He said: ‘Marvel wanted to show how powerful Thanos was even before he had any of the Stones.
‘There was going to be a huge battle sequence where he fights a military alien race. The aliens actually did show up in the film but only for a few seconds before being killed by Gamora and Nebula.’
Advertisement Advertisement
Not quite the epic battle scene originally thought out, then.
Jerad Marantz, costume concept artist, described the army and called coming up with the design ‘challenging’.
‘After looking at the source material, I wanted them to have a biomechanics quality to them,’ he said.
‘There was concern that the Outriders may look too much like a Venom symbiote, and the challenge was to ensure they had a unique look.
‘To achieve that, I decided to go biomechanical with them and incorporate the same shapes that are used in Thanos’ armor and Proxima Midnight’s and Corvus Glaive’s.’
This isn’t the only scene that had been cut out of the epic superhero flick, as Katherine Langford was set to appear as the grown-up version of Tony Stark’s (Robert Downey Jr) daughter Morgan, who was played by Lexi Rabe in the movie.
The deleted scene, revealed by Disney+, shows Tony encountering the adult version of his daughter, saying: ‘Guess it worked.’
Advertisement Advertisement
Morgan goes on to tell him: ‘Yeah, it worked for me. I got to live, grow up. For you, I can’t answer.’
Then, as if we weren’t sobbing enough, she tells her dad: ‘I love you’, with him (of course) answering: ‘I love you 3000’.
Got a showbiz story?
If you've got a story, video or pictures get in touch with the Metro.co.uk Entertainment team by emailing us<EMAIL_ADDRESS>calling 020 3615 2145 or by visiting our Submit Stuff page - we'd love to hear from you.


Rasa¶
Rasa is an open source NLU provider that is distributed as an Python API,
developed and provided by Rasa Technologies. Different from other closed
source providers like Dialogflow, you will need to host your own server
in order to use Rasa. This will pose several challenges and is not as
easy to integrate into the framework as other agents, where you simply have
to provide a valid configuration to the configuration file and are good to go.
One major advantage of hosting your own server is that you do not have
to share any of your data with another company.
Here we will quickly introduce how you can setup emubot
using Rasa.
Setting Up a Rasa Agent¶
You can install the Rasa API as a pip package by using the following command:
pip3 install rasa-x --extra-index-url https://pypi.rasa.com/simple
After you have installed the Rasa API you can follow Rasa tutorial to define your own Rasa bot. After you have done so you can use the provided Rasa commands to train your bot and start a test server:
rasa train
rasa run --enable-api -m path/to/trained/model
The example Rasa server will start on port 5000 by default. The framework uses the HTTP API provided with the server as a reference for its implementation. If you want to use your own server between the framework and Rasa, you should provide the following two routes for the requests from the framework:
POST /model/parse
This route parses the provided text using your model.
{
message_id: string,
sender: 'user',
text: string,
token: string
}
The response is expected to include the following fields:
{
entities: [
{
value: string,
entity: string,
}
],
intent: {
confidence: number,
name: string
},
}
Where entities and intent are conform with the Rasa parse results.
You can also add the following fields in order to give additional information to your interceptors:
{
entities: [
{
value: string,
entity: string,
}
],
intent: {
confidence: number,
name: string
},
action: string,
contexts: [string]
}
POST /webhooks/rest/webhook
This route parses the provided text with your trained Rasa model.
{
message: string,
message_id: string,
token: string,
}
The result of the request is the answer of the Rasa agent:
{
"text": string
}
Note that emubot
will also add the token you provide in the
configuration to the requests. You can use this token as an API token for
your server.
Of course you can include any number of other information in your responses,
which you can then use to trigger events in the implementation of your
Interceptors. But you should make sure to pass the information to the
emubot
framework.
These requests have to conform to the definition in the Rasa HTTP API. Head over to their docs for more information.
Exemplar Rasa Configuration¶
In this section you can see an example for a Rasa configuration to be used in
the emubot
framework.
export const platformNlpRasa = {
agents: {
first_agent: {
defaultLifespan: 2,
executionIndex: 1,
languageCode: 'en',
minScore: 0.75,
token: env.NLP_TOKEN,
url: 'https://my-cool-rasa-bot.com/',
},
},
constructor: RasaAdapter,
name: 'rasa',
};