- testAuthor() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests updating the author field of a Comment.
- testBodyTerm() - Method in class ca.ualberta.lard.test.SearchRequestTests
-
Test that search request creates the json string literal in the correct format
when body text is not empty.
- testByteArray() - Method in class ca.ualberta.lard.test.PictureModelTests
-
Tests the byte getters and setters to make sure they are not returning null
- testChildren() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests that a comment has no children upon creation.
- testConstructor() - Method in class ca.ualberta.lard.test.GeoLocationMapTests
-
Tests to make sure the map is populated correctly
- testConstructor() - Method in class ca.ualberta.lard.test.GeoLocationModelTests
-
Tests the constructor by creating a GeoLocation and comparing attributes
- testConstructors() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests the creation of a Comment.
- testDistanceFrom() - Method in class ca.ualberta.lard.test.GeoLocationModelTests
-
Makes sure that a distance is the same to and from two destination points
- testEmptySearch() - Method in class ca.ualberta.lard.test.DataModelTests
-
Tests that the Datamodel can pull at least 1 comment from the server
when a request is made for any comments.
- testFavourites() - Method in class ca.ualberta.lard.test.CommentActivityTests
-
Tests that the parent comment of the list is added to the favourites list when
the favourite button in the action bar is clicked.
- testGeoLocation() - Method in class ca.ualberta.lard.test.NewCommentActivityTests
-
- testGetByIdExists() - Method in class ca.ualberta.lard.test.DataModelTests
-
Tests making a request to the Datamodel for an existing comment returns the correct
comment and returns only 1 comment.
- testGetByIdNotExists() - Method in class ca.ualberta.lard.test.DataModelTests
-
Tests that trying to make a request to the Datamodel for a non-existent comment
returns null.
- testIsLocal() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests that a newly created comment is not saved locally unless the DataModel
is told to save it locally.
- testIsLocal() - Method in class ca.ualberta.lard.test.DataModelTests
-
Tests that the Datamodel is able to check if a comment is saved locally.
- testListViewIsVisable() - Method in class ca.ualberta.lard.test.CommentActivityTests
-
Tests that all parts of the parent comment and its list of child comments can be
seen on the screen.
- testLocation() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests that the GeoLocation of a comment can updated to a new location.
- testNoInfo() - Method in class ca.ualberta.lard.test.SearchRequestTests
-
Test that search request creates the json string literal in the correct format
when no information is provided.
- testParent() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests that a Comment has no parent by default and returns false when
asked if it has a parent.
- testParentId() - Method in class ca.ualberta.lard.test.SearchRequestTests
-
Test that search request creates the json string literal in the correct format
when the parent id is not empty.
- testParentIDExists() - Method in class ca.ualberta.lard.test.NewCommentActivityTests
-
- testParentIDNotExists() - Method in class ca.ualberta.lard.test.NewCommentActivityTests
-
- testPicture() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests that a newly created comment has picture set to null
by default and returns false when asked if it has a picture.
- testPicture() - Method in class ca.ualberta.lard.test.NewCommentActivityTests
-
- testPreconditions() - Method in class ca.ualberta.lard.test.GeoLocationModelTests
-
- testPreConditions() - Method in class ca.ualberta.lard.test.UserModelTests
-
- testReceiveId() - Method in class ca.ualberta.lard.test.CommentActivityTests
-
Tests that when the activity is started, a comment id is received.
- testReply() - Method in class ca.ualberta.lard.test.CommentActivityTests
-
Tests that a NewCommentActivity is opened when the reply button in the action bar
is clicked and that the id of the parent comment is sent.
- testSave() - Method in class ca.ualberta.lard.test.CommentActivityTests
-
Tests that the parent comment of the list is saved locally when the reply button
in the action bar is clicked.
- testSave() - Method in class ca.ualberta.lard.test.DataModelTests
-
Tests that a comment can successfully be saved to stretchy client.
- testSearchByBody() - Method in class ca.ualberta.lard.test.DataModelTests
-
Tests that the Datamodel can search for a comment using only body text.
- testSerialization() - Method in class ca.ualberta.lard.test.GeoLocationModelTests
-
Tests the JSON String serialization and de-serialization by creating
a GeoLocation, serialization then comparing to see if the results are the same
after de-serialization.
- testSetBodyText() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests updating the text of a comment.
- testSetImageString() - Method in class ca.ualberta.lard.test.PictureModelTests
-
Tests the String setters and getters with an arbitrary String
- testSetUsername() - Method in class ca.ualberta.lard.test.UserModelTests
-
Tests that when a username is changed, the hash appended to the end remains the same.
- testToString() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests that Comment.toString returns the same text as
Comment.bodyText.
- testUpdatedAt() - Method in class ca.ualberta.lard.test.CommentModelTests
-
Tests that when a comment is updated, the date it was updated is set
to the current date.
- testUsername() - Method in class ca.ualberta.lard.test.UserModelTests
-
Tests that a username is never null and has a hash appended to the end.


" Unconference" is a 3 day entrepreneurial extravaganza designed to take you on a journey where you understand the bits and pieces of developing an enterprise. It is themed around a case study based approach where you will innovate and iterate to solve some of the most pressing problems faced by India today in areas like Education, Agriculture and Healthcare and Smart City. Unconference will include a series of workshops, focused talks, mentoring sessions and an interactive Startup Walk to aid you in this process. The objective is to set a framework for you to take up any problem and solve with the correct entrepreneurial approach.
With startups growing out of each and every corner of the country, students are not far behind in the scene. A lot of students enter this space to solve a problem but due to the lack of experience and fierce competition out there, millions of ideas or so to say potential multi-national companies get lost. Unconference will guide you to approach some of the most pressing problems in today's world correctly and efficiently. Please go through the brochure attached below to gain an in depth understanding of Unconference.
Why should you attend ?
Lectures and Workhops
Lecture on Frugal Innovation by Navi Radjou ( TEDx talk) - Uplifter. Catalyzer. Connector.
An innovation and leadership strategist based in Silicon Valley, Navi is Fellow at Judge Business School, University of Cambridge and has served as a World Economic Forum member and Harvard Business Review columnist. He is the author of "FRUGAL INNOVATION: How To Do More With Less" published by The Economist worldwide in 2015. He is also a winner of the Thinkers50 Innovation Award for "reshaping the way we think about and practice innovation" .
Design Thinking by Mohan Krishnaraj - Design Thinking draws upon logic, imagination, intuition, and systematic reasoning, to explore possibilities of what could be and to create desired outcomes that benefit the end user.
With over two decades of experience in the UX industry, Mohan Krishnaraj has a proven track record of enabling UX led business transformation for several Fortune 100 companies by optimizing customer interactions with the brand, offerings, and touch points.
Idea Validation by Nandini Vaidyanthan - So you have a business idea, How do you tell if it is good? Will customers buy? How do I validate my idea?
An interactive and hands on session where you will learn the art of Idea Validation from seasoned mentor andStartup coach Nandini Vaidyanathan. After more than 20 years of experience in the corporate sector she started CARMa, which mentors entrepreneurs from an idea in their head to become market-ready. She has mentored thousands of aspiring and budding entrepreneurs till date. You can watch her TEDx talk here.
Business Model Canvas by Ravikiran A- BMC is a strategic management and entrepreneurial tool which is extremely useful for describing, designing, and summarizing a start-up idea. During this workshop you will understand the different components of the Canvas and will also learn how to build business models that work and create value propositions that sell.
Ravikiran Annaswamy is the Founder and CEO of Innohabit Technologies and a renowned business model innovator. He works closely with global programs like Founders Institute (Fi.Co) and Unreasonable Institute as Mentor and Coach for early stage startups. He has over 22 years of business experience as Entrepreneur and as Business Leader at Nokia Siemens Networks and Siemens AG.
Selection Procedure
Top 25 applicants from all over India will be chosen to participate in Unconference after multiple rounds of assessment.
Registration Cost Structure
Once selected, the candidates will be required to pay a fee. The fee structure is as follows:
| IITM students | Other students |
|---|---|
| ₹ 500 - Refundable. | ₹ 500 - Non Refundable. |
**This includes two nights accommodation ( 7th and 8th ) within IIT M campus along with Breakfast, lunch and Networking dinners. Check out the schedule below for further details.
For any queries or clarifications, mail us at events_ecell@smail.iitm.ac.in.


|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
BidiMap
,
OrderedBidiMap
and
SortedBidiMap
interfaces.
See:
Description
| Class Summary | |
| AbstractBidiMapDecorator | Provides a base decorator that enables additional functionality to be added to a BidiMap via decoration. |
| AbstractDualBidiMap | Abstract BidiMap implemented using two maps. |
| AbstractDualBidiMap.BidiMapIterator | Inner class MapIterator. |
| AbstractDualBidiMap.EntrySet | Inner class EntrySet. |
| AbstractDualBidiMap.EntrySetIterator | Inner class EntrySetIterator. |
| AbstractDualBidiMap.KeySet | Inner class KeySet. |
| AbstractDualBidiMap.KeySetIterator | Inner class KeySetIterator. |
| AbstractDualBidiMap.MapEntry | Inner class MapEntry. |
| AbstractDualBidiMap.Values | Inner class Values. |
| AbstractDualBidiMap.ValuesIterator | Inner class ValuesIterator. |
| AbstractDualBidiMap.View | Inner class View. |
| AbstractOrderedBidiMapDecorator | Provides a base decorator that enables additional functionality to be added to an OrderedBidiMap via decoration. |
| AbstractSortedBidiMapDecorator | Provides a base decorator that enables additional functionality to be added to a SortedBidiMap via decoration. |
| DualHashBidiMap | Implementation of BidiMap that uses two HashMap instances. |
| DualTreeBidiMap | Implementation of BidiMap that uses two TreeMap instances. |
| DualTreeBidiMap.BidiOrderedMapIterator | Inner class MapIterator. |
| DualTreeBidiMap.ViewMap | Internal sorted map view. |
| TreeBidiMap | Red-Black tree-based implementation of BidiMap where all objects added
implement the Comparable interface. |
| UnmodifiableBidiMap | Decorates another BidiMap to ensure it can't be altered. |
| UnmodifiableOrderedBidiMap | Decorates another OrderedBidiMap to ensure it can't be altered. |
| UnmodifiableSortedBidiMap | Decorates another SortedBidiMap to ensure it can't be altered. |
This package contains implementations of the
BidiMap
,
OrderedBidiMap
and
SortedBidiMap
interfaces.
A BidiMap is an extension to Map that allows keys and values to be looked up with equal ease.
One example usage is a system communicating to a legacy datasource that must convert codes
from the new format to the old format and vice versa.
The following implementations are provided in the package:
The following decorators are provided in the package:
|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Arduino IDE with installed the following plugins:
source /opt/ros/<distro>/setup.bash
roscore
rosrun rosserial_python serial_node.py /dev/ttyACM0
. Make sure to specify the correct port (same port you used in the Arduino IDE to upload the code)rostopic pub motor2/start std_msgs/Empty --once
will execute once the following methodvoid startMotor2(const std_msgs::Empty& toggle_msg)
whereas rostopic pub motor1/start std_msgs/Int8 15 --once
will execute once the following method
void startMotor1(const std_msgs::Int8& rpm)
by passing as an argument an rpm of 15
rostopic list


MonkeyDo keeps you organized at all the times. Home, on work, on the go. Everywhere!
You can have a list for each person, but also common lists that keeps you in synch.
MonkeyDo is both easy and intuitive, but with a lot of great options for personalization


SERVICES
COMPANY
PORTFOLIO
CAREERS
BLOG
CONTACT
Your Digital
Workshop
Building Business
Solutions
& Bright
Ideas


Class ImageButtonState
OBSOLETE: Use ButtonState
Implements
Inherited Members
Namespace: Forms9Patch
Assembly: Forms9Patch.dll
Syntax
[Obsolete("Use ButtonState", true)]
public class ImageButtonState : ButtonState, INotifyPropertyChanged, IDynamicResourceHandler, IButtonState, IBackground, IShape, ILabel, ILabelStyle, IFontElement, IElement


This is library allows for basic mathmatical functions to be tied to HTML interfaces for maximum flexiablity.


Samples of the Celebration Brass Quintet
With a library of more than 700 arrangements, the Celebration Brass Quintet can create the special tone and atmosphere you want for your event.
Audio Samples
Sample Programs
Sample Summer Park Concert Program
A fun evening of brass music
| Early Jazz |
Bugle Call Rag audio |
| Livery Stable Blues |
| Tiger Rag |
| Broadway |
The Music Man |
| Dead Woman Blues |
St. James Infirmary |
| Dead (Wo)man Blues |
| La Traviata |
Prelude |
| Introduction |
| Brindisi |
| Scott Joplin |
Solace |
| The Easy Winners |
| Waltz |
Tales from the Vienna Woods |
| Movie Music |
A Tribute to M.G.M. audio |
| Patriotic Music |
America, the Beautiful |
| The Thunderer |
Sample Holiday Program
A merry, merry celebration
- We Wish You a Merry Christmas
- Angels We Have Heard on High
- Carol of the Bells
- The Holly and the Ivy
- We Three Kings
- Cantique de Noel
- Joy to the World
- Gloucestershire Wassail
- Sussex Carol
- O Tannenbaum
- Sleigh Ride
- White Christmas
- Let it Snow
- Rudolph the Red-Nosed Reindeer
- Linus and Lucy
- Christmas Time is Here
- You're a Mean One, Mister Grinch
- Have Yourself a Merry Little Christmas
Sample Wedding Program
A beautiful, unforgettable ceremony
| Prelude |
Bach: Jesu, Joy of Man's Desiring |
| Bach: My Spirit Be Joyful |
| Bach: Sheep May Safely Graze audio |
| Processional |
Purcell: Trumpet Voluntary audio |
| Special Music |
J.C. Bach: Andante |
| Recessional |
Scheidt: Canzona Bergamasca |
Sample Formal Concert Program


About me
I am an engineer with AT&T and it was my passion to learn new thing. Udacity has opened many doors for me and i feel like Alice in wonderland. Bear with me as i explore all the interesting doors on Mi Windows through udacity. I love to hike, read and gardening. Cooking is my passion apart from wonderful work that i do at my company.
I love my wife's art of cake decorating. she has a blog of her own, see Art of cakes blog for her gifted talent.
My Favorite Links
Art of Cakes


Learning Plan
Long term goals and career pathway
My long term goals are quite broad, I would like to own my own town-house close to the city eventually, I am seeking a career change that will allow me more sociable hours to pursue my many other interests such as music, homebrewing, cooking and cheesemaking.
As of writing this I have no clear career pathway, except a move away from what I am currently doing, I chose to pursue the tech industry because it is constantly evolving, which means there will always be new challenges. Where exactly I will fit within this behemoth is yet to be determined.
What human skills I would like to develop
developing a better self-awareness and self-evaluation skills to help me improve my employability is essential. I feel like I can be a bit rough round the edges, which is fine, but being able to refine my personality to suit, would be awesome.
My team working ability is suitable, but I would love to develop this even more, because projects are always more fun when completed as a team working together.
My own strengths and limitations
My biggest strength is my fast-learning, once I grasp a concept or repeat an action one or two times, BAM! that’s it, I can move forward. That doesn’t mean I don’t struggle to understand things/concepts/formulas, sometimes it will take me a while to grasp particular ideas, but I try not to let this slow me down to much because I know I’ll get it eventually.
My biggest limitation is time-management, though it is improving with age, I am still a master procrastinator. And tend to get distracted easily by random passing thoughts. I also have to refer back to the previous blog and give the voice in my head an honorable mention.
How I will manage my workload and other commitments
I’ve cut down my working hours in order to make sure I have enough time each week to complete the material and have a day of to do nothing at all! Yay Sunday, I am currently also working on a small programming paper for polytechnic, which requires about five hours a week, but I am just slotting that in wherever I can.
How I will seek help in a timely way and what I expect from the facilitation team
So far I’ve managed to get to grips with the program, however I am not taking that for granted, so when I inevitably get stuck at some point my first port of call will be the foundations slack channel. The channel is active with a lot of knowledgeable people who seem more than happy to help. It is also great to have access to a facilitator, and I save any broader questions about the material, which do not require urgent attention, for the weekly meeting with John. I do not expect the facilitator to give me all the information I need, I believe they are there more as a guide to let me know I’m on the right track.


EECS341 Fall 2019 Group 9
Application Background
There are many video games played competitively at the international level. Teams trade players and interact with other teams in tournaments and majors. Some players switch games. Teams have statistics such as the number of major wins, and players have statistics such as points per game. Our database will track and make simple tracking this complex scene for the user.
Data description
In this database, we’ll be tracking the following entities: player, club, tournament, arena, reward, status, and coach. The players will be signed onto a team and will have a status for overall statistics. Each player has basic attributes like name, age, nationality. Clubs will play certain games and hire coaches. Coach has similar attributes to player, and clubs have a formation date, whether they are active, nationality, and ranking. Tournaments on specific dates will be held for specific games in an arena in a city and country, with a reward provided by a sponsor for a certain amount of money.


Cake\ORM\
Table
Table objects provide access to the collection of entities stored in a specific table. Each table in your application should have an associated Table class which is used to interact with a given table. If you do not need to customize the behavior of a given table CakePHP will generate a Table instance for you to use.
Before trying to use Table objects and the ORM, you should ensure that you have configured your database connection.
To get started, create a Table class. These classes live in src/Model/Table. Tables are a type model collection specific to relational databases, and the main interface to your database in CakePHP’s ORM. The most basic table class would look like:
// src/Model/Table/ArticlesTable.php
namespace App\Model\Table;
use Cake\ORM\Table;
class ArticlesTable extends Table
{
}
Note that we did not tell the ORM which table to use for our class. By
convention table objects will use a table that matches the lower cased and
underscored version of the class name. In the above example the articles
table will be used. If our table class was named BlogPosts
your table should
be named blog_posts
. You can specify the table to using the setTable()
method:
namespace App\Model\Table;
use Cake\ORM\Table;
class ArticlesTable extends Table
{
public function initialize(array $config)
{
$this->setTable('my_table');
// Prior to 3.4.0
$this->table('my_table');
}
}
No inflection conventions will be applied when specifying a table. By convention
the ORM also expects each table to have a primary key with the name of id
.
If you need to modify this you can use the setPrimaryKey()
method:
namespace App\Model\Table;
use Cake\ORM\Table;
class ArticlesTable extends Table
{
public function initialize(array $config)
{
$this->setPrimaryKey('my_id');
// Prior to 3.4.0
$this->primaryKey('my_id');
}
}
By default table objects use an entity class based on naming conventions. For
example if your table class is called ArticlesTable
the entity would be
Article
. If the table class was PurchaseOrdersTable
the entity would be
PurchaseOrder
. If however, you want to use an entity that doesn’t follow the
conventions you can use the setEntityClass()
method to change things up:
class PurchaseOrdersTable extends Table
{
public function initialize(array $config)
{
$this->setEntityClass('App\Model\Entity\PO');
// Prior to 3.4.0
$this->entityClass('App\Model\Entity\PO');
}
}
As seen in the examples above Table objects have an initialize()
method
which is called at the end of the constructor. It is recommended that you use
this method to do initialization logic instead of overriding the constructor.
Before you can query a table, you’ll need to get an instance of the table. You
can do this by using the TableRegistry
class:
// In a controller or table method.
use Cake\ORM\TableRegistry;
$articles = TableRegistry::get('Articles');
The TableRegistry class provides the various dependencies for constructing a table, and maintains a registry of all the constructed table instances making it easier to build relations and configure the ORM. See Using the TableRegistry for more information.
If your table class is in a plugin, be sure to use the correct name for your table class. Failing to do so can result in validation rules, or callbacks not being triggered as a default class is used instead of your actual class. To correctly load plugin table classes use the following:
// Plugin table
$articlesTable = TableRegistry::get('PluginName.Articles');
// Vendor prefixed plugin table
$articlesTable = TableRegistry::get('VendorName/PluginName.Articles');
As you have seen above table objects trigger a number of events. Events are useful if you want to hook into the ORM and add logic in without subclassing or overriding methods. Event listeners can be defined in table or behavior classes. You can also use a table’s event manager to bind listeners in.
When using callback methods behaviors attached in the
initialize()
method will have their listeners fired before the table
callback methods are triggered. This follows the same sequencing as controllers
& components.
To add an event listener to a Table class or Behavior simply implement the method signatures as described below. See the Events System for more detail on how to use the events subsystem.
Model.initialize
Model.beforeMarshal
Model.beforeFind
Model.buildValidator
Model.buildRules
Model.beforeRules
Model.afterRules
Model.beforeSave
Model.afterSave
Model.afterSaveCommit
Model.beforeDelete
Model.afterDelete
Model.afterDeleteCommit
Cake\ORM\Table::
initialize
(Event $event, ArrayObject $data, ArrayObject $options)¶The Model.initialize
event is fired after the constructor and initialize
methods are called. The Table
classes do not listen to this event by
default, and instead use the initialize
hook method.
To respond to the Model.initialize
event you can create a listener class
which implements EventListenerInterface
:
use Cake\Event\EventListenerInterface;
class ModelInitializeListener implements EventListenerInterface
{
public function implementedEvents()
{
return array(
'Model.initialize' => 'initializeEvent',
);
}
public function initializeEvent($event)
{
$table = $event->getSubject();
// do something here
}
}
and attach the listener to the EventManager
as below:
use Cake\Event\EventManager;
$listener = new ModelInitializeListener();
EventManager::instance()->attach($listener);
This will call the initializeEvent
when any Table
class is constructed.
Cake\ORM\Table::
beforeMarshal
(Event $event, ArrayObject $data, ArrayObject $options)¶The Model.beforeMarshal
event is fired before request data is converted
into entities. See the Modifying Request Data Before Building Entities documentation for more information.
Cake\ORM\Table::
beforeFind
(Event $event, Query $query, ArrayObject $options, $primary)¶The Model.beforeFind
event is fired before each find operation. By stopping
the event and supplying a return value you can bypass the find operation
entirely. Any changes done to the $query instance will be retained for the rest
of the find. The $primary
parameter indicates whether or not this is the root
query, or an associated query. All associations participating in a query will
have a Model.beforeFind
event triggered. For associations that use joins,
a dummy query will be provided. In your event listener you can set additional
fields, conditions, joins or result formatters. These options/features will be
copied onto the root query.
You might use this callback to restrict find operations based on a user’s role, or make caching decisions based on the current load.
In previous versions of CakePHP there was an afterFind
callback, this has
been replaced with the Modifying Results with Map/Reduce features and entity constructors.
Cake\ORM\Table::
buildValidator
(Event $event, Validator $validator, $name)¶The Model.buildValidator
event is fired when $name
validator is created.
Behaviors, can use this hook to add in validation methods.
Cake\ORM\Table::
buildRules
(Event $event, RulesChecker $rules)¶The Model.buildRules
event is fired after a rules instance has been
created and after the table’s buildRules()
method has been called.
Cake\ORM\Table::
beforeRules
(Event $event, EntityInterface $entity, ArrayObject $options, $operation)¶The Model.beforeRules
event is fired before an entity has had rules applied. By
stopping this event, you can halt the rules checking and set the result
of applying rules.
Cake\ORM\Table::
afterRules
(Event $event, EntityInterface $entity, ArrayObject $options, $result, $operation)¶The Model.afterRules
event is fired after an entity has rules applied. By
stopping this event, you can return the final value of the rules checking
operation.
Cake\ORM\Table::
beforeSave
(Event $event, EntityInterface $entity, ArrayObject $options)¶The Model.beforeSave
event is fired before each entity is saved. Stopping
this event will abort the save operation. When the event is stopped the result
of the event will be returned.
How to stop an event is documented here.
Cake\ORM\Table::
afterSave
(Event $event, EntityInterface $entity, ArrayObject $options)¶The Model.afterSave
event is fired after an entity is saved.
Cake\ORM\Table::
afterSaveCommit
(Event $event, EntityInterface $entity, ArrayObject $options)¶The Model.afterSaveCommit
event is fired after the transaction in which the
save operation is wrapped has been committed. It’s also triggered for non atomic
saves where database operations are implicitly committed. The event is triggered
only for the primary table on which save()
is directly called. The event is
not triggered if a transaction is started before calling save.
Cake\ORM\Table::
beforeDelete
(Event $event, EntityInterface $entity, ArrayObject $options)¶The Model.beforeDelete
event is fired before an entity is deleted. By
stopping this event you will abort the delete operation. When the event is stopped the result
of the event will be returned.
How to stop an event is documented here.
Cake\ORM\Table::
afterDelete
(Event $event, EntityInterface $entity, ArrayObject $options)¶The Model.afterDelete
event is fired after an entity has been deleted.
Cake\ORM\Table::
afterDeleteCommit
(Event $event, EntityInterface $entity, ArrayObject $options)¶The Model.afterDeleteCommit
event is fired after the transaction in which the
delete operation is wrapped has been is committed. It’s also triggered for non
atomic deletes where database operations are implicitly committed. The event is
triggered only for the primary table on which delete()
is directly called.
The event is not triggered if a transaction is started before calling delete.
Cake\ORM\Table::
addBehavior
($name, array $options = [])¶Behaviors provide an easy way to create horizontally re-usable pieces of logic related to table classes. You may be wondering why behaviors are regular classes and not traits. The primary reason for this is event listeners. While traits would allow for re-usable pieces of logic, they would complicate binding events.
To add a behavior to your table you can call the addBehavior()
method.
Generally the best place to do this is in the initialize()
method:
namespace App\Model\Table;
use Cake\ORM\Table;
class ArticlesTable extends Table
{
public function initialize(array $config)
{
$this->addBehavior('Timestamp');
}
}
As with associations, you can use plugin syntax and provide additional configuration options:
namespace App\Model\Table;
use Cake\ORM\Table;
class ArticlesTable extends Table
{
public function initialize(array $config)
{
$this->addBehavior('Timestamp', [
'events' => [
'Model.beforeSave' => [
'created_at' => 'new',
'modified_at' => 'always'
]
]
]);
}
}
You can find out more about behaviors, including the behaviors provided by CakePHP in the chapter on Behaviors.
By default all table instances use the default
database connection. If your
application uses multiple database connections you will want to configure which
tables use which connections. This is the defaultConnectionName()
method:
namespace App\Model\Table;
use Cake\ORM\Table;
class ArticlesTable extends Table
{
public static function defaultConnectionName() {
return 'replica_db';
}
}
Note
The defaultConnectionName()
method must be static.
Cake\ORM\
TableRegistry
¶As we’ve seen earlier, the TableRegistry class provides an easy to use factory/registry for accessing your applications table instances. It provides a few other useful features as well.
Cake\ORM\TableRegistry::
get
($alias, $config)¶When loading tables from the registry you can customize their dependencies, or
use mock objects by providing an $options
array:
$articles = TableRegistry::get('Articles', [
'className' => 'App\Custom\ArticlesTable',
'table' => 'my_articles',
'connection' => $connectionObject,
'schema' => $schemaObject,
'entityClass' => 'Custom\EntityClass',
'eventManager' => $eventManager,
'behaviors' => $behaviorRegistry
]);
Pay attention to the connection and schema configuration settings, they aren’t
string values but objects. The connection will take an object of
Cake\Database\Connection
and schema Cake\Database\Schema\Collection
.
Note
If your table also does additional configuration in its initialize()
method,
those values will overwrite the ones provided to the registry.
You can also pre-configure the registry using the config()
method.
Configuration data is stored per alias, and can be overridden by an object’s
initialize()
method:
TableRegistry::config('Users', ['table' => 'my_users']);
Note
You can only configure a table before or during the first time you access that alias. Doing it after the registry is populated will have no effect.
Cake\ORM\TableRegistry::
clear
¶During test cases you may want to flush the registry. Doing so is often useful when you are using mock objects, or modifying a table’s dependencies:
TableRegistry::clear();
If you have not followed the conventions it is likely that your Table or
Entity classes will not be detected by CakePHP. In order to fix this, you can
set a namespace with the Cake\Core\Configure::write
method. As an example:
/src
/App
/My
/Namespace
/Model
/Entity
/Table
Would be configured with:
Cake\Core\Configure::write('App.namespace', 'App\My\Namespace');


Before Change
OrderHWCN
from webdnn.graph.variable import Variable
orders4 = [OrderNHWC, OrderHWNC, OrderHWCN, OrderNCHW, OrderCNHW, OrderCHWN]
def main(k, s, p, n, h1, w1, c1, expected_shape_dict: AxisKeyDict[int]):
for order_x in orders4:
After Change
from webdnn.graph.order import Order, OrderNHWC
from webdnn.graph.variable import Variable
OrderNHWKKC = Order([Axis.N, Axis.H, Axis.W, Axis.KH, Axis.KW, Axis.C])
def main(col_shape=[1, 5, 5, 3, 3, 6], col_order=OrderNHWKKC, ksize=3, stride=1, padding=1,
expected_shape_dict: AxisKeyDict[int] = AxisKeyDict(OrderNHWC.axes, [1, 5, 5, 6])):


Use AI to analysis NBA data to predict top-50 player per week.
Use AI to analysis Stock Data to predict close price.
Use AI to do server and api service analysis to improve efficiency.
To scrap hot topics and news from twitter and other websites.
Use Bootstrap 4, React , Vue and Angular to do Responsive Website.
Use Python, Golang, Node.js to do Restful API with Mysql DB.
Use PowerBI, tableau, python for data visualization.
Use Python, SAS, ssas for data mining.
Use Python Unittest, selenium for both API and UI test.
Use CICD to improve efficiency of software development.
Gitlab CICD setup.
VPN setup in Virtual Machine using openvpn and VM ware .
Cisco server firewall setting and network design.


Extensible class
An extension loader that collects extensions and waits on their loading.
You can inherit this if you want, but I'd rather compose it.
class Extensible { /** * The instance being extended, will be passed to all extensions. */ final dynamic _pluggable; /** * The list of futures that this loader will wait on. */ final List<Future> waitingFor = <Future>[]; /** * Create a new extension loader for the given pluggable. */ Extensible([this._pluggable]); /** * The argument passed during plugin setup. * * Either passed on instantiation, or will be this, */ dynamic get pluggable => _pluggable != null ? _pluggable : this; /** * Load an extension. */ dynamic extend(Extension plugin) { var result = plugin(pluggable); if (result is Future) { waitingFor.add(result); } return result; } /** * Wait for all the extensions to load. */ Future start() { return Futures.wait(waitingFor); } }
Constructors
new Extensible([_pluggable]) #
Create a new extension loader for the given pluggable.
Extensible([this._pluggable]);
Properties
final pluggable #
The argument passed during plugin setup.
Either passed on instantiation, or will be this,
dynamic get pluggable => _pluggable != null ? _pluggable : this;
final List<Future> waitingFor #
The list of futures that this loader will wait on.
final List<Future> waitingFor = <Future>[];


Cri::Command represents a command that can be executed on the commandline. It is also used for the commandline tool itself.
@return [Array<String>] A list of aliases for this command that can be
used to invoke this command
@return [Proc] The block that should be executed when invoking this
command (ignored for commands with subcommands)
@return [Set<Cri::Command>] This command’s subcommands
@return [String] The long description (“description”)
@return [String] The name
@return [Array<Hash>] The list of option definitions
@return [Set<Cri::Command>] This command’s subcommands
@return [String] The short description (“summary”)
@return [Cri::Command, nil] This command’s supercommand, or nil if the
command has no supercommand
@return [String] The usage, without the “usage:” prefix and without the
supercommands’ names.
Creates a new command using the DSL. If a string is given, the command will be defined using the string; if a block is given, the block will be used instead.
If the block has one parameter, the block will be executed in the same context with the command DSL as its parameter. If the block has no parameters, the block will be executed in the context of the DSL.
@param [String, nil] string The command definition as a string
@param [String, nil] filename The filename corresponding to the string parameter (only useful if a string is given)
@return [Cri::Command] The newly defined command
# File lib/cri/command.rb, line 97 def self.define(string=nil, filename=nil, &block) dsl = Cri::CommandDSL.new if string args = filename ? [ string, filename ] : [ string ] dsl.instance_eval(*args) elsif [ -1, 0 ].include? block.arity dsl.instance_eval(&block) else block.call(dsl) end dsl.command end
# File lib/cri/command.rb, line 128 def initialize @aliases = Set.new @commands = Set.new @option_definitions = Set.new end
Returns a new command that implements showing help.
@return [Cri::Command] A basic help command
# File lib/cri/command.rb, line 123 def self.new_basic_help filename = File.dirname(__FILE__) + '/commands/basic_help.rb' self.define(File.read(filename)) end
Returns a new command that has support for the `-h`/`–help` option and also has a `help` subcommand. It is intended to be modified (adding name, summary, description, other subcommands, …)
@return [Cri::Command] A basic root command
# File lib/cri/command.rb, line 115 def self.new_basic_root filename = File.dirname(__FILE__) + '/commands/basic_root.rb' self.define(File.read(filename)) end
Compares this command's name to the other given command's name.
# File lib/cri/command.rb, line 306 def <=>(other) self.name <=> other.name end
Adds the given command as a subcommand to the current command.
@param [Cri::Command] command The command to add as a subcommand
@return [void]
# File lib/cri/command.rb, line 165 def add_command(command) @commands << command command.supercommand = self end
Returns the command with the given name. This method will display error messages and exit in case of an error (unknown or ambiguous command).
The name can be a full command name, a partial command name (e.g. “com” for “commit”) or an aliased command name (e.g. “ci” for “commit”).
@param [String] name The full, partial or aliases name of the command
@return [Cri::Command] The command with the given name
# File lib/cri/command.rb, line 220 def command_named(name) commands = commands_named(name) if commands.size < 1 $stderr.puts "#{self.name}: unknown command '#{name}'\n" exit 1 elsif commands.size > 1 $stderr.puts "#{self.name}: '#{name}' is ambiguous:" $stderr.puts " #{commands.map { |c| c.name }.sort.join(' ') }" exit 1 else commands[0] end end
Returns the commands that could be referred to with the given name. If the result contains more than one command, the name is ambiguous.
@param [String] name The full, partial or aliases name of the command
@return [Array<Cri::Command>] A list of commands matching the given name
# File lib/cri/command.rb, line 198 def commands_named(name) # Find by exact name or alias @commands.each do |cmd| found = cmd.name == name || cmd.aliases.include?(name) return [ cmd ] if found end # Find by approximation @commands.select do |cmd| cmd.name[0, name.length] == name end end
Defines a new subcommand for the current command using the DSL.
@param [String, nil] name The name of the subcommand, or nil if no name
should be set (yet)
@return [Cri::Command] The subcommand
# File lib/cri/command.rb, line 176 def define_command(name=nil, &block) # Execute DSL dsl = Cri::CommandDSL.new dsl.name name unless name.nil? if [ -1, 0 ].include? block.arity dsl.instance_eval(&block) else block.call(dsl) end # Create command cmd = dsl.command self.add_command(cmd) cmd end
@return [Hash] The option definitions for the command itself and all its
ancestors
# File lib/cri/command.rb, line 153 def global_option_definitions res = Set.new res.merge(option_definitions) res.merge(supercommand.global_option_definitions) if supercommand res end
@return [String] The help text for this command
# File lib/cri/command.rb, line 301 def help(params={}) HelpRenderer.new(self, params).render end
Modifies the command using the DSL.
If the block has one parameter, the block will be executed in the same context with the command DSL as its parameter. If the block has no parameters, the block will be executed in the context of the DSL.
@return [Cri::Command] The command itself
# File lib/cri/command.rb, line 141 def modify(&block) dsl = Cri::CommandDSL.new(self) if [ -1, 0 ].include? block.arity dsl.instance_eval(&block) else block.call(dsl) end self end
Runs the command with the given commandline arguments, possibly invoking subcommands and passing on the options and arguments.
@param [Array<String>] opts_and_args A list of unparsed arguments
@param [Hash] parent_opts A hash of options already handled by the
supercommand
@return [void]
# File lib/cri/command.rb, line 244 def run(opts_and_args, parent_opts={}) # Parse up to command name stuff = partition(opts_and_args) opts_before_subcmd, subcmd_name, opts_and_args_after_subcmd = *stuff if subcommands.empty? || (subcmd_name.nil? && !self.block.nil?) run_this(opts_and_args, parent_opts) else # Handle options self.handle_options(opts_before_subcmd) # Get command if subcmd_name.nil? $stderr.puts "#{name}: no command given" exit 1 end subcommand = self.command_named(subcmd_name) # Run subcommand.run(opts_and_args_after_subcmd, opts_before_subcmd) end end
Runs the actual command with the given commandline arguments, not invoking any subcommands. If the command does not have an execution block, an error ir raised.
@param [Array<String>] opts_and_args A list of unparsed arguments
@param [Hash] parent_opts A hash of options already handled by the
supercommand
@raise [NotImplementedError] if the command does not have an execution
block
@return [void]
# File lib/cri/command.rb, line 280 def run_this(opts_and_args, parent_opts={}) # Parse parser = Cri::OptionParser.new( opts_and_args, self.global_option_definitions) self.handle_parser_errors_while { parser.run } local_opts = parser.options global_opts = parent_opts.merge(parser.options) args = parser.arguments # Handle options self.handle_options(local_opts) # Execute if self.block.nil? raise NotImplementedError, "No implementation available for '#{self.name}'" end self.block.call(global_opts, args, self) end
# File lib/cri/command.rb, line 312 def handle_options(opts) opts.each_pair do |key, value| opt_def = global_option_definitions.find { |o| (o[:long] || o[:short]) == key.to_s } block = opt_def[:block] block.call(value, self) if block end end
# File lib/cri/command.rb, line 336 def handle_parser_errors_while(&block) begin block.call rescue Cri::OptionParser::IllegalOptionError => e $stderr.puts "#{name}: illegal option -- #{e}" exit 1 rescue Cri::OptionParser::OptionRequiresAnArgumentError => e $stderr.puts "#{name}: option requires an argument -- #{e}" exit 1 end end
# File lib/cri/command.rb, line 320 def partition(opts_and_args) # Parse delegate = Cri::Command::OptionParserPartitioningDelegate.new parser = Cri::OptionParser.new(opts_and_args, global_option_definitions) parser.delegate = delegate self.handle_parser_errors_while { parser.run } parser # Extract [ parser.options, delegate.last_argument, parser.unprocessed_arguments_and_options ] end


|
Assimp
5.0.1, master @ cd42b955
|
Helper class to iterate through all keys in an animation channel. More...
Public Member Functions | |
| KeyIterator (const std::vector< aiVectorKey > *_objPos, const std::vector< aiVectorKey > *_targetObjPos, const aiVector3D *defaultObjectPos=nullptr, const aiVector3D *defaultTargetPos=nullptr) | |
| Constructs a new key iterator. More... | |
| bool | Finished () const |
| Returns true if all keys have been processed. More... | |
| const aiVector3D & | GetCurPosition () const |
| Getters to retrieve the current state of the iterator. More... | |
| const aiVector3D & | GetCurTargetPosition () const |
| double | GetCurTime () const |
| void | operator++ () |
| Increment the iterator. More... | |
| void | operator++ (int) |
Private Attributes | |
| aiVector3D | curPosition |
| Represents the current position of the iterator. More... | |
| aiVector3D | curTargetPosition |
| double | curTime |
| std::vector< aiVectorKey > | defaultObjPos |
| std::vector< aiVectorKey > | defaultTargetObjPos |
| unsigned int | nextObjPos |
| unsigned int | nextTargetObjPos |
| const std::vector< aiVectorKey > * | objPos |
| Input tracks and the next key to process. More... | |
| bool | reachedEnd |
| Did we reach the end? More... | |
| const std::vector< aiVectorKey > * | targetObjPos |
Helper class to iterate through all keys in an animation channel.
Missing tracks are interpolated. This is a helper class for TargetAnimationHelper, but it can be freely used for other purposes.
| KeyIterator::KeyIterator | ( | const std::vector< aiVectorKey > * | _objPos, |
| const std::vector< aiVectorKey > * | _targetObjPos, | ||
| const aiVector3D * | defaultObjectPos = nullptr , |
||
| const aiVector3D * | defaultTargetPos = nullptr |
||
| ) |
Constructs a new key iterator.
| _objPos | Object position track. May be nullptr. |
| _targetObjPos | Target object position track. May be nullptr. |
| defaultObjectPos | Default object position to be used if no animated track is available. May be nullptr. |
| defaultTargetPos | Default target position to be used if no animated track is available. May be nullptr. |
|
inline |
Returns true if all keys have been processed.
|
inline |
Getters to retrieve the current state of the iterator.
|
inline |
|
inline |
| void KeyIterator::operator++ | ( | ) |
Increment the iterator.
|
inline |
|
private |
Represents the current position of the iterator.
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
Input tracks and the next key to process.
|
private |
Did we reach the end?
|
private |


Todo:
Todo:
some striked text
Now a link.
| version | status | codename |
|---|---|---|
| v1 | ok | Antilope |
| v2 | not ok | Bear |
| v3 | pending | Crocodile |
| v4 | pending | Elephant |
| v5 | pending | Falcon |
This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph,
This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column,
This paragraph is inside the right column
This paragraph is inside the right column
This paragraph is inside the right column
This paragraph is inside the right column
This paragraph is inside the right column
This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column, This paragraph is inside the left column,
This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column, This paragraph is inside the right column,
This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph, This is a big paragraph,


ListKeyManager
manages the focus in a list of items based on keyboard interaction. Intended to be
used with components that correspond to a role="menu"
or role="listbox"
pattern.
activeItemIndex
Index of the currently active item
activeItem
The active item
tabOut
Observable that emits any time the Tab key is pressed, so components can react when focus is shifted off of the list.
withWrap(): this
Turns on wrapping mode, which ensures that the active item will wrap to the other end of list when there are no more items in the given direction.
setActiveItem(index: number): void
Sets the active item to the item at the index specified.
onKeydown(event: KeyboardEvent): void
Sets the active item depending on the key event passed in.
setFirstItemActive(): void
Sets the active item to the first enabled item in the list.
setLastItemActive(): void
Sets the active item to the last enabled item in the list.
setNextItemActive(): void
Sets the active item to the next enabled item in the list.
setPreviousItemActive(): void
Sets the active item to a previous enabled item in the list.


% if(!fullName) var fullName = "This person"; %>
<%=fullName%> hasn't submitted anything yet.
<% if(username){ %>If you are a previous ACADIS Gateway user, you will need to take additional steps to access your data sets in the new NSF Arctic Data Center.
Send us a message at<EMAIL_ADDRESS>with your old ACADIS Gateway username or and your ORCID identifier (<%=MetacatUI.appUserModel.get("username")%>) and we will help.


Pleasant Activity Scheduling
Some people with tinnitus feel like they can’t enjoy life again unless the tinnitus is quieter or gone. Because of this, they may stop doing many of their usual activities, especially activities they enjoy. If you are doing fewer activities because of tinnitus, then you are more likely to be focused on your tinnitus, and you are more likely to feel unhappy.
One way to start feeling better is to plan pleasant activities even when your tinnitus is bothering you. Pleasant activities can help you enjoy life and pay less attention to your tinnitus. At first, you might feel like you are “relearning” how to enjoy pleasant activities. The activities might be harder to enjoy than they were without tinnitus. With time, you can learn to enjoy the activities even with tinnitus.
Activity Planning
One way to increase pleasant activities is to plan ahead. This may sound simple, but most of the time we wait until we feel better to do something we enjoy. If you let how you feel guide what you do, then you may end up staying home and not doing anything. If you schedule pleasant activities you will find it easier to do something you enjoy. As a result, you may feel more pleasure! Plan at least one pleasant activity each day.
Values
When thinking about which activities are the best fit for you, think about what you value in life. Values are like directions on a compass - they point you where you wish to go. Values can be things like caring for others, service, adventure, scholarship, leadership, faith, family, love, discipline, focus, or fitness. If you pick pleasant activities that fit with your values, the activities can add meaning to your life.
Step 1: Make a List of Pleasant Activities. Make a list of 10 pleasant activities that you would enjoy. These activities can be done with other people or just by yourself. Make sure that each activity is pleasant for you.
Step 2: Plan Pleasant Activities.  Unless you plan the activity by scheduling it, you may continue with your routine as it is. Plan at least one pleasant activity per day. Use a calendar or scheduler to record your plans for pleasant activities. Write down how long you will do the activity and when you will do it.
Step 3: Evaluate
Once per week ask yourself the following questions:
- Did I do all of my scheduled pleasant activities each day?
- Why didn’t I do some or all of my activities as planned?
- Did I notice my tinnitus less when I did these activities?
- Would more activities help me get my mind off of my tinnitus?
- Do I need to have more or fewer pleasant activities?
Use this information to evaluate which activities are best for you. Identify which ones reduce your awareness of tinnitus and which ones lead to the most enjoyment. Then keep going!


computer vision
Contents
5.3. computer vision#
5.3.1. useful packages#
https://www.cellpose.org/ - cell segmentation
Active shape model - Wikipedia
intro (cootes 2000)
Model-based methods make use of a prior model of what is expected in the image, and typically attempt to find the best match of the model to the data in a new image
model
requires user-specified landmarks \(x\) (e.g. points for eyes/nose on a face)
simplest model - use a typical example as a prototype + compare others using correlation
invariances: given a set of image coordinates, for all rotations / scales / translations - try them all so that the sum of distances of each shape to the mean is minimized (called Procrustes analysis)
shape model learns low-dim model of \(x\), maybe using \(k\) top bases of PCA
inference
nearest neighbor: iteratively find transformation + shape model parameters to represent landmarks
classification: non-trivial to define a goodness of fit measure for the landmarks - something like distance between points and strongest nearby edges
active shape model - for each landmark, look for nearby groundtruth, adapt PCA values, apply reasonable constraints, then iterate
improve speed by doing this at large scales before going to more detailed scales
snakes - active contour models (kass et al. 1988)
deformable spline - pulled towards object contours while internal forces resist deformation
5.3.2. what’s in an image?#
vision doesn’t exist in isolation - movement
three R’s: recognition, reconstruction, reorganization
<IP_ADDRESS>. fundamentals of image formation#
<IP_ADDRESS>.1. projections#
image I(x,y) projects scene(X, Y, Z)
lower case for image, upper case for scene
-
f is a fixed dist. not a function
box with pinhole=center of projection, which lets light go through
Z axis points out of box, X and Y aligned w/ image plane (x, y)
perspective projection - maps 3d points to 2d points through holes
perspective projection works for spherical imaging surface - what’s important is 1-1 mapping between rays and pixels
natural measure of image size is visual angle
orthographic projection - appproximation to perspective when object is relatively far
define constant \(s = f/Z_0\)
transform \(x = sX, y = sY\)
<IP_ADDRESS>.2. phenomena from perspective projection#
parallel lines converge to vanishing point (each family has its own vanishing point)
pf: point on a ray \([x, y, z] = [A_x, A_y, A_z] + \lambda [D_x, D_y, D_z]\)
\(x = \frac{fX}{Z} = \frac{f \cdot (A_x+\lambda D_X)}{A_z + \lambda D_z}\)
\(\lambda \to \infty \implies \frac{f \cdot \lambda D_x}{\lambda D_z} = \frac{f \cdot D_x}{D_z}\)
\(\implies\) vanishing point coordinates are \(fD_x / D_z , f D_y / D_z\)
not true when \(D_z = 0\)
all vanishing points lie on horizon
nearer objects are lower in the image
let ground plane be \(Y = -h\) (where h is your height)
point on ground plane \(y = -fh / Z\)
nearer objects look bigger
foreshortening - objects slanted w.r.t line of sight become smaller w/ scaling factor cos \(\sigma\) ~ \(\sigma\) is angle between line of sight and the surface normal
<IP_ADDRESS>. radiometry#
irradiance - how much light (photons) is captured in some time interval
radiant power / unit area (\(W/m^2\))
radiance - power in given direction / unit area / unit solid angle
L = directional quantity (measured perpendicular to direction of travel)
\(L = Power / (dA \cos \theta \cdot d\Omega)\) where \(d\Omega\) is a solid angle (in steradians)
irradiance \(\propto\) radiance in direction of the camera
outgoing radiance of a patch has 3 factors
incoming radiance from light source
angle between light / camera
reflectance properties of patch
2 special cases
specular surfaces - outgoing radiance direction obeys angle of incidence
lambertian surfaces - outgoing radiance same in all directions
albedo * radiance of light * cos(angle)
model reflectance as a combination of Lambertian term and specular term
also illuminated by reflections of other objects (ray tracing / radiosity)
shape-from-shading (SFS) goes from irradiance \(\to\) geometry, reflectances, illumination
<IP_ADDRESS>. frequencies and colors#
contrast sensitivity depends on frequency + color
band-pass filtering - use gaussian pyramid
pyramid blending
eye
iris - colored annulus w/ radial muscles
pupil - hole (aperture) whose size controlled by iris
retina:
colors are what is reflected
cones (short = blue, medium = green, long = red)
metamer - 2 different but indistinguishable spectra
color spaces
rgb - easy for devices
chips tend to be more green
hsv (hue, saturation, value)
lab (perceptually uniform color space)
color constancy - ability to perceive invariant color despite ecological variations
camera white balancing (when entire photo is too yellow or something)
manual - choose color-neutral object and normalize
automatic (AWB)
grey world - force average color to grey
white world - force brightest object to white
5.3.3. image processing#
<IP_ADDRESS>. transformations#
2 object properties
pose - position and orientation of object w.r.t. the camera (6 numbers - 3 translation, 3 rotation)
shape - relative distances of points on the object
nonrigid objects can change shape
Transform (most general on top) |
Constraints |
Invariants |
2d params |
3d params |
|---|---|---|---|---|
Projective = homography (contains perspective proj.) |
Ax + t, A nonsingular, homogenous coords |
parallel -> intersecting |
8 (-1 for scale) |
15 (-1 for scale) |
Affine |
Ax + t, A nonsingular |
parallelism, midpoints, intersection |
6=4+2 |
12=9+3 |
Euclidean = Isometry |
Ax + t, A orthogonal |
length, angles, area |
3=1+2 |
6=3+3 |
Orthogonal (rotation when det = 1 / reflection when det = -1) |
Ax, A orthogonal |
1 |
3 |
projective transformation = homography
homogenous coordinates - use n + 1 coordinates for n-dim space to help us represent points at \(\infty\)
\([x, y] \to [x_1, x_2, x_3]\) with \(x = x_1/x_3, y=x_2/x_3\)
\([x_1, x_2] = \lambda [x_1, x_2] \quad \forall \lambda \neq 0\) - each points is like a line through origin in n + 1 dimensional space
even though we added a coordinate, didn’t add a dimension
standardize - make third coordinate 1 (then top 2 coordinates are euclidean coordinates)
when third coordinate is 0, other points are infinity
all 0 disallowed
Euclidean line \(a_1x + a_2y + a_3=0\) \(\iff\) homogenous line \(a_1 x_1 + a_2x_2 + a_3 x_3 = 0\)
perspective maps parallel lines to lines that intersect
incidence of points on lines
when does a point \([x_1, x_2, x_3]\) lie on a line \([a_1, a_2, a_3]\) (homogenous coordinates)
when \(\mathbf{x} \cdot \mathbf{a} = 0\)
cross product gives intersection of any 2 lines
representing affine transformations: \(\begin{bmatrix}X'\\Y'\\W'\end{bmatrix} = \begin{bmatrix}a_{11} & a_{12} & t_x\\ a_{21} & a_{22} & t_y \\ 0 & 0 & 1\end{bmatrix}\begin{bmatrix}X\\Y\\1\end{bmatrix}\)
representing perspective projection: \(\begin{bmatrix}1 & 0& 0 & 0\\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1/f & 0 \end{bmatrix} \begin{bmatrix}X\\Y\\Z \\ 1\end{bmatrix} = \begin{bmatrix}X\\Y\\Z/f\end{bmatrix} = \begin{bmatrix}fX/Z\\fY/Z\\1\end{bmatrix}\)
affine transformations
affine transformations are a a group
examples
anisotropic scaling - ex. \(\begin{bmatrix}2 & 0 \\ 0 & 1 \end{bmatrix}\)
shear
euclidean transformations = isometries = rigid body transform
preserves distances between pairs of points: \(||\psi(a) - \psi(b)|| = ||a-b||\)
ex. translation \(\psi(a) = a+t\)
composition of 2 isometries is an isometry - they are a group
orthogonal transformations - preserves inner products \(\forall a,b \: a \cdot b =a^T A^TA b\)
\(\implies A^TA = I \implies A^T = A^{-1}\)
\(\implies det(A) = \pm 1\)
2D
really only 1 parameter \( \theta\) (also for the +t)
\(A = \begin{bmatrix}cos \theta & - sin \theta \\ sin \theta & cos \theta \end{bmatrix}\) - rotation, det = +1
\(A = \begin{bmatrix}cos \theta & sin \theta \\ sin \theta & - cos \theta \end{bmatrix}\) - reflection, det = -1
3D
really only 3 parameters
ex. \(A = \begin{bmatrix}cos \theta & - sin \theta & 0 \\ sin \theta & cos \theta & 0 \\ 0 & 0 & 1\end{bmatrix}\) - rotation, det rotate about z-axis (like before)
rotation - orthogonal transformations with det = +1
2D: \(\begin{bmatrix}cos \theta & - sin \theta \\ sin \theta & cos \theta \end{bmatrix}\)
3D: \( \begin{bmatrix}cos \theta & - sin \theta & 0 \\ sin \theta & cos \theta & 0 \\ 0 & 0 & 1\end{bmatrix}\) (rotate around z-axis)
lots of ways to specify angles
axis plus amount of rotation - we will use this
euler angles
quaternions (generalize complex numbers)
Roderigues formula - converts: \(R = e^{\phi \hat{s}} = I + sin [\phi] \: \hat{s} + (1 - cos \phi) \hat{s}^2\)
\(s\) is a unit vector along \(w\) and \(\phi=||w||t\) is total amount of rotation
rotation matrix
can replace cross product with matrix multiplication with a skew symmetric \((B^T = -B)\) matrix:
\(\begin{bmatrix} t_1 \\ t_2 \\ t_3\end{bmatrix}\) ^ \(\begin{bmatrix} x_1 \\ x_2 \\ x_3 \end{bmatrix} = \begin{bmatrix} t_2 x_3 - t_3 x_2 \\ t_3 x_1 - t_1 x_3 \\ t_1 x_2 - t_2 x_1\end{bmatrix}\)
\(\hat{t} = [t_\times] = \begin{bmatrix} 0 & -t_3 & t_2 \\ t_3 & 0 & -t_1 \\ -t_2 & t_1 & 0\end{bmatrix}\)
proof
\(\dot{q(t)} = \hat{w} q(t)\)
\(\implies q(t) = e^{\hat{w}t}q(0)\)
where \(e^{\hat{w}t} = I + \hat{w} t + (\hat{w}t)^2 / w! + ...\)
can rewrite in terms above
<IP_ADDRESS>. image preprocessing#
image is a function from \(R^2 \to R\)
f(x,y) = reflectance(x,y) * illumination(x,y)
image histograms - treat each pixel independently
better to look at CDF
use CDF as mapping to normalize a histogram
histogram matching - try to get histograms of all pixels to be same
need to map high dynamic range (HDR) to 0-255 by ignoring lots of values
do this with long exposure
point processing does this transformation independent of position x, y
can enhance photos with different functions
negative - inverts
log - can bring out details if range was too large
contrast stretching - stretch the value within a certain range (high contrast has wide histogram of values)
sampling
sample and write function’s value at many points
reconstruction - make samples back into continuous function
ex. audio -> digital -> audio
undersampling loses information
aliasing - signals traveling in disguise as other frequencies
antialiasing
can sample more often
make signal less wiggly by removing high frequencies first
filtering
lowpass filter - removes high frequencies
linear filtering - can be modeled by convolution
cross correlation - what cnns do, dot product between kernel and neighborhood
sobel filter is edge detector
gaussian filter - blur, better than just box blur
rule of thumb - set filter width to about 6 \(\sigma\)
removes high-frequency components
convolution - cross-correlation where filter is flipped horizontally and vertically
commutative and associative
convolution theorem: \(F[g*h] = F[g]F[h]\) where F is Fourier, * is convolution
convolution in spatial domain = multiplication in frequency domain
resizing
Gaussian (lowpass) then subsample to avoid aliasing
image pyramid - called pyramid because you can subsample after you blur each time
whole pyramid isn’t much bigger than original image
collapse pyramid - keep upsampling and adding
good for template matching, search over translations
sharpening - add back the high frequencies you remove by blurring (laplacian pyramid):
<IP_ADDRESS>. edges + templates#
edge - place of rapid change in the image intensity function
solns
smooth first, then take gradient
gradient first then smooth gives same results (linear operations are interchangeable)
derivative theorem of convolution - differentiation can also be though of as convolution
can convolve with deriv of gaussian
can give orientation of edges
tradeoff between smoothing (denoising) and good edge localization (not getting blurry edges)
image gradient looks like edges
canny edge detector
filter image w/ deriv of Gaussian
find magnitude + orientation of gradient
non-maximum suppression - does thinning, check if pixel is local maxima
anything that’s not a local maximum is set to 0
on line direction, require a weighted average to interpolate between points (bilinear interpolation = average on edges, then average those points)
hysteresis thresholding - high threshold to start edge curves then low threshold to continue them
Scale-space and edge detection using anisotropic diffusion (perona & malik 1990)
introduces anisotropic diffusion (see wiki page) - removes image noise without removing content
produces series of images, similar to repeatedly convolving with Gaussian
filter review
smoothing
no negative values
should sum to 1 (constant response on constant)
derivative
must have negative values
should sum to 0 (0 response on constant)
intuitive to have positive sum to +1, negative sum to -1
matching with filters (increasing accuracy, but slower)
ex. zero-mean filter subtract mean of patch from patch (otherwise might just match brightest regions)
ex. SSD - L2 norm with filter
doesn’t deal well with intensities
ex. normalized cross-correlation
recognition
instance - “find me this particular chair”
simple template matching can work
category - “find me all chairs”
<IP_ADDRESS>. texture#
texture - non-countable stuff
related to material, but different
texture analysis - compare 2 things, see if they’re made of same stuff
pioneered by bela julesz
random dot stereograms - eyes can find subtle differences in randomness if fed to different eyes
human vision sensitive to some difference types, but not others
easy to classify textures based on v1 gabor-like features
can make histogram of filter response histograms - convolve filter with image and then treat each pixel independently
heeger & bergen siggraph 95 - given texture, want to make more of that texture
start with noise
match histograms of noise with each of your filter responses
combine them back together to make an image
repeat this iteratively
simoncelli + portilla 98 - also match 2nd order statistics (match filters pairwise)
much harder, but works better
texton histogram matching - classify images
use “computational version of textons” - histograms of joint responses
like bag of words but with “visual words”
won’t get patches with exact same distribution, so need to extract good “words”
define words as k-means of features from 10x10 patches
features could be raw pixels
gabor representation ~10 dimensional vector
SIFT features: histogram set of oriented filters within each box of grid
HOG features
usually cluster over a bunch of images
invariance - ex. blur signal
each image patch -> a k-means cluster so image -> histogram
then just do nearest neighbor on this histogram (chi-squared test is good metric)
object recognition is really texture recognition
all methods follow these steps
compute low-level features
aggregate features - k-means, pool histogram
use as visual representation
why these filters - sparse coding (data driven find filters)
<IP_ADDRESS>. optical flow#
simplifying assumption - world doesn’t move, camera moves
lets us always use projection relationship \(x, y = -Xf/Z, -Yf/Z\)
optical flow - movement in the image plane
square of points moves out as you get closer
as you move towards something, the center doesn’t change
things closer to you change faster
if you move left / right points move in opposite direction
rotations also appear to move opposite to way you turn your head
equations: relate optical flow in image to world coords
optical flow at \((u, v) = (\Delta x / \Delta t, \Delta y/ \Delta t)\) in time \(\Delta t\)
function in image space (produces vector field)
\(\begin{bmatrix} \dot{X}\\ \dot{Y} \\ \dot{Z} \end{bmatrix} = -t -\omega \times \begin{bmatrix} X \\ Y \\ Z\end{bmatrix} \implies \begin{bmatrix} \dot{x}\\ \dot{y}\end{bmatrix}= \frac{1}{Z} \begin{bmatrix} -1 & 0 & x\\ 0 & 1 & y\end{bmatrix} \begin{bmatrix} t_x \\ t_y \\ t_z \end{bmatrix}+ \begin{bmatrix} xy & -(1+x^2) & y \\ 1+y^2 & -xy & -x\end{bmatrix}\begin{bmatrix} \omega_x \\ \omega_y \\ \omega_z\end{bmatrix}\)
decomposed into translation component + rotation component
\(t_z / Z\) is time to impact for a point
translational component of flow fields is more important - tells us \(Z(x, y)\) and translation \(t\)
we can compute the time to contact
this is a key to what is used in video compression
5.3.4. cogsci / neuro#
<IP_ADDRESS>. psychophysics#
julesz search experiment
“pop-out” effect of certain shapes (e.g. triangles but not others)
axiom 1: human vision has 2 modes
preattentive vision - parallel, instantaneous (~100-200 ms)
large visual field, no scrutiny
surprisingly large amount of what we do
ex. sensitive to size/width, orientation changes
attentive vision - serial search with small focal attention in 50 ms steps
axiom 2: textons are the fundamental elements in preattentive vision
texton is invariant in preattentive vision
ex. elongated blobs (rectangles, ellipses, line segments w/ orientation/width/length)
ex. terminators - ends of line segments
crossing of line segments
julesz conjecture (not quite true) - textures can’t be spontaneously discriminated if they have same first-order + second-order statistics (ex. density)
humans can saccade to correct place in object detection really fast (150 ms - Kirchner & Thorpe, 2006)
still in preattentive regime
can also do object detection after seeing image for only 40 ms
<IP_ADDRESS>. neurophysiology#
on-center off-surround - looks like Laplacian of a Gaussian
horizontal cell “like convolution”
LGN does quick processing
hubel & wiesel - single-cell recording from visual cortex in v1
3 v1 cell classes
simple cells - sensitive to oriented lines
oriented Gaussian derivatives
some were end-stopped
complex cells - simple cells with some shift invariance (oriented lines but with shifts)
could do this with maxpool on simple cells
hypercomplex cells (less common) - complex cell, but only lines of certain length
retinotopy - radiation stain on retina maintained radiation image
hypercolumn - cells of different orientations, scales grouped close together for a location
<IP_ADDRESS>. perceptual organization#
max werthermian - we perceive things not numbers
principles: grouping, element connectedness
figure-ground organization: surroundedness, size, orientation, contrast, symmetry, convexity
gestalt - we see based on context
5.3.5. correspondence + applications (steropsis, optical flow, sfm)#
<IP_ADDRESS>. binocular steropsis#
stereopsis - perception of depth
disparity - difference in image between eyes
this signals depth (0 disparity at infinity)
measured in pixels (in retina plane) or angle in degrees
sign doesn’t really matter
active stereopsis - one projector and one camera vs passive (ex. eyes)
active uses more energy
ex. kinect - measure / triangulate
worse outside
ex. lidar - time of light - see how long it takes for light to bounce back
3 types of 2-camera configurations: single point, parallel axes, general case
<IP_ADDRESS>.1. single point of fixation (common in eyes)#
fixation point has 0 disparity
humans do this to put things in the fovea
use coordinates of cyclopean eye
vergence movement - look at close / far point on same line
change angle of convergence (goes to 0 at \(\infty\))
disparity = \( 2 \delta \theta = b \cdot \delta Z / Z^2\) where b - distance between eyes, \(\delta Z\) - change in depth, Z - depth
-
b - distance between eyes, \(\delta\) - change in depth, Z - depth
version movement - change direction of gaze
forms Vieth-Muller circle - points lie on same circle with eyes
cyclopean eye isn’t on circle, but close enough
disparity of P’ = \(\alpha - \beta = 0\) on Vieth-Muller circle
<IP_ADDRESS>.2. optical axes parallel (common in robots)#
disparity \(d = x_l - x_r = bf/Z\)
error \(|\delta Z| = \frac{Z^2 |\delta d|}{bf}\)
parallax - effect where near objects move when you move but far don’t
<IP_ADDRESS>.3. general case (ex. reconstruct from lots of photos)#
given n point correspondences, estimate rotation matrix R, translation t, and depths at the n points
more difficult - don’t know coordinates / rotations of different cameras
epipolar plane - contains cameras, point of fixation
different epipolar planes, but all contain line between cameras
\(\vec{c_1 c_2}\) is on all epipolar planes
each image plane has corresponding epipolar line - intersection of epipolar plane with image plane
epipole - intersection of \(\vec{c_1 c_2}\) and image plane
structure from motion problem: given n corresponding projections \((x_i, y_i)\) in both cameras, find \((X_i, Y_i, Z_i)\) by estimating R, t: Longuet-Higgins 8-point algorithm - overall minimizing re-projection error (basically minimizes least squares = bundle adjustment)
find \(n (\geq 8)\) corresponding points
estimate essential matrix \(E = \hat{T} R\) (converts between points in normalized image coords - origin at optical center)
fundamental matrix F corresponds between points in pixel coordinates (more degrees of freedom, coordinates not calibrated )
essential matrix constraint: \(x_1, x_2\) homogoneous coordinates of \(M_1, M_2 \implies x_2^T \hat{T} R x_1 = 0\)
6 or 5 dof; 3 dof for rotation, 3 dof for translation. up to a scale, so 1 dof is removed
\(t = c_2 - c_1, x_2\) in second camera coords, \(Rx_1\) moves 1st camera coords to second camera coords
need at least 8 pairs of corresponding points to estimate E (since E has 8 entries up to scale)
if they’re all coplanar, etc doesn’t always work (need them to be independent)
extract (R, t)
triangulation
<IP_ADDRESS>. solving for stereo correspondence#
stereo correspondence = stereo matching: given point in one image, find corresponding point in 2nd image
basic stereo matching algorithm
stereo image rectification - transform images so that image planes are parallel
now, epipolar lines are horizontal scan lines
do this by using a few points to estimate R, t
for each pixel in 1st image
find corresponding epipolar line in 2nd image
correspondence search: search this line and pick best match
simple ex. parallel optical axes = assume cameras at same height, same focal lengths \(\implies\) epipolar lines are horizontal scan lines
correspondence search algorithms (simplest to most complex)
assume photo consistency - same points in space will give same brightness of pixels
take a window and use metric
larger window smoother, less detail
metrics
minimize L2 norm (SSD)
maximize dot product (NCC - normalized cross correlation) - this works a little better because calibration issues could be different
failures
textureless surfaces
occlusions - have to extrapolate the disparity
half-occlusion - can’t see from one eye
full-occlusion - can’t see from either eye
repetitions
non-lambertian surfacies, specularities - mirror has different brightness from different angles
<IP_ADDRESS>.1. optical flow II#
related to stereo disparity except moving one camera over time
aperture problem - looking through certain hole can change perception (ex. see movement in wrong directions)
measure correspondence over time
for point (x, y, t), optical flow is (u,v) = \((\Delta x / \Delta t, \Delta y / \Delta t)\)
optical flow constraint equation: \(I_x u + I_y v + I_t = 0\)
assume everything is Lambertian - brightness of any given point will stay the same
also add brightness constancy assumption - assume brightness of given point remains constant over short period \(I(x_1, y_1, t_1) = I(x_1 + \Delta x, y_1 + \Delta x, t_1 + \Delta t)\)
here, \(I_x = \partial I / \partial x\)
local constancy of optical flow - assume u and v are same for n points in neighborhood of a pixel
rewrite for n points(left matrix is A): \(\begin{bmatrix} I_x^1 & I_y^1\\ I_x^2 & I_y^2\\ \vdots & \vdots \\ I_x^n & I_y^n\\ \end{bmatrix}\begin{bmatrix} u \\ v\end{bmatrix} = - \begin{bmatrix} I_t^1\\ I_t^2\\ \vdots \\ I_t^n\\\end{bmatrix}\)
then solve with least squares \(\begin{bmatrix} u \\ v\end{bmatrix}=-(A^TA^{-1} A^Tb)\)
second moment matrix \(A^TA\) - need this to be high enough rank
<IP_ADDRESS>. general correspondence + interest points#
more general correspondence - matching points, patches, edges, or regions across images (not in the same basic image)
most important problem - used in steropsis, optical flow, structure from motion
2 ways of finding correspondences
align and search - not really used
keypoint matching - find keypoint that matches and use everything else
3 steps to kepoint matching: detection, description, matching
<IP_ADDRESS>.1. detection - identify key points#
find ‘corners’ with Harris corner detector
shift small window and look for large intensity change in multiple directions
edge - only changes in one direction
compare auto-correlation of window (L2 norm of pixelwise differences)
very slow naively - instead look at gradient (Taylor series expansion - second moment matrix M)
if gradient isn’t flat, then it’s a corner
look at eigenvalues of M
eigenvalues tell you about magnitude of change in different directions
if same, then circular otherwise elliptical
corner - 2 large eigenvalues, similar values
edge - 1 eigenvalue larger than other
simple way to compute this: \(det(M) - \alpha \: trace(M)^2\)
apply max filter to get rid of noise
adaptive - want to distribute points across image
invariance properties
ignores affine intensity change (only uses derivs)
ignores translation/rotation
does not ignore scale (can fix this by considering multiple scales and taking max)
<IP_ADDRESS>.2. description - extract vector feature for each key point#
lots of ways - ex. SIFT, image patches wrt gradient
simpler: MOPS
take point (x, y), scale (s), and orientation from gradients
take downsampled rectangle around this point in proper orientation
invariant to things like shape / lighting changes
<IP_ADDRESS>.3. matching - determine correspondence between 2 views#
not all key points will match - only match above some threshold
ex. criteria: symmetry - only use if a is b’s nearest neighbor and b is a’s nearest neighbor
better: David Lowe trick - how much better is 1-NN than 2-NN (e.g. threshold on 1-NN / 2-NN)
problem: outliers will destroy fit
RANSAC algorithm (random sample consensus) - vote for best transformation
repeat this lots of times, pick the match that had the most inliers
select n feature pairs at random (n = minimum needed to compute transformation - 4 for homography, 8 for rotation/translation)
compute transformation T (exact for homography, or use 8-point algorithm)
count inliers (how many things agree with this match)
8-point algorithm / homography check
\(x^TEx < \epsilon \) for 8-point algorithm or \(x^THx < \epsilon\) for homography
finally, could recompute least squares H or F on all inliers
<IP_ADDRESS>. correspondence for sfm / instance retrieval#
sfm (structure for motion) - given many images, simultaneously do 2 things
calibration - find camera parameters
triangulation - find 3d points from 2d points
structure for motion system (ex. photo tourism 2006 paper)
camera calibration: determine camera parameters from known 3d points
parameters
internal parameters - ex. focal length, optical center, aspect ratio
external parameters - where is the camera
only makes sense for multiple cameras
approach 1 - solve for projection matrix (which contains all parameters)
requires knowing the correspondences between image and 3d points (can use calibration object)
least squares to find points from 3x4 projection matrix which projects (X, Y, Z, 1) -> (x, y, 1)
approach 2 - solve for parameters
translation T, rotation R, focal length f, principle point (xc, yc), pixel size (sx, sy)
can’t use homography because there are translations with changing depth
sometimes camera will just list focal length
decompose projection matrix into a matrix dependent on these things
nonlinear optimization
triangulation - predict 3d points \((X_i, Y_i, Z_i)\) given pixels in multiple cameras \((x_i, y_i)\) and camera parameters \(R, t\)
minimize reprojection error (bundle adjustment): \(\sum_i \sum_j \underbrace{w_{ij}}_{\text{indicator var}}\cdot || \underbrace{P(x_i, R_j, t_j)}_{\text{pred. im location}} - \underbrace{\begin{bmatrix} u_{i, j}\\v_{i, j}\end{bmatrix}}_{\text{observed m location}}||^2\)
solve for matrix that projects points into 3d coords
incremental sfm: start with 2 cameras
initial pair should have lots of matches, big baseline (shouldn’t just be a homography)
solve with essential matrix
then iteratively add cameras and recompute
good idea: ignore lots of data since data is cheap in computer vision
search for similar images - want to establish correspondence despite lots of changes
see how many keypoint matches we get
search with inverted file index
ex. visual words - cluster the feature descriptors and use these as keys to a dictionary
inverted file indexing
should be sparse
spatial verification - don’t just use visual words, use structure of where the words are
want visual words to give similar transformation - RANSAC with some constraint
5.3.6. deep learning#
<IP_ADDRESS>. cnns#
object recognition - visual similarity via labels
classification
linear boundary -> nearest neighbors
neural nets
don’t need feature extraction step
high capacity (like nearest neighbors)
still very fast test time
good at high dimensional noisy inputs (vision + audio)
pooling - kind of robust to exact locations
a lot like blurring / downsampling
everyone now uses maxpooling
history: lenet 1998
neocognitron (fukushima 1980) - unsupervised
convolutional neural nets (lecun et al) - supervised
alexnet 2012
used norm layers (still common?)
resnet 2015
152 layers
3x3s with skip layers
like nonparametric - number of params is close to number of data points
network representations learn a lot
zeiler-fergus - supercategories are learned to be separated, even though only given single class lavels
nearest neighbors in embedding spaces learn things like pose
can be used for transfer learning
fancy architectures - not just a classifier
siamese nets
ex. want to compare two things (ex. surveillance) - check if 2 people are the same (even w/ sunglasses)
ex. connect pictures to amazon pictures
embed things and make loss function distance between real pics and amazon pics + make different things farther up to some margin
ex. searching across categories
multi-modal
ex. could look at repr. between image and caption
semi-supervised
context as supervision - from word predict neighbors
predict neighboring patch from 8 patches in image
multi-task
many tasks / many losses at once - everything will get better at once
differentiable programming - any nets that form a DAG
if there are cycles (RNN), unroll it
fully convolutional
works on different sizes
this lets us have things per pixel, not per image (ex. semantic segmentation, colorization)
usually use skip connections
<IP_ADDRESS>. image segmentation#
consistency - 2 segmentations consistent when they can be explained by same segmentation tree
percept tree - describe what’s in an image using a tree
evaluation - how to correspond boundaries?
min-cost assignment on bipartite graph=bigraph - connections only between groundtruth, signal:
ex. for each pixel predict if it’s on a boundary by looking at window around it
proximity cue
boundary cues: brightness gradient, color gradient, texture gradient (gabor responses)
look for sharp change in the property
region cue - patch similarity
proximity
graph partitioning
learn cue combination by fitting linear combination of cues and outputting whether 2 pixels are in same segmentation
graph partitioning approach: generate affinity graph from local cues above (with lots of neighbors)
normalized cuts - partition so within-group similarity is large and between-group similarity is small
deep semantic segmentation - fully convolutional
upsampling
unpooling - can fill all, always put at top-left
max-unpooling - use positions from pooling layer
learnable upsampling = deconvolution = upconvolution = fractionally strided convolution = backward strided convolution - transpose the convolution
<IP_ADDRESS>. classification + localization#
goal: coords (x, y, w, h) for each object + class
simple: sliding window and use classifier each time - computationally expensive!
region proposals - find blobby image regions likely to contain objects and run (fast)
R-CNN - run each region of interest, warped to some size, through CNN
Fast R-CNN - get ROIs from last conv layer, so everything is faster / no warping
to maintain size, fix number of bins instead of filter sizes (then these bins are adaptively sized) - spatial pyramid pooling layer
Faster R-CNN - use region proposal network within network to do region proposals as well
train with 4 losses for all things needed
region proposal network uses multi-scale anchors and predicts relative to convolution
instance segmentation
mask-rcnn - keypoint detection then segmentation
<IP_ADDRESS>. learning detection#
countour detection - predict contour after every conv (at different scales) then interpolate up to get one final output (ICCV 2015)
deep supervision helps to aggregate multiscale info
semantic segmentation - sliding window
classification + localization
need to output a bounding box + classify what’s in the box
bounding box: regression problem to output box
use locations of features
feature map
location of a feature in a feature map is where it is in the image (with finer localization info accross channels)
response of a feature - what it is
<IP_ADDRESS>.1. modeling figure-ground#
figure is closer, ground background - affects perception
figure/ground datasets
local cues
edge features: shapemes - prototypical local shapes
junction features: line labelling - contour directions with convex/concave images
lots of principles
surroundedness, size, orientation, constrast, symmetry, convexity, parallelism, lower region, meaningfulness, occlusion, cast shadows, shading
global cues
want consistency with CRF
spectral graph segmentation
embedding approach - satisfy pairwise affinities
<IP_ADDRESS>. single-view 3d construction#
useful for planning, depth, etc.
different levels of output (increasing complexity)
image depth map
scene layout - predict simple shapes of things
volumetric 3d - predict 3d binary voxels for which voxels are occupied
could approximate these with CAD models, deformable shape models
need to use priors of the world
(explicit) single-view modeling - assume a model and fit it
many classes are very difficult to model explicitly
ex. use dominant edges in a few directions to calculate vanishing points and then align things
(implicit) single-view prediction - learn model of world data-driven
collect data + labels (ex. sensors)
train + predict
supervision from annotation can be wrong
<IP_ADDRESS>. unsupervised keypoint learning#
Unsupervised Learning of Visual 3D Keypoints for Control (chen, abbeel, & pathak, 2021) - learn keypoints unsupervised from video
KeypointDeformer: Unsupervised 3D Keypoint Discovery for Shape Control (jakab…kanazawa, 2021) - learn to predict keypoints completely unsupervised
can also manipulate keypoints and generate new shape
Lions and Tigers and Bears: Capturing Non-Rigid, 3D, Articulated Shape From Images (zuffi, kanazawa, & black, 2018) - capture 3d shape of animals using 2d images alone
Self-Supervised Learning of Interpretable Keypoints From Unlabelled Videos (jakab et al. 2020 cvpr) - recognize pose uses unlabelled videos + weak empirical prior on the object poses
Unsupervised Object Keypoint Learning using Local Spatial Predictability (gopalakrishnan…schmidhuber, 2021) - identifies salient regions by trying to predict local image regions from spatial neighborhoods
applications to Atari


About Me
My career path has encompassed a variety of fields, including material science, architecture and industrial design.
I've done scientific research on low temperature aluminum superconductors under Professor Nina Markovic,
architectural design at PRESENT Architecture and product design with additive manufacturing at Studio Bitonti.
In that time, I've helped bring innovative products to market including 3D printed shoes for Feetz and new scoliosis braces for UNYQ.
I've also done multiple innovation based projects involving wearable technology, the manufacturing of conductive polymer compounds,
new mass customized product lines for gamers and a scoliosis brace that was acquired by The Cooper Hewitt Design Museum.
My sincere belief is that a design is only as good as the research behind it and the best research comes from the study of multiple intersecting fields.
To reach me directly, please email me at wildfeuer.peter@gmail.com


{% extends 'tt_core/base.html' %} {% block content %}
Thank you so much for checking this project out. It was genuinely a blast to make but it would be even better if people found it fun to use, too!
If you're wanting to contribute, that's incredible. Thanks again. This has been split into two sections: the first is how to contribute if you're not so tech-y, and the second is how to contribute if you can hack on a bit of code, too.
First, though, let's go over the known issues with the site.
If you have any bugs or feature requests, let me (Tom) know (you can email tweaktoday -at- tomwallis -dot- net) and he'll add it to the list!
Im so glad you want to contribute to the site! You can find the code in its github repo. The whole thing is django. CSS is a combination of skeleton.css and tufte.css.
Thanks so much!
— Tom.


{% extends "layout.html" %} {% block page_title %} Registered Traveller {% endblock %} {% block content %} Add your child to your membership Your Registered Traveller number Your date of birth expected format is DD/MM/YYY For example, 21 3 1979 New passport expiry date Day expected format DD. Required New passport expiry date Month expected format MM. Required New passport expiry date Year expected format YYYY. Required {% endblock %}
For example, 21 3 1979


Harbor seal and forage fish, east Strait of Juan de Fuca, 6/26/2011
Which species are highest priority for you?
Furthest along with long-term monitoring time series: SRKWs, Bigg's, harbor porpoise, and harbor seal...With inspiration from Marine Waters longer-term time-series!
PDO+NPDO (1950); herring spawning biomass (1973); bird metrics (1974); larval fish density (2000).
Data sources -- 1973-present from Ken Balcomb, Center for Whale Research; 1960-1972 from Olesiuk et al., 1990; baselines and forecasts from NOAA recovery plan
With inspiration from Marine Waters longer-term time-series!
PDO+NPDO (1950); herring spawning biomass (1973); bird metrics (1974); larval fish density (2000).
Data sources -- 1973-present from Ken Balcomb, Center for Whale Research; 1960-1972 from Olesiuk et al., 1990; baselines and forecasts from NOAA recovery plan
Data source: Ken Balcomb, Center for Whale Research
Draft SRKW entry for 2018 Marine Waters report
Long-term trends: increasing annual occurence; seasonal peak in August ~1990; bimodal peak in Apr-May and Aug-Sep
Data sources: 1987-1993 (Baird and Dill, 1995); 2004-2010 (Houghton et al., 2015); 2011-2017 (Shields et al., 2018).
Draft Bigg's "species brief" for the Encyclopedia of Puget Sound (EoPS) (Monika Wieland, lead MMWG author)
Winter density of harbor porpoise and Dall’s porpoise during 1995-2015 by region.
Data source: aerial surveys by Evenson et al., 2016
Draft harbor porpoise species brief for the EoPS (Cindy Elliser, lead MMWG author)
Estimated haulout counts of three WA inland stocks 1978-2015.
Data source: 12/14/2018 WDFW Commission presentation by Pamplin, Anderson, and Pearson
(Carrying capacity earlier ~1995 in Strait of Georgia 1974-2009.)
Notes for harbor seal species brief for the EoPS
/


The current request will be saved as a favorite. The request method (GET/POST etc.) and any payload or headers will also be saved.
Enter a name for the new favorite.


Clicks number
Day as YYYY-MM-DD
Impressions number
Events number
Month as YYYY-MM
1 if period=overall
Reach
Spent funds
Clickthoughs to the advertised site
Video views number
Video views (full video)
Video views (half of video)
Generated using TypeDoc
Clicks number


--- title: Facer Creator Overview category: Getting Started order: 1 ---
The canvas is your main working area for a watch face. All elements will be added to the canvas, and it can show you your watch face in different times (using the time machine) & modes. On the canvas you can drag your elements into position, resize, and rotate them.
The layer list contains all layers for your watch. The elements are listed in order from top to bottom as a stack. You can think about it like a stack of paper - elements at the top will cover up the elements below. From here you can drag and drop element's orders, toggle visibility, and rename/duplicate/delete elements.
The Facer Time Machine allows you to see your watch face in action. You can use this to preview how your watch will change throughout the day. Use the slider to drag to specific times, or view your watch face animations by using the play & fast-forward buttons.
Every element has an 'advanced' panel, which is where you can add tags, expressions, formulas and more! The advanced section lets you get under the hood and build anything you can dream up in the Facer creator.
Shape previews show your watch face as it will appear in various shapes and sizes of watches. In order to get the best exposure for your creations, make sure your watch looks great in both square and round formats, and preview how it will look on watches that have a 'chin' element at the bottom of the dial.


{{ if $.Scratch.Get "h1" }}
{{ .Title }}
{{ $.Scratch.Set "h1" false }} {{ else }}{{ .Title }}
{{ end }} {{ with .Description }}{{ . }}
{{ end }}Since you were likely referred one of my public profiles, you might have an idea of my skills and background. However, there’s more to my story than you’ll find on LinkedIn or online resume listings. The following notes provide work history from the time I left college until I relocated to the west coast. Since I refer to this formative period throughout this site I thought it worth providing some context here.
{{ $paginator := .Paginate (where .Data.Pages "Type" "itemized") 10 }}
{{ range .Paginator.Pages }}
{{ .Render "content-list" }}
{{ end }}


This is the course website CSCI P-14110
This is the course website for Intro to Scientific Computing and Data Viz, instructed by Jill P. Naiman (jnaiman@illinois.edu).
The Canvas webpage is where Assignments will be posted: https://canvas.harvard.edu/courses/57025
Slack site is: https://cscip14110sum-arr8217.slack.com
Below, you will find the materials for each lesson, as well as a syllabus that includes contact information and a course outline.
Homework resubmission policy: if you want to re-submit a new answer for a graded HW, you can earn up to 1/2 of the points back (for example: if you missed 4 points you can earn up to 2 back on your resubmission).
Some handy references you might appreciate: