Variable
| Static Public Summary | ||
| public |
ELogContext: * |
|
| public |
ELogLevel: * |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
STATE: {"NONE": *, "ROTATE": *, "DOLLY": number, "PAN": number, "TOUCH_ROTATE": number, "TOUCH_DOLLY": number, "TOUCH_PAN": number} This file is a modified version of THREE.OrbitControls Contributors: |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
cmPerPixel: * |
|
| public |
|
|
| public |
The dimensioning unit for 2D floorplan measurements. |
|
| public |
The initial wall height in cm. |
|
| public |
The initial wall thickness in cm. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
defaultRoomTexture: {"url": string, "scale": number} Default texture to be used if nothing is provided. |
|
| public |
defaultWallTexture: {"url": string, "stretch": boolean, "scale": *} The default wall texture. |
|
| public |
|
|
| public |
Dimensioning in Centi Meter. |
|
| public |
Dimensioning in Inch. |
|
| public |
Dimensioning in Inch. |
|
| public |
Dimensioning in Meter. |
|
| public |
Dimensioning in Milli Meter. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
floorplannerModes: {"MOVE": *, "DRAW": number, "DELETE": number} |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
item_types: {"1": *, "2": *, "3": *, "7": *, "8": *, "9": *, "0": *, "4": *} |
|
| public |
logContext: * The current log context. |
|
| public |
pixelsPerCm: * |
|
| public |
|
|
| public |
|
|
| public |
how much will we move a corner to make a wall axis aligned (cm) |
|
| public |
states: {"UNSELECTED": *, "SELECTED": number, "DRAGGING": number, "ROTATING": number, "ROTATING_FREE": number, "PANNING": number} |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
Static Public
public EVENT_ACTION: string source
import {EVENT_ACTION} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_CAMERA_ACTIVE_STATUS: string source
import {EVENT_CAMERA_ACTIVE_STATUS} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_CAMERA_MOVED: string source
import {EVENT_CAMERA_MOVED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_CAMERA_VIEW_CHANGE: string source
import {EVENT_CAMERA_VIEW_CHANGE} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_CHANGED: string source
import {EVENT_CHANGED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_CORNER_2D_CLICKED: string source
import {EVENT_CORNER_2D_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_CORNER_2D_DOUBLE_CLICKED: string source
import {EVENT_CORNER_2D_DOUBLE_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_CORNER_2D_HOVER: string source
import {EVENT_CORNER_2D_HOVER} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_DELETED: string source
import {EVENT_DELETED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_FLOOR_CLICKED: string source
import {EVENT_FLOOR_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_FPS_EXIT: string source
import {EVENT_FPS_EXIT} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_GLTF_READY: string source
import {EVENT_GLTF_READY} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ITEM_LOADED: string source
import {EVENT_ITEM_LOADED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ITEM_LOADING: string source
import {EVENT_ITEM_LOADING} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ITEM_REMOVED: string source
import {EVENT_ITEM_REMOVED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ITEM_SELECTED: string source
import {EVENT_ITEM_SELECTED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ITEM_UNSELECTED: string source
import {EVENT_ITEM_UNSELECTED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_LOADED: string source
import {EVENT_LOADED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_LOADING: string source
import {EVENT_LOADING} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_MODE_RESET: string source
import {EVENT_MODE_RESET} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_NOTHING_CLICKED: string source
import {EVENT_NOTHING_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_REDRAW: string source
import {EVENT_REDRAW} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ROOM_2D_CLICKED: string source
import {EVENT_ROOM_2D_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ROOM_2D_DOUBLE_CLICKED: string source
import {EVENT_ROOM_2D_DOUBLE_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ROOM_2D_HOVER: string source
import {EVENT_ROOM_2D_HOVER} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ROOM_CLICKED: string source
import {EVENT_ROOM_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_ROOM_NAME_CHANGED: string source
import {EVENT_ROOM_NAME_CHANGED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_UPDATED: string source
import {EVENT_UPDATED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_WALL_2D_CLICKED: string source
import {EVENT_WALL_2D_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_WALL_2D_DOUBLE_CLICKED: string source
import {EVENT_WALL_2D_DOUBLE_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_WALL_2D_HOVER: string source
import {EVENT_WALL_2D_HOVER} from 'blueprint3d-js/scripts/core/events.js'
public EVENT_WALL_CLICKED: string source
import {EVENT_WALL_CLICKED} from 'blueprint3d-js/scripts/core/events.js'
public STATE: {"NONE": *, "ROTATE": *, "DOLLY": number, "PAN": number, "TOUCH_ROTATE": number, "TOUCH_DOLLY": number, "TOUCH_PAN": number} source
import {STATE} from 'blueprint3d-js/scripts/three/controls.js'
This file is a modified version of THREE.OrbitControls Contributors:
public VIEW_FRONT: string source
import {VIEW_FRONT} from 'blueprint3d-js/scripts/core/constants.js'
public VIEW_ISOMETRY: string source
import {VIEW_ISOMETRY} from 'blueprint3d-js/scripts/core/constants.js'
public VIEW_RIGHT: string source
import {VIEW_RIGHT} from 'blueprint3d-js/scripts/core/constants.js'
public cmPerFoot: number source
import {cmPerFoot} from 'blueprint3d-js/scripts/core/dimensioning.js'
public config: {"dimUnit": *, "wallHeight": number, "wallThickness": number} source
import {config} from 'blueprint3d-js/scripts/core/configuration.js'
public configDimUnit: string source
import {configDimUnit} from 'blueprint3d-js/scripts/core/configuration.js'
The dimensioning unit for 2D floorplan measurements.
public configWallHeight: string source
import {configWallHeight} from 'blueprint3d-js/scripts/core/configuration.js'
The initial wall height in cm.
public configWallThickness: string source
import {configWallThickness} from 'blueprint3d-js/scripts/core/configuration.js'
The initial wall thickness in cm.
public cornerColor: string source
import {cornerColor} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public cornerColorHover: string source
import {cornerColorHover} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public cornerRadius: number source
import {cornerRadius} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public cornerRadiusHover: number source
import {cornerRadiusHover} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public cornerTolerance: number source
import {cornerTolerance} from 'blueprint3d-js/scripts/model/corner.js'
public defaultFloorPlanTolerance: number source
import {defaultFloorPlanTolerance} from 'blueprint3d-js/scripts/model/floorplan.js'
public defaultRoomTexture: {"url": string, "scale": number} source
import {defaultRoomTexture} from 'blueprint3d-js/scripts/model/room.js'
Default texture to be used if nothing is provided.
public defaultWallTexture: {"url": string, "stretch": boolean, "scale": *} source
import {defaultWallTexture} from 'blueprint3d-js/scripts/model/wall.js'
The default wall texture.
public deleteColor: string source
import {deleteColor} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public dimCentiMeter: string source
import {dimCentiMeter} from 'blueprint3d-js/scripts/core/dimensioning.js'
Dimensioning in Centi Meter.
public dimFeetAndInch: string source
import {dimFeetAndInch} from 'blueprint3d-js/scripts/core/dimensioning.js'
Dimensioning in Inch.
public dimInch: string source
import {dimInch} from 'blueprint3d-js/scripts/core/dimensioning.js'
Dimensioning in Inch.
public dimMeter: string source
import {dimMeter} from 'blueprint3d-js/scripts/core/dimensioning.js'
Dimensioning in Meter.
public dimMilliMeter: string source
import {dimMilliMeter} from 'blueprint3d-js/scripts/core/dimensioning.js'
Dimensioning in Milli Meter.
public dimensioningOptions: undefined[] source
import {dimensioningOptions} from 'blueprint3d-js/scripts/core/dimensioning.js'
public edgeColor: string source
import {edgeColor} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public edgeColorHover: string source
import {edgeColorHover} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public edgeWidth: number source
import {edgeWidth} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public floorplannerModes: {"MOVE": *, "DRAW": number, "DELETE": number} source
import {floorplannerModes} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public gridColor: string source
import {gridColor} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public gridSpacing: number source
import {gridSpacing} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public gridWidth: number source
import {gridWidth} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public item_types: {"1": *, "2": *, "3": *, "7": *, "8": *, "9": *, "0": *, "4": *} source
import {item_types} from 'blueprint3d-js/scripts/items/factory.js'
public logContext: * source
import {logContext} from 'blueprint3d-js/scripts/core/log.js'
The current log context. To be set when initializing the Application.
public pixelsPerCm: * source
import {pixelsPerCm} from 'blueprint3d-js/scripts/core/dimensioning.js'
public pixelsPerFoot: number source
import {pixelsPerFoot} from 'blueprint3d-js/scripts/core/dimensioning.js'
public roomColor: string source
import {roomColor} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public snapTolerance: number source
import {snapTolerance} from 'blueprint3d-js/scripts/floorplanner/floorplanner.js'
how much will we move a corner to make a wall axis aligned (cm)
public states: {"UNSELECTED": *, "SELECTED": number, "DRAGGING": number, "ROTATING": number, "ROTATING_FREE": number, "PANNING": number} source
import {states} from 'blueprint3d-js/scripts/three/controller.js'
public wallColor: string source
import {wallColor} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public wallColorHover: string source
import {wallColorHover} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public wallWidth: number source
import {wallWidth} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'
public wallWidthHover: number source
import {wallWidthHover} from 'blueprint3d-js/scripts/floorplanner/floorplanner_view.js'


Basic Usages:
- Input the world and map ID wanna to be viewed;
- Enabling
All Nodes
will show unlocked node detials if map data is ready (have sortied to this map once);
- Enabling
Edge IDs
, Arrows
, Red BG
will add optional details to map rendering;
- Enabling
Enemies
will show offical in-game abyssal ship icons (still no submarine icon for some nodes);
- Input / paste makers JSON, both markers and JSON texts will be updated on focus out;
- Drag markers to their proper position on map. Zoom to 100% if accurate coordinates needed;
- To remove marker, delete JSON directly or drag it out of map.
How to show hidden nodes & routes before unlocked in game?
Enabling the data digging flag will do, execute this code in console:
KC3StrategyTabs.mapmarkers.definition.digEventSpots = true
NOTE: Will try to fetch JSON data from official server until 404 is responded.


Hierarch Kekropus:
The "Forgoten History" was never revealed to the other races. Even now, the only ones who know its details are myself and a few of our Elders
and the three great heroes of the Kamael. The world believes that we were sealed on the island because of the threat posed by our combat skills.
they do not know the truth...
Continue listening.


Arrays vs. Hashes
Exploring the different types of lists in Ruby
3/14/15
In learning the fundamentals of coding (and Ruby in particular), I have found that the basic structure boils down to taking “objects” and manipulating them with various types of “methods.” It has also become apparent that some objects are extremely versatile and useful in their ability to store more than one piece of information. Namely, “Arrays” and “Hashes” are incredibly important and advantageous objects thanks to their list-like structure. But in order to get optimal use out of the two it is first important to fully understand the differences between them.
You can think of both arrays and hashes as lists of stored information, and these lists can contain any combination of types of objects (such as integers and/or strings… or even lists of lists!) and can be as long as you’d like.
There are a number of ways to define an array, but below is one example of a common form:
Each slot in an array has a corresponding number index that can be used to reference a given object. Note though that the first entry is in the “0th” index, so in the above example we would call favorite_cookie[0] to see that it is oatmeal chocolate chip. To check what ranks as first runner up for my favorite cookie, we’d call favorite_cookie[1] to see that it returns chocolate chip. Second runner up, or, favorite_cookie[2] returns Oreo, and so on (this list is clearly not complete, but remember arrays do have the freedom to be however long you’d like).
Somewhat similarly to an array, a hash can hold a list of values with corresponding reference keys, but these keys have to be provided by the user, and there is no particular order to the pairs of keys and their values. If we think back to my sweet tooth we saw that I could create an ordered list that ranked my favorite type of cookie. I could probably do the same for my favorite flavor of ice cream, or my favorite kind of pie, etc. But if you were to ask me what my favorite dessert of all was, I would not be able to come up with an answer. Each type of dessert is so good in it’s own way, that there’s just no way to compare them. So I would have to instead present my favorite desserts in a manner that did not force any kind of rank or order on them. For example:
favorite_dessert = { “Cookie” => “Oatmeal Chocolate Chip”,
“Ice cream” => “Coffee”,
“Pie” => “Chocolate Pecan”,
“Cake” => “Almond”}
This hash provides a list of my favorite types of dessert, but it is by no means a representation of which type of dessert is preferred over another. In a hash the order doesn’t make any difference. Notice you need to provide a reference key for each value, because there isn’t a default index number associated with the entries. In fact you will have an error if you do not include a label for each value you give.
So hashes provide an ideal way to store information when you want to pair a certain value with a reference key and do not care about (or perhaps do not want) a specific order to the items in the list. An array, on the other hand, is a great way to maintain order and allows you to easily look up a given value by the index number. Both arrays and hashes have their benefits depending on the task at hand, so it’s great to understand their subtle nuances to make the most out of your Ruby code!


Malaysia's Independence Day will be celebrated on 31 August 2021. Also known as Merdeka Day (Freedom Day), this is Malaysia's National Day...
Malaysia's Independence Day will be celebrated on 31 August 2021. Also known as Merdeka Day (Freedom Day), this is Malaysia's National Day...
School holidays are coming soon! Make sure you spend the holidays effectively by doing productive activities such as taking up a new hobby. Of course! The most important thing is to take care of yourselves.
Oh my, SPM is getting near. SMK Cyberjaya wishes all SPM 2021 candidates the best of luck for the upcoming examination. Make our school proud!


The need for near-silence in a submarine leads to strict procedures. As a submarine captain explained, “One of our drills, in case we are under conditions of extreme radio silence inside the submarine, is to exchange information among our five key departments. Naturally, we can’t tell you which those are.
“Each department consists of five sailors. Our basic protocol works as follows: As captain, I request certain information by broadcasting the request to all departments; each department responds with a number that is sent only to the captain (no broadcast); then the captain may broadcast a number; and so on. Remember, the captain broadcasts; the others don’t.
“To demonstrate, the departments will exchange very few messages with me - as few as possible - in order for me to determine some information. Naturally, we can’t reveal to you the nature of such information, but my first officer has come up with a sanitized version.”
Suppose the captain broadcasts the request for the arithmetic mean of the blood pressures of all sailors in those departments. (“Blood pressure,” technically, systolic blood pressure, is the sanitization of a three digit quantity of interest.) Can the departments respond in such a way that the captain can then compute the mean?
Each department calculates the mean of its sailors’ blood pressures and reports that number. The captain computes the sum of these means and divides by five. This works because each department has the same number of sailors (otherwise the captain would have had to weight each reported mean by the number of sailors in that department).
Okay, that was pretty easy. It turns out they weren’t so interested in the mean as in the median. (The mean is too sensitive to outliers.) But the median itself wasn’t necessary, simply a “blood pressure” among the 10 middle values of the 25.
Assuming blood pressures are three digits long, can each department report one three digit number so that the captain can infer a blood pressure among the 10 middle blood pressures of the 25 sailors?
The captain wants to find some blood pressure value that is sure to be less than or equal to the median and some blood pressure value that is sure to be greater than or equal to the median. Using the assumptions of the first question, can the captain infer such a value after one three-digit report from each department?


Convocation BUET 2019
A Short Historical Review of Kepler Conjecture
2nd Int. Conference on Physics for Sustainable Development and Technology (ICPSDT), 2017. Chittagong, Bangladesh.
From right: Me, My Mentor (Prof. Hakim), My Mentor's Mentor (Prof. Per nordblad)
Beautiful Patenga Beach, Chittagong, Bangladesh
Beautiful Patenga Beach, Chittagong, Bangladesh
Random click during our presentation which won the best paper award in that session.
Photonic Crystals: Molding the Flow of Light
Nanoscale Functional Ceramics: Into the World of Photocatalyst
B.Sc. Thesis: Hydrothermal Synthesis & Characterization of Pure and Doped BiVO4 Nanoparticles


Creates a new temporary directory with a random name.
New-TempDirectory [[-Prefix] <String>] [-WhatIf] [-Confirm] [<CommonParameters>]
A new temporary directory is created in the current user's env:TEMP
directory. The directory's name is created using the Path
class's GetRandomFileName method.
To add a custom prefix to the directory name, use the Prefix
parameter. If you pass in a path, only its name will be used. In this way, you can pass $MyInvocation.MyCommand.Definition
(PowerShell 2) or $PSCommandPath
(PowerShell 3+), which will help you identify what scripts are leaving cruft around in the temp directory.
Added -WhatIf
support in Carbon 2.0.
| Name | Type | Description | Required? | Pipeline Input | Default Value |
|---|---|---|---|---|---|
| Prefix | String | A prefix to use, so you can more easily identify what created the temporary directory. If you pass in a path, it will be converted to a file name. |
false | false | |
| WhatIf | SwitchParameter | false | false | ||
| Confirm | SwitchParameter | false | false | ||
| CommonParameters | This cmdlet supports common parameters. For more information type Get-Help about_CommonParameters . |
New-TempDirectory
Demonstrates how to create a new temporary directory, e.g. C:\Users\ajensen\AppData\Local\Temp\5pobd3tu.5rn
.
New-TempDirectory -Prefix 'Carbon'
Demonstrates how to create a new temporary directory with a custom prefix for its name, e.g. C:\Users\ajensen\AppData\Local\Temp\Carbon5pobd3tu.5rn
.
New-TempDirectory -Prefix $MyInvocation.MyCommand.Definition
Demonstrates how you can use $MyInvocation.MyCommand.Definition
in PowerShell 2 to create a new, temporary directory, named after the currently executing scripts, e.g. C:\Users\ajensen\AppData\Local\Temp\New-TempDirectory.ps15pobd3tu.5rn
.
New-TempDirectory -Prefix $PSCommandPath
Demonstrates how you can use $PSCommandPath
in PowerShell 3+ to create a new, temporary directory, named after the currently executing scripts, e.g. C:\Users\ajensen\AppData\Local\Temp\New-TempDirectory.ps15pobd3tu.5rn
.


所有类
ApiKey
Assertions
Binary
BuildConfig
Command
Command.CommandType
DataPoint
DataStream
Device
HttpExecutor
Meta
Mqtt
OneNetApi
OneNetApiCallback
OneNetLogger
R
Trigger
Urls


Teach 3: Team Activity
Name:
E-mail:
Major:
Computer Science
Software Engineering
Web Design and Development
Computer Information Technology
Computer Engineering
Places Visited:
North America
South America
Europe
Asia
Australia
Africa
Antarctica
Comments:


"I'm sorry I wrote you such a long PR. I didn't have time to write you a short one."
2/3/2022, 8:07:55 AM
Favs: 10
Retweets: 0
link--- layout: tweet ---
"I'm sorry I wrote you such a long PR. I didn't have time to write you a short one."
2/3/2022, 8:07:55 AM
Favs: 10
Retweets: 0
link


---
layout: post
title: The Neovintage Collection (new mix)
date: '2006-10-16T21:09:00.000-07:00'
author: Rimas Silkaitis
tags:
- music
modified_time: '2007-04-03T12:07:17.499-07:00'
blogger_id: tag:blogger.com,1999:blog-6201986.post-1672931761190539007
blogger_orig_url: http://neovintage.blogspot.com/2006/10/neovintage-collection-new-mix.html
---
Its been quite a while since I've made a mix. Its been even longer since I got new music. Regardless I spend some time today to pick some new tunes out for an hour of listening enjoyment.
Please note that its been a while since I last made a mix and my "skillz" weren't ninja-like in the past, so some of the parts are a little choppy, not to mention my levels were off.
Tracklist:
- Aspect - Soul Lady (blu saphir)
- Paul B & Yana Kay - Waiting for your Love (Euphoria)
- Logistics - Call Me Back (Now More Than Ever EP - Hospital)
- Calibre - Derranged (Derranged EP - Soul:R)
- Sonic - Saigon Traffic (Bingo)
- Seba - Heaven Sent feat Robert Manos (Soul:R)
- Kubicks and Lomax - Edge City (Liquid V)
- Logistics - City Life (Now More Than Ever EP - Hospital)
- Mathematics and Tactile - Espirit (Social Studies)
- Synopix - Veteran (Fokuz)
- Total Science - Soul Patrol (Sunny Side Up Mix) (CIA)
- Locuss - Foundation (Cymbalism Liquified)
- Junior Cartel - Havana (Renegade Recordings)
Download:
The link is coming soon.... I'm probably going to redo the mix tomorrow cause I'm not really content with it in its current form.
Go and get it at sendspace!
Enjoy!


${imports}
${headfinal}
ESRL
|
Physical Sciences Division
Toggle navigation
About
About PSD
Organization At-A-Glance
Science Reviews
Visiting NOAA Boulder
People
Contacts
Staff List
Employee Spotlight
Research
Overview
Teams
Publications
Observations
Data
All
Gridded Climate
Profiler Network Data & Image Library
Cruise Data
Satellite
Boulder Climate & Weather
Analysis & Plotting Tools
Help
Products
All
Experimental
Map Room
Analysis & Plotting Tools
GEFS Reforecast V2
Subseasonal Tropical Forecasts
Climate Change Web Portal
News | Events
News
Events
Seminars
Learn
Research Handouts
Education Resources
FACTS - Facility for Climate Assessments
${links}
${header}
${content}


Notebooks
Story: Feathered arrows and poison
Feathered arrows and poison
Title
Feathered arrows and poison
Collection
Summary
Arrow making, and Arrow poisoning. By /han≠kass’o (L VIII.-26. 8293-8302, 8315-8334). Two kinds of Arrow. (L VIII.-10. 6923 rev. and 6924 rev., note). Arrow heads, etc. (L VIII.-1. 6086 and 6087). Description of the spur, or barblet, sometimes added to the Arrow shaft by Bushmen. (L VIII.-31. 8770-8773, and 8767 rev., note). The adhesive substance used by Bushmen in making Arrows. Preparation thereof. (L VIII.-1. 6088-6091). The marking of Arrows. (L VIII.-26. 8289-8392). Arrow Bags. (L VIII. 30. 8663 rev., note). The names and uses of poisons and the feathering of arrows.
Comments
1) See also The ||kuken, 2) This story is found in Book VIII-10
Contributors
|han≠kass'o (Klein Jantje) (VIII)
Date
May 1878
Categories
Custom and daily life, Artefact and dress
Keywords
arrow (feathered, and poison) , arrow (the use of an) , arrow (poisoned) , arrow (the name of an) , arrow (used for hunting springbok) , poison (feathered arrows and) , poison (the name of) , poison (a description of) , poison (people-) , hunting (springbok and the use of feathered and poisoned arrows) , springbok (hunting with feathered and poisoned arrows) , feather (feathered arrows and poison) , names (of poisons used on arrows) , names (of arrows)
Story Pages
6923v-6924v


| Rng | |
|---|---|
| CHACHA12 | gen_payloads/Rng/CHACHA12 |
| CHACHA8 | gen_payloads/Rng/CHACHA8 |
| CORE | gen_payloads/Rng/CORE |
| HC128 | gen_payloads/Rng/HC128 |
| HYPERTHREAD | gen_payloads/Rng/HYPERTHREAD |
| PCG64FAST | gen_payloads/Rng/PCG64FAST |
| SFMT | gen_payloads/Rng/SFMT |
| WYRNG | gen_payloads/Rng/WYRNG |
| XORSHIFT | gen_payloads/Rng/XORSHIFT |
| XOSHIRO256PLUSPLUS | gen_payloads/Rng/XOSHIRO256PLUSPLUS |
| XOSHIRO256STARSTAR | gen_payloads/Rng/XOSHIRO256STARSTAR |


To allow extended scaling of meetings that expect significant portions of attendees be non-active participants (e.g. a live event or presentation), the Amazon Chime SDK supports the creation of Replica meetings with specialized behavior. For explanation of how to create Replica meetings via the CreateMeeting and CreateMeetingWithAttendees APIs, a high level overview of how Replica meetings work, and a walkthrough of how to incorporate this type of scaling in your applications meetings, see the section above.
In short, an attendee in a Replica meeting will receive remote media and metadata from the Primary meeting as if they were attendees of the Primary meeting (though they will not require authentication for the Primary meeting unless they would like to be promoted to an active participant, which is covered in a separate section below).
This document will cover specifics of the behavior and features available to Replica meeting attendees with relation to the Amazon Chime SDK for Javascript. It assumes that:
You have an understanding of the core media features of the Amazon Chime SDK for Javascript.
You have an understanding of the high level ideas around Replica meetings as covered in the Chime Developer Guide.
Note: This guide will refer to the meeting which is replicated as a Primary meeting, however there is no difference between a Primary meeting and a normal meeting. There is additionally no difference in the behavior and features of an attendee of a Primary meeting, so builders should not need to use the SDK any differently from the way they would for non-replicated meetings for those Primary meeting attendees.
As mentioned above, an attendee in a Replica meeting will receive remote media and metadata as if they were attendees of the Primary meeting. They will not require authentication for the Primary meeting unless they would like to be promoted to a fully-interactive participant; see section below. For extended clarity, we can further break down this behavior by section. Details on send limitations are explained in the following section.
Replica meeting attendees should subscribe to real time events as they would in a normal meeting. This is covered in the API Overview. Post-subscription, the Replica attendee can expect following behavior:
Attendee presence events (via realtimeSubscribeToAttendeeIdPresence) will be received for the Primary meeting attendees. The callback will contain both the attendee ID and external user ID from CreateAttendee for the aforementioned Primary meeting attendee. There will be no callback for attendees of the same Replica meeting that was joined, or any other Replica meeting.
A Replica attendee will receive audio played out to their chosen audio device from the Primary meeting (see this section in the API Overview for information on setting up an audio output device). This will not include any audio from any Replica meeting attendees.
Similarly, remote video availability notified via remoteVideoSourcesDidChange and/or videoTileDidUpdate will all correspond to Primary meeting attendees (i.e. they will contain the Attendee ID and External ID from a CreateAttendee call for the Primary meeting). Builders should handle and respond to those callbacks and videoTileWasRemoved in the same fashion as normal meetings.
A replica meeting attendee which has subscribed to meeting data messages via realtimeSubscribeToReceiveDataMessage will receive data messages (i.e. those sent via realtimeSendDataMessage) from Primary meeting attendees. They will not receive any from other Replica meeting attendees.
If live transcription is enabled for the Primary meeting, Replica meeting attendees will receive Transcription Events just as they would any Primary meeting data message. See the Developer Guide for more information on how to handle Transcription Events.
The client events and ingestion covered in Meeting Events and Event Ingestion (note, these are different the events such as provided by realtimeSubscribeToAttendeeIdPresence) will continue to work as before for Replica meeting attendees, all events have the meetingId attribute set to the Replica meeting ID.
As covered in the previous section, Replica meeting attendees will not receive media, data messages, or attendee events for any other Replica meeting attendee, regardless of whether they are in the same replica meeting. Additionally, Primary meeting attendees will not receive media, data messages, or attendee events for any Replica meeting attendee.
Therefore application builders should be considerate of that fact and avoid displaying UI which may indicate that other participants may be able to receive transmitted media unless there is the ability to promote as covered in section below.
Although application builders should already be aware of when attendees are in a replica meeting, they will additionally be notified of video-related restrictions via videoAvailabilityDidChange and videoSendDidBecomeUnavailable. In particular:
videoAvailabilityDidChange will always return a MeetingSessionVideoAvailability object with canStartLocalVideo set to false.
Any attempts to enable video as a Replica meeting attendee will result in videoSendDidBecomeUnavailable. As mentioned before, builders should avoid code which tries to enable video for attendees in Replica meetings.
Since transmitted media from non-promoted Replica meeting attendee will not be visible to any other participants, it is recommended to avoid querying for device permissions that are not necessary. Refer to this section in the API Overview for instructions on how to optimally set up a view-only/spectator experience.
Applications may want to allow Replica attendees to authenticate against and participate in the Primary meeting by sharing audio, video and data messages without needing to incur the latency of leaving the Replica meeting and joining the Primary meeting. This may, for example, be used for Town Hall-style events where normal participants may be given the opportunity to ask their question to participants in the Primary meeting. The Amazon Chime SDK for Javascript provides a set of APIs for low latency promotions of Replica attendees: promoteToPrimaryMeeting and demoteFromPrimaryMeeting.
Primary meeting credentials for Replica attendees which desire promotion need to be retrieved in the same way as a normal Primary meeting attendee via CreateAttendee Chime APIs. See Getting responses from your server application for more information. Once the Primary meeting credentials have been retrieved, they can be provided to an AudioVideoFacade which is already connected to a Replica meeting:
// We assume `replicaMeetingSession` is created using configuration created// with Replica meeting credentials.constreplicaMeetingSession = newDefaultMeetingSession(configuration,logger,deviceController);// Can then use `replicaMeetingSession` as non-participating session.// When promotion is desired...// Response from Primary's CreateMeeting API callconstmeetingResponse = getPrimaryMeeting();//Response from CreateAttendee API call against PrimaryconstattendeeResponse = createPrimaryMeetingAttendee();constconfiguration = newMeetingSessionConfiguration(meetingResponse,attendeeResponse);// This could also be created solely through the `CreateAttendee` responseconstcredentials = configuration.credentials;conststatus = meetingSession.audioVideo.promoteToPrimaryMeeting(credentials);
status is a MeetingSessionStatus object. See promoteToPrimaryMeeting documentation for possible return codes. If status.code is MeetingSessionStatusCode.OK, the connection has successfully authenticated as a Primary meeting attendee and the attendee experience should now be as if you had joined the Primary meeting directly. This means:
Audio captured and transmitted will now be shared with the Primary meeting and all Replica meetings. If you hadn't set up the audio input device, you can refer to this section of the API Overview for instructions. Attendee presence, volume, and signal strength callbacks for the promoted attendee on all Primary and Replica meeting attendees will be labeled with the attendee associated with the credentials provided to addPrimaryMeetingCredentials.
If there is video source capacity in the Primary meeting, videoAvailabilityDidChange should eventually be called
with canStartLocalVideo set to true. startVideoInput can then be used as normally to enable
video in the conference. Further information on configuring video input can be found in the API Overview. In the same way as audio, this video will be associated with the Primary meeting attendee.
Data messages sent via realtimeSendDataMessage will be forwarded to all Primary and Replica meeting attendees. They will also be associated with the Primary meeting attendee.
Builders should be considerate of these changes by showing UI related to video enable/disable, audio mute/unmute, etc. on promoted attendees.
A promoted attendee can be considered as authenticated in two meetings, as two attendees, at the same time. However with regards to their connection to the Amazon Chime SDK servers, their 'root' connection is as a Replica attendee, and thus there are three ways for the attendee to 'revert' to a view-only, Replica meeting attendee with behavior explained in earlier sections. (i.e. demotion will lead to audio, video, and data messages ceasing to be forwarded from the client). All demotions will result in a call to AudioVideoObserver.audioVideoWasDemotedFromPrimaryMeeting with a corresponding status code.
The demotion can be forced by call to DeleteAttendee on the Chime API.
Any disconnection will trigger an automatic demotion to avoid unexpected or unwanted promotion state on reconnection. If the attendee still needs to be an interactive participant in the Primary meeting, promoteToPrimaryMeeting should be called again with the same credentials.
Replica Meetings Attendee Behaviors and Features
To allow extended scaling of meetings that expect significant portions of attendees be non-active participants (e.g. a live event or presentation), the Amazon Chime SDK supports the creation of Replica meetings with specialized behavior. For explanation of how to create Replica meetings via the CreateMeeting and CreateMeetingWithAttendees APIs, a high level overview of how Replica meetings work, and a walkthrough of how to incorporate this type of scaling in your applications meetings, see the section above.
In short, an attendee in a Replica meeting will receive remote media and metadata from the Primary meeting as if they were attendees of the Primary meeting (though they will not require authentication for the Primary meeting unless they would like to be promoted to an active participant, which is covered in a separate section below).
This document will cover specifics of the behavior and features available to Replica meeting attendees with relation to the Amazon Chime SDK for Javascript. It assumes that:
Note: This guide will refer to the meeting which is replicated as a Primary meeting, however there is no difference between a Primary meeting and a normal meeting. There is additionally no difference in the behavior and features of an attendee of a Primary meeting, so builders should not need to use the SDK any differently from the way they would for non-replicated meetings for those Primary meeting attendees.
Replica meeting receive behavior
As mentioned above, an attendee in a Replica meeting will receive remote media and metadata as if they were attendees of the Primary meeting. They will not require authentication for the Primary meeting unless they would like to be promoted to a fully-interactive participant; see section below. For extended clarity, we can further break down this behavior by section. Details on send limitations are explained in the following section.
Remote attendee events
Replica meeting attendees should subscribe to real time events as they would in a normal meeting. This is covered in the API Overview. Post-subscription, the Replica attendee can expect following behavior:
realtimeSubscribeToAttendeeIdPresence
) will be received for the Primary meeting attendees. The callback will contain both the attendee ID and external user ID fromCreateAttendee
for the aforementioned Primary meeting attendee. There will be no callback for attendees of the same Replica meeting that was joined, or any other Replica meeting.realtimeSubscribeToVolumeIndicator
,realtimeSubscribeToLocalSignalStrengthChange
, andsubscribeToActiveSpeakerDetector
) will correspond to Primary meeting attendees. There will be no callback for attendees of the same Replica meeting that was joined, or any other Replica meeting.Remote audio and video
A Replica attendee will receive audio played out to their chosen audio device from the Primary meeting (see this section in the API Overview for information on setting up an audio output device). This will not include any audio from any Replica meeting attendees.
Similarly, remote video availability notified via
remoteVideoSourcesDidChange
and/orvideoTileDidUpdate
will all correspond to Primary meeting attendees (i.e. they will contain the Attendee ID and External ID from aCreateAttendee
call for the Primary meeting). Builders should handle and respond to those callbacks andvideoTileWasRemoved
in the same fashion as normal meetings.All information related to receipt and display of video in User guide for Priority-based downlink policy and Managing Video Quality for Different Video Layouts continue to apply to Replica meeting attendees.
Remote data messages
A replica meeting attendee which has subscribed to meeting data messages via
realtimeSubscribeToReceiveDataMessage
will receive data messages (i.e. those sent viarealtimeSendDataMessage
) from Primary meeting attendees. They will not receive any from other Replica meeting attendees.If live transcription is enabled for the Primary meeting, Replica meeting attendees will receive Transcription Events just as they would any Primary meeting data message. See the Developer Guide for more information on how to handle Transcription Events.
Meeting events and ingestion
The client events and ingestion covered in Meeting Events and Event Ingestion (note, these are different the events such as provided by
realtimeSubscribeToAttendeeIdPresence
) will continue to work as before for Replica meeting attendees, all events have the meetingId attribute set to the Replica meeting ID.Replica meeting attendee limitations and messaging
As covered in the previous section, Replica meeting attendees will not receive media, data messages, or attendee events for any other Replica meeting attendee, regardless of whether they are in the same replica meeting. Additionally, Primary meeting attendees will not receive media, data messages, or attendee events for any Replica meeting attendee.
Therefore application builders should be considerate of that fact and avoid displaying UI which may indicate that other participants may be able to receive transmitted media unless there is the ability to promote as covered in section below.
Video send availability notification
Although application builders should already be aware of when attendees are in a replica meeting, they will additionally be notified of video-related restrictions via
videoAvailabilityDidChange
andvideoSendDidBecomeUnavailable
. In particular:videoAvailabilityDidChange
will always return a MeetingSessionVideoAvailability object with canStartLocalVideo set to false.videoSendDidBecomeUnavailable
. As mentioned before, builders should avoid code which tries to enable video for attendees in Replica meetings.Avoiding unnecessary device permission requests for Replica attendees
Since transmitted media from non-promoted Replica meeting attendee will not be visible to any other participants, it is recommended to avoid querying for device permissions that are not necessary. Refer to this section in the API Overview for instructions on how to optimally set up a view-only/spectator experience.
Low latency promotion of Replica meeting attendees into the Primary meeting
Applications may want to allow Replica attendees to authenticate against and participate in the Primary meeting by sharing audio, video and data messages without needing to incur the latency of leaving the Replica meeting and joining the Primary meeting. This may, for example, be used for Town Hall-style events where normal participants may be given the opportunity to ask their question to participants in the Primary meeting. The Amazon Chime SDK for Javascript provides a set of APIs for low latency promotions of Replica attendees:
promoteToPrimaryMeeting
anddemoteFromPrimaryMeeting
.Promotion of Replica attendees
Primary meeting credentials for Replica attendees which desire promotion need to be retrieved in the same way as a normal Primary meeting attendee via
CreateAttendee
Chime APIs. See Getting responses from your server application for more information. Once the Primary meeting credentials have been retrieved, they can be provided to anAudioVideoFacade
which is already connected to a Replica meeting:status is a
MeetingSessionStatus
object. SeepromoteToPrimaryMeeting
documentation for possible return codes. If status.code isMeetingSessionStatusCode.OK
, the connection has successfully authenticated as a Primary meeting attendee and the attendee experience should now be as if you had joined the Primary meeting directly. This means:videoAvailabilityDidChange
should eventually be called withcanStartLocalVideo
set to true.startVideoInput
can then be used as normally to enable video in the conference. Further information on configuring video input can be found in the API Overview. In the same way as audio, this video will be associated with the Primary meeting attendee.realtimeSendDataMessage
will be forwarded to all Primary and Replica meeting attendees. They will also be associated with the Primary meeting attendee.Builders should be considerate of these changes by showing UI related to video enable/disable, audio mute/unmute, etc. on promoted attendees.
Demotion of promoted Replica attendees
A promoted attendee can be considered as authenticated in two meetings, as two attendees, at the same time. However with regards to their connection to the Amazon Chime SDK servers, their 'root' connection is as a Replica attendee, and thus there are three ways for the attendee to 'revert' to a view-only, Replica meeting attendee with behavior explained in earlier sections. (i.e. demotion will lead to audio, video, and data messages ceasing to be forwarded from the client). All demotions will result in a call to
AudioVideoObserver.audioVideoWasDemotedFromPrimaryMeeting
with a corresponding status code.demoteFromPrimaryMeeting
.DeleteAttendee
on the Chime API.promoteToPrimaryMeeting
should be called again with the same credentials.Give feedback on this guide


public class Controller
extends java.lang.Object
| Constructor and Description |
|---|
Controller()
Constructor
Sets up and starts the game
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
allPawnsPlaced()
Checks if all the pawns have been placed
|
void |
applySettings()
Applies the users settings
|
void |
disconnect()
Sends a disconnect message to the server
|
boolean |
gameExists()
Checks if a game has been saved
|
Position |
getPawnPosition(Pawn pawn)
Returns the position of the pawn
|
boolean |
inOverState()
Checks to see if the game is in the setup state.
|
boolean |
inSetupState()
Checks to see if the game is in the setup state.
|
boolean |
isInPlayerArea(Position position)
Checks if a position is in the players setup area.
|
boolean |
isOnlineGame()
Checks if the game is an online game
|
void |
loadFromUserSetup(java.lang.String userSetupName)
Loads a saved user setup into the game
|
void |
loadGame(Game game)
Loads a game and starts it.
|
static void |
main(java.lang.String[] args)
Starts the application
|
void |
movePawn(Pawn pawn,
Position positionFrom,
Position positionTo)
Moves the pawn
|
void |
newMessage(java.lang.String message)
Messages from server end up here for sorting and distribution
|
void |
placePawn(Pawn pawn,
Pawn pawnPosition)
Places the pawn on the board
|
boolean |
positionContainsEmptyPawn(Position selectedPosition)
Checks if a position contains a Empty pawn.
|
void |
reDrawMatrix()
Redraws the matrix
|
void |
removePawn(Pawn pawn)
Removes the pawn from the game board
|
void |
removeSidePanel()
Removes the side panel from the BoardUI
|
void |
saveExistingGame()
Saves the current game, overwriting the existing save with the same name.
|
void |
saveGame(java.lang.String gameName)
Saves the current game
|
void |
saveUserSetup(java.lang.String userSetupName)
Saves a user setup
|
SelectValue |
select(Pawn pawn,
Position position)
Selects the pawn at the position
|
void |
sendObject(java.lang.String clientObject)
Sends a message to the server
|
void |
sendToMatrix(Pawn[][] pawns)
Sends the game board to the matrix
|
void |
sendToSidePanel(Pawn[][] pawns,
int[][] counters)
Sends the pawns and the available number of each pawn to the side panel.
|
void |
setupDone()
Called when the user is done with their setup
|
void |
showEndAnimation()
shows animation if player wins
|
void |
showGameRequest(java.lang.String opponent)
Shows a game request in the LobbyUI
|
void |
showPawnMovement(Pawn pawn,
Position from,
Position to,
Pawn[][] boardGrid)
Animates the pawn movement
|
void |
startClient(java.lang.String userName)
Starts the client socket and attempts to connect to the server
|
void |
startGame()
Starts a new hotseat game
|
void |
startOnlineGame(Pawn.Color localColor,
java.lang.String user,
java.lang.String opponent)
Starts a new online game
|
void |
updateGameStatus(java.lang.String gameStatus)
Sends the games status to the BoardUI
|
void |
userList(java.lang.String list)
Sends a list of connected players to LobbyUI
|
public void newMessage(java.lang.String message)
message
- The message from the serverpublic void startOnlineGame(Pawn.Color localColor, java.lang.String user, java.lang.String opponent)
localColor
- The color of the local playeruser
- The username of the playeropponent
- The username of the opponentpublic void startClient(java.lang.String userName)
userName
- The username to usepublic void disconnect()
public void sendObject(java.lang.String clientObject)
clientObject
- The messagepublic void saveGame(java.lang.String gameName)
gameName
- The name to save it aspublic void saveExistingGame()
public void loadGame(Game game)
game
- The gamepublic void startGame()
public void sendToMatrix(Pawn[][] pawns)
pawns
- The game boardpublic void reDrawMatrix()
public void sendToSidePanel(Pawn[][] pawns, int[][] counters)
pawns
- A 2d array of pawnscounters
- A 2d array of int's. This is the number the user has of each
pawn.public SelectValue select(Pawn pawn, Position position)
pawn
- The pawnposition
- The pawns positionSelectValue
public void movePawn(Pawn pawn, Position positionFrom, Position positionTo)
pawn
- The pawnpositionFrom
- The start positionpositionTo
- The end positionpublic boolean inSetupState()
public boolean inOverState()
public boolean isOnlineGame()
public void updateGameStatus(java.lang.String gameStatus)
gameStatus
- The status stringpublic boolean gameExists()
public void applySettings()
public void placePawn(Pawn pawn, Pawn pawnPosition)
pawn
- The pawn to placepawnPosition
- The pawn in the positionpublic void setupDone()
public void removeSidePanel()
public void removePawn(Pawn pawn)
pawn
- The pawnpublic boolean isInPlayerArea(Position position)
position
- The positionpublic Position getPawnPosition(Pawn pawn)
pawn
- The pawnPosition
The pawns positionpublic boolean positionContainsEmptyPawn(Position selectedPosition)
selectedPosition
- The position to checkpublic boolean allPawnsPlaced()
public void saveUserSetup(java.lang.String userSetupName)
userSetupName
- The name to usepublic void loadFromUserSetup(java.lang.String userSetupName)
userSetupName
- The name of the setuppublic void userList(java.lang.String list)
list
- The list of connected playerspublic void showGameRequest(java.lang.String opponent)
opponent
- The opponent that sent the requestpublic void showPawnMovement(Pawn pawn, Position from, Position to, Pawn[][] boardGrid)
pawn
- The pawnfrom
- The position to move fromto
- The position to move toboardGrid
- The games board gridpublic void showEndAnimation()
public static void main(java.lang.String[] args)


Additional information is needed before your project can begin. This table will help you to keep track of what tasks have been completed and what is outstanding.
| Partner | Project details | Monitoring Officer | Bank details | Finance checks | Spend profile | Other docs | Grant offer letter |
|---|---|---|---|---|---|---|---|


Index of /flat-admin/assets/js/libs/jquery-validation/dist
Parent Directory
additional-methods.js
additional-methods.min.js
jquery.validate.js
jquery.validate.min.js
localization/


Flash and JavaScript are required for this feature.
Download the video from iTunes U or the Internet Archive.
Description: We consider how object recognition has evolved over the past 30 years. In alignment theory, 2-D projections are used to determine whether an additional picture is of the same object. To recognize faces, we use intermediate-sized features and correlation.
Instructor: Patrick H. Winston
Lecture 9: Constraints: Vis...
Related Resources
Prof. Winston wrote about the Rumpelstiltskin principle, which was briefly mentioned in this lecture, in the Slice of MIT blog.

Back when you were little it was a lot more fun.
You could make fun of politicians.
Here's a politician some of you may recognize.
But it's convenient to be able to vary what this particular politician looks like.
For example, we can go from a cookie baker to radical.
[LAUGHTER] PATRICK WINSTON: We can go from superwoman to bimbo.
[LAUGHTER] PATRICK WINSTON: Socialite-- I put socialite into this.
There she is.
Or we can move the slider over the other way to bag lady.
Alert, asleep, sad, happy.
How does that work?
I don't know.
But I bet by the end of this hour you'll know how that works.
And not only that, you'll understand something about what it takes to recognize faces.
It turns out to some theories of face recognition are based on the same principles that this program is based on.
But you can kind of guess what's happening here.
There are many stored images and when I move those sliders it's interpolating amongst them.
So that's how that works.
But the main subject of today is this matter of recognizing objects.
Faces could be the objects, but they don't have to be.
This could be an object that you might want to recognize.
And I want to talk to you a little bit about the history of this problem and where it stands today.
It's still not solved.
But it's an interesting exercise to see how the attempts at solution have evolved slowly over the past 30 years.
So slowly, in fact, that I think if someone told me how long it would take to get to where we are 30 years ago I think I would have hung myself.
But things do move slowly.
And it's important to see how slowly they move.
Because they will continue to move slowly in the future.
And you have to understand that that's the way things work sometimes.
So to start this all off, we have to go back to the ideas of the legendary David Marr, who dropped dead from leukemia in about 1980.
I say, the gospel according to Marr, because he was such a powerful and central figure that almost anything he said was believed by a large collection of devotees.
But Marr articulated a set of ideas about how computer vision would work that started off by suggesting that with the input from the camera, you look for edges.
And you find edge fragments.
And normally they wouldn't be even as well-drawn as I've done them now.
Or as badly drawn as I've done them now.
But the first step, then, in visual recognition would be to form this edge-based description of what's out there in the world.
And Marr called that the primal sketch.
And from the primal sketch, the next step was to decorate the primal sketch with some vectors, some surface normals, showing where the faces on the object were oriented.
He called that the two and a half D sketch.
Now why is it two and a half D?
Well, it's sort of 2D in the sense that it's still camera-centric in its way of presenting information.
But at same time, it attempts to say something about the three-dimensional arrangement of the faces.
So the speculation was that you couldn't get to where you wanted to go in one step.
So you needed several steps to get from the image to something you could recognize.
And the third step was to convert the two and a half D sketch into generalized cylinders.
And the idea is this.
If you have a regular cylinder, you can think of it as a circular area moving along an axis like so.
So that's the description of a cylinder.
A circular area moving along an axis.
You can get a different kind of cylinder if you go along the same axis but you allow the size of the circle to change as you go.
So for example, if you were to describe a wine bottle.
It would be a function of distance along the axis that would shrink the circle appropriately to match the dimensions of a wine bottle.
A fine burgundy, I perceive.
In any case, this one once converted into a generalized cylinder, when matched against a library of such descriptions, results in recognition.
Great theory, based on the idea that you start off by looking at edges and you end up, in several steps of transformation, producing something that you could look up in a library of descriptions.
Great idea.
Trouble is, no one could make it work.
It was too hard to do this.
It was too hard to do that.
And the generalized cylinders produced, if any, were too coarse.
You couldn't tell the difference between a Ford and a Chevrolet or between a Volkswagen and a Cadillac.
Because they were just too coarse.
So although it was a great idea based on the idea that you have to do recognition in several transformations of representational apparatus, it just didn't work.
So much later, maybe 15 years later or so, we get to the next part of our story.
Which is the alignment theories, most notably the one produced by Shimon Ullman, one of Marr's students.
So the alignment theory of recognition is based on a very strange and exotic idea.
It doesn't seem strange and exotic to mechanical engineers for a while, because they're used to mechanical drawings.
But here's the strange and miraculous idea.
Imagine this object.
You take three pictures of it.
You can reconstruct any view of that object.
Now, I have to be a little bit careful about how I say that.
First of all, some of the vertexes are not visible in the views that you have.
So, of course, you can't do anything with those.
So let's say that we have a transparent object where you can see all the vertexes.
If you have three pictures of that, you can reconstruct any view of that object.
Now I have to be a little careful about how I say that, because it's not true.
What's true is, you can produce any view of that in orthographic projection.
So if you're close enough to the object that you get perspective, it doesn't work.
But for the most part, you can neglect perspective after you get about two and a half times as far away as the object is big.
And you can presume that you've got orthographic projection.
So that's a strange and exotic idea.
But how can you make a recognition theory out of that?
So let me show you.
Well, here's one drawing of the object, I need two more.
Let's see.
Let's have this one.
And maybe one that's tilted up a little bit.
It's important that these pictures not be just rotations on one axis.
Because they wouldn't form what you might think of as a kind of basis set.
So there are three pictures.
We'll call them a, b, and c.
And then we want a fourth picture.
Which will look like this.
It doesn't have to be too precise.
And we'll call that the unknown.
And what we really want to know is if the unknown is the same object that these three pictures were made from.
So let me begin with an assertion.
I'll need four colors of chalk to make this assertion.
What I want to do is I want to pick a particular place on the object, like this one.
And maybe the same place on this object over here.
Those are corresponding places, right?
So I can now write an equation that the x-coordinate of that unknown object is equal to, oh, I don't know, alpha x sub a plus beta x sub b plus gamma x sub c plus some constant, tau.
Well, of course, that's obviously true.
Because I'm letting you take those alpha, beta, gamma, and tau and make them anything you want.
So although that's conspicuously obviously true, it's not interesting.
So let me take another point.
And of course, I can write the same equation down for this purple point.
And now that I'm on a roll and having a great deal of fun with this, I can take this point and make a blue equation.
And you know I'm destined to do it, so I've got one more color.
I might as well use it.
Let's just make sure I get something that works here.
That's this one, that's this one.
I hope I've got these correspondences right.
STUDENT: [INAUDIBLE].
PATRICK WINSTON: Have I got one off?
STUDENT: [INAUDIBLE].
PATRICK WINSTON: Which color?
STUDENT: Blue.
[INAUDIBLE].
PATRICK WINSTON: OK.
So this one goes with this one, goes with this one.
Is that one wrong?
STUDENTS: Yeah.
PATRICK WINSTON: Oh, oh, oh.
Of course this one, excuse me, goes down here.
Right?
And then this one is off as well.
I wouldn't get a very good recognition scheme if I can't get those correspondences right.
Which is one of the lessons of today.
OK.
Now I've got them right.
And now that equation is correct.
I think I've got this one right already.
So now I can just write that down.
I'm on a roll, I'm just copying this.

And now the astonishing part is that I can choose alpha, beta, gamma, and tau to be all the same.
That is, there's one set of alpha, beta, gamma, and tau that works for everything, for all four points.
So you look at that puzzled.
And that's OK to be puzzled.
Because I certainly haven't proved it.
I'm asserting it.
But right away, there's something interesting about this and that is that the relationship between the points on the unknown object and the points in this stored library of images are related linearly.
That's true because it's orthographic projection.
Linearly related.
So I can generate the points in some fourth object from the points in three sample objects with linear operations.
Christopher?
STUDENT: Is that the x-coordinate of-- PATRICK WINSTON: It's the x-coordinate.
Christopher asked about the x-coordinates.
Each of these x-coordinates are meant to be color coded.
It gets a little complicated with notation and stuff.
So that's the reason I'm color coding the coordinates.
So the orange x sub u is the x-coordinate of that particular point.
STUDENT: In 3D space?
PATRICK WINSTON: No.
Not in 3D space.
In the image.
STUDENT: So it's a 2D projection of it?
PATRICK WINSTON: It's a 2D projection of it, an orthographic projection.
OK?
So we're looking at drawings.
And those coordinates over there are the two-dimensional coordinates in the drawing.
Just as if it were on your retina.
STUDENT: [INAUDIBLE] vertexes on the 3D projection or can curved surfaces also?
PATRICK WINSTON: So he asked about curved surfaces.
And the answer is that you have to find corresponding points on the object.
So if you have a totally curved surface and you can't identify any corresponding points, you lose.
But if you consider our faces, there are some obvious points, even though our face are not by any means flat like these objects.
We have the tip of our nose and the center of our eyeballs and so on.
So if that's true, what does that mean about recovering alpha, beta, gamma, and tau?
Can we find them?
[INAUDIBLE], what do you think?
How do we go about finding them?

[LAUGHTER] STUDENT: It's four equations and-- PATRICK WINSTON: Splendid.
It's four equations and four unknowns.
Four linear equations and four unknowns.
So obviously, you can solve for alpha, beta, gamma, and tau if you know that these equations are correct.
So how does that help us with recognition?
It helps us with recognition because we can take another point, let me say this square point here and this corresponding square point here and this corresponding square point here, and what can we do with those three points now?
We've got alpha, beta, gamma, and tau, so we can predict where it's going to be in the fourth image.
So we can predict that that square point is going to be right there.
And if it isn't, we're highly suspicious about whether this object is the kind of object we think it is.
So you look at me in disbelief.
You'd like me to demonstrate this, I imagine.
STUDENT: Yeah.
PATRICK WINSTON: OK.
Let me see if I can demonstrate this.
So I'm going to do this in a slightly simplified version.
I'm only going to allow rotation around the vertical axis.
And just so you know I'm not cheating, there's a little slider here that rotates that third object.
Let's see, why are there just two known objects and one unknown?
Well that's because I've restricted the motion to rotation around the vertical axis and some translation.
So now that I've spun that around a little bit, let me pick some corresponding points.
Oops.
What's happened?
Wow.
Let me run that by again.
OK.
So there's one point I've selected from the model objects.
The corresponding point over here on the unknown is right there.

But that's OK.
So let me just pick that one and then that corresponds to this one.
Krishna, would you like to specify a point so people know I'm not cheating.
Pick a point.
Pick a point, Krishna.
STUDENT: Oh, the right?
PATRICK WINSTON: The right?
STUDENT: Yeah.
PATRICK WINSTON: This one?
STUDENT: Yep.
PATRICK WINSTON: Oops.
OK, let's pick it out on the model first.
Now pick it over here.
Boom.
So all the points are where they're supposed to be.
Isn't that cool?
Well, let's suppose that the unknown is something else.
This is a carefully selected object.
Because the points are all the correct positions vertically, but they're not necessarily the correct positions in the other two dimensions.
So let me pick this point, and this point, and this point, and this point.
And Krishna had me pick this point.
So let me pick this point.
So if it thinks that the unknown is one of these obelisk objects, then we would expect to see all of the corresponding points correctly identified.
But boom.
All the points are off.
So it seems to work in this particular example.
I find the alpha and beta using two images.
And I predict the locations of the other points.
And I determine whether those positions are correct.
And if they are correct, then I have a pretty good idea that I have in fact identified the object on the right as either an obelisk or an organ, depending on which of the model choices and the unknown choices I've selected.
So the only thing I have left to do is to demonstrate that what I said about this is true.
So I'm going to actually demonstrate that what I said about this is true using the configuration in this demonstration.
Because it's much too hard for me to remember matrix transformations for generalized rotation in three dimensions.
So here's how it's going to work.
The z-axis is going up that way.
Or, it's going to be pointing toward you.

And what I want to do is I want to find out how the x-coordinate in the image of the points move as I do that rotation.
So here's the x-axis.
This is the coordinate that you can see.
Here is the y-axis.
That's in depth, so you can't tell how far away it is.
And the z-axis-- x, y, z-axis must be pointing out that way toward you.
So now I'm going to consider just a single point on the object and see what happens to it.
So I'm going to say to myself, let's put the object in some kind of standard position.
I don't care what it is.
It can be just random, just spin it around.
Some position, we'll call that the standard position, S. And that means that the x-coordinate of the standard position is x sub s.
And the y-coordinate of the standard position is y sub s.
And now I'm going to rotate the object three times.
Once to form the a picture, once to form the b picture, and once to form the c picture.
And you can make those choices.
Those can be anything, right?
So let's say that the a picture is out here.
So that's the a picture.
The B picture is out here.
And the unknown is up that way.
And so what I want to know depends on these vectors.
We'll call that theta sub a, and this is theta sub b.
And this one is theta sub u.
So I would like to know how x sub a depends on x sub s and y sub s.
And I can never remember how to do that, because I can never remember the transformation equations for rotation.
So I have to figure it out every time.
And this is no exception.
So what I'm going to say is that this vector that goes out to S consists of two pieces.
There's the x part and the y part.
And I know that I can rotate this vector by alpha sub a by rotating this vector and rotating that vector and adding up the results.
So if I rotate this vector by alpha sub a, then the contribution of that to the x-coordinate of a is going to be given by the cosine of theta sub a multiplied by x sub s.
So you can just exaggerate that motion, say, well if I pitch it up that way then the projection down on the x-axis is going to be this length of the vector times the cosine of the angle.
Now there's also going to be a dependence on y sub s.
Let's figure out what that's going to be.
I've got this vector here.
And I'm going to rotate it by theta sub a as well.
If I rotate that by theta sub a and see what the projection is on the x-axis, that's going to be given by the sine of the angle.
But it's going the wrong way, so I have to subtract it off.
So that's how I don't have to remember what the signs are on these equations.
Well, that was good.
And now that I'm off and running I can do what I did before.
It makes it easy to give the lecture.
Because this is going to be x sub b is equal to x sub s times the cosine of theta sub b minus y sub s times the cosine of theta-- oh, you're letting me make mistakes.
Shame.
I can generally tell by all the troubled looks.
But there should be some shouting as well.
That's the sine and that's the sine.

And I forgot the b up there.
So there are some equations.
And we don't know what we're doing.
We're just going to stare at them awhile and see if they sing us a song.
So let's see if they sing us a song.
What about x sub a and x sub b?
These are things that we see in the image.
These are things that we can measure.
What about all those cosines and sines of theta a's and theta b's.
Well, we have no idea what they are.
But one thing is clear.
They're true for all of the points on the object.
Because when we rotate the object around by angle theta, we're rotating all of the points through the same angle, right?
So with respect to any particular view of the object-- here we are in the standard position.
Here we are in position a.
The vectors to all of the points on the object are rotated by the same angle when we go from the standard position to the a position.
So that means that for all of the images in this particular rendering, with a particular rotation by theta a, theta b, and theta u, those are constants.
Now remember this is for a particular theta a, a particular theta be, and a particular theta u.
As long as we're talking about all of the points for each of those rotations, those angles and cosines are going to be the same for all possible points on the object.
OK.
So now we go back to our high school algebra experts and we say, look at these first two equations, We've got two equations and what we can now construe to be two unknowns.
What are the unknowns that are left?
We can measure a and b.
Whatever the cosines are, they're the same for all the pictures.
So if we treat those as constants, then we can solve for x sub s and y sub s.
Right?
We can solve for x sub s and y sub s in terms of x sub a and x sub b and a whole bunch of constants.
But, I don't know, a whole bunch of constants, let's see.
We can gather up all of those cosines and ratios of sines and cosines and all that stuff and put them all together.
Because they're all constants.
And then we can do this.
We can say x sub u is equal to-- well, it's going to depend on x sub a and x sub b.

So that's not a slight of hand.
That's just linear manipulation of those equations.
And that's what we wanted to show, that for orthographic projection, which this is-- there is no perspective involved here, we're just taking the projection along the x-axis-- we can demonstrate for this simplified situation that that equation must hold.
Now I want to give you a few puzzles.
Because this stuff is so simple.
Suppose I allow translation as well as rotation.
What's going to happen?
STUDENT: You just get the tau.
Basically, you get a constant.
PATRICK WINSTON: Yeah, you add a constant, tau.
But what do we need to do in order to solve it?
STUDENT: Subtract them [INAUDIBLE].
You subtract two equations and then [INAUDIBLE].
PATRICK WINSTON: Let's see, now we've got three unknowns, right?
I don't know tau.
I don't know x sub s.
And I don't know y sub s.
So I need another equation.
Where do I get the other equation.
STUDENT: [INAUDIBLE].
PATRICK WINSTON: From another picture.
That's why up there I needed four points.
That covers a situation where I've got three degrees of rotation and translation.
Here I got by with just two pictures in this illustration.
That one involved a tau translational element, so I needed three pictures.
And this one's got full rotation, so I needed four.
So great idea, works fine.
The trouble is it doesn't work so fine on natural objects.
It works fine on things that are manufactured because they all have identical dimensions.
So if I made a million of these in a factory, I'd have no trouble recognizing them.
Because all I'd have to do is take three pictures, record the coordinates of some of the points, and I'd be done.
The trouble is the natural world isn't like this.
And you aren't like this either.
I don't know, if I'm trying to recognize faces, it's not that easy to do all this.
First of all, it's a little difficult to find the exact point, the exactly corresponding points.
I made a mistake in doing it myself.
And if the computer made a mistake it would certainly make an error.
Because it would be using non-corresponding points to make the prediction.
So it would be way off.
But this is still in the tradition of working from local features in the objects toward recognition.
So having looked at that theory, we also find it a little wanting.
It works great it some circumstances, doesn't seem to solve the whole recognition problem.
Years pass.
Shimon Ullman comes up with another theory that's not so much based on edge fragments or the location of particular features but rather on correlation.
Taking a picture of, say, Krishna's face, taking a picture of the whole class, and then using that as a kind of correlation mask, running it all over the picture of the class, seeing where it maximizes out.
Now that's vague.
I'll explain when I'm talking about [INAUDIBLE] correlation in a minute.
But it's basically saying, if I have a picture of Krishna, where do I find him?
I'll find him in one place.
But you know what?
Krishna doesn't look like anybody else.
So I might not find any other faces.
And if my objective is to find all the faces, then maybe that idea won't work either.
Or, to take another example, here's a dollar bill.
We haven't had raises in quite well, so this is my last one.
It's got a picture of George Washington on it.
And I can look all over the class.
And if I use this is as a face detector, I'd be sorely disappointed.
Because I wouldn't find any faces.
Because thank God, nobody looks exactly like George Washington.
So the correlation wouldn't work very well.

But wait a minute.
I don't have to look for the whole face.
I could just look for eyes.
And then I could look for noses and maybe mouths.
And maybe I could have a library of 10 different eyes and 10 different noses and 10 different mouths.
Would that idea work?
Probably not so well.
The trouble with that one is, I'd find eyeballs in every doorknob.
There's just not enough stuff there to give me a reliable correlation.
So let's make this a little more concrete by drawing some pictures.
Halloween is approaching.
So here's a face.
All right?
Here's another face.
So those might be faces in my pre-recorded library of pumpkin faces.
Now along comes this face.
What's going to happen?
Well, I don't know.
Let's draw yet another face.
I don't know, that could be a pretty weird pumpkin face, I suppose.
But I mean it to be something that doesn't look very much like a face.
So if I'm doing a complete correlation with either of these faces in my library, neither one will match this one very well.
If I'm looking for fine features like eyes, then I've got these eyes everywhere.
So it doesn't help very much.
So you can see where I'm going.
And you can reinvent Ullman's great idea.
What is it?
We don't look for big features, like whole faces.

So when we do that, then we can say, now, here are two eyes and a nose.
Well, that's found in this one.
And what about the combination of that nose and that mouth?
Oh, that's over here.
But neither of those features can be found in the fourth image.
So that's the Goldilocks principle.
When you're doing this sort of thing, you want things that are not too small and not too big.
I've got the Rumpelstiltskin principle up there, too, by the way.
Because I meant to mention that Marr was a genius at naming things.
And even though many of his theories have faded, he's still known for these names like primal sketch and two and a half D sketch because he was such an artist at naming the concepts.
He even got credit for a lot of stuff that he didn't do.
Not because he was deliberately trying to get it inappropriately, but just because he was so good at naming stuff.
So we had the Rumpelstiltskin principle back then.
And now we have the Goldilocks principle.
Not too big, not too small.
But that leaves us with the final question, which is, so if what we want to do is look for intermediate-size features, how do we actually find them in a sea of faces out there?
See, I might have a library, I might take 10 of you and record your eyes.
Take another ten, record your mouths.
And they may be put together in a unique way for each of you out there.
But it's likely that I'll fin Lana's eyes somewhere else in a crowd.
And Nicola's mouth somewhere else in a crowd.
So how do we in fact go about finding them?
And I mentioned the term correlation a couple of times now.
Let me make that concrete.
So let's consider a one-dimensional face that looks like this.
Which is a signal.
And I'm going to consider a one-dimensional image.
And in that one-dimensional image I've got a facsimile of the face.
And the question is, what kind of algorithm could I use to determine the offset in the image where the face occurs?
So you can see that one possibility is you just do an integral of the signal in the face and the signal out here over the extent of the face and see how it multiplies out.
Or, to make it less lawyerly and more MITish, let's say that what we're going to do is we're going to maximize over some parameter x the integral over x of some face, which is a function of x and the image g, which is a function of x minus that offset.
So when the offset, t, is equal to this offset, then we're essentially multiplying the thing by itself and integrating over the extent of the face.
And that gives you a very big number if they're lined up and a very small number if they're not.
And it's even true if we add a whole lot of noise to the images.
But these are images.
They're not one dimensional.
But that's OK.
It's easy enough to make a modification here.
We're going to maximize over translation parameters x and y.
And these are no longer functions of just x, they're also functions of y.
Like so.
So that's basically how it works.
We won't go into details about normalization and all that sort of thing because that's the stuff of which other courses remain the custodians.
So would you like to see a demonstration?
OK.
All right.
So without realizing it, Nicola and Erica have loaned us their pictures.
And they are embedded in that big field of noise.
And it's pretty easy to pick out Erica and Nicola, right?
Because we are actually pretty good at picking faces out of these images.
So let's add some noise.
It's a little harder now.
What I'm going to is I'm going to run this correlation program over this whole image using Nicola's face as a mask and seeing where the correlation peaks up, in spite of all the noise that's in there.
Boom, there he is.
I don't know, maybe we can find Erica too.
I forgot where she was.
I can't find her.
There she is.
Unfortunately the parameters aren't very good here.
Do you see that?
Let me get another version of this.
I'll just do some real-time programming.
I've been trying to reset the parameters so that the images in the demonstration comes out clearly up there.
Let's see if this works a little better.
OK, so let's add some noise.
And let's find Erica.
There she is.
There are some other things that look a little bit like Erica.
But nothing looks quite exactly like Erica.
So let's try Nicola's eyes.
So they stand out pretty clearly against the background.
Let's see if we can find Erica's eyes.
So they stand out pretty clearly against the background.
Notice that it also gets Nicola's eyes.
So two eyes is an intermediate-size constraint.
It's loose enough that it will match more than one person.
But it's not so loose that it's as bad as looking for one eye.
See, they're all over the place.
So two eyes and a nose, a mouth and a nose, that would be even better as an intermediate feature.
But it doesn't matter what the best ones are, because you can work that out experimentally.
So that's how correlation works.
And it's just amazing how much noise you can add and it'll still pick out the right stuff.
There's Nicola.
Boom.
Very clear.
Want to add some more noise?
I don't know, I can see it, but that's because I'm a pretty good correlator, too.
Boom.
I don't know, let's add some more noise.
It's just hard to get rid of it.
It's just amazing how well it picks it out.
That's good.
That's cool.
Now, but the reason that this is 30 years and we're still not done is there are still some questions.
This is recognizing stuff straight on.
How is it I can recognize you in the hall from the side?
Nobody knows.
One possibility is that you have an ability to make those transformations.
If so, then that alignment theory has a role to play.
Another theory is that, well, after I've seen you once I can watch you turn your head and keep recording what you look like at all possible angles.
That would work.
The trouble is, is there enough stuff in there?
Maybe.
We don't know.
Now what would it take to break this mechanism?
Well, I don't know.
Let's just see if we can break the mechanism.
Let's see if you can recognize some well-known faces.
Who's that?
Quick.
STUDENT: Obama.
PATRICK WINSTON: Oh, that's too easy.
We'll see if we can make some harder ones.
Yeah, that's Obama.
Who's this?
STUDENT: Bush.
PATRICK WINSTON: Oh boy.
You're really good at this.
That's Bush.
How about this guy?
STUDENT: Kerry.
PATRICK WINSTON: OK.
Now I've got it.
Some people are starting to turn their heads.
And that's not fair.
[LAUGHTER] PATRICK WINSTON: That's not fair.
Because you see what's happened is that if this kind of pumpkin in theory is correct, then when you turn the face upside down you lose the correlation of those features that have vertical components.

Well, let's see.
We'll try some more.
Who's that?
STUDENT: Gorbachev.
PATRICK WINSTON: Gorbachev.
Who said that?
Leonid, where are you?
This is Gorbachev, right?
You can recognize him because of the little birthmark on the top of his head.
One more.
Who's-- oh, that's easy.
Who is it?
That's Clinton.
How about this one?
Do you see how insulting it is to be at MIT?
That's me.
[LAUGHTER] PATRICK WINSTON: And you didn't even know.
Oh, god.
So this might be evidence for the correlation theory.
But of course, turning the face upside down would make it very difficult to do alignment, too.
So it would break out alignment theory, as well.
Let me get that after class, Was there a mistake, or?
STUDENT: No, no.
I was just curious [INAUDIBLE] stretching would break the correlation.
PATRICK WINSTON: If what would break the structure?
What?
Stretching?
STUDENT: [INAUDIBLE].
PATRICK WINSTON: Elliot asked if stretching would break the correlation.
And the answer is, I think, stretching in the vertical dimension is worse than stretching in the horizontal dimension.

By the way, since our faces are basically mounted on a cylinder, this kind of transformation might actually work.
That's a sidebar to the answer to your question, Elliot.
But now you say, well, OK, so this is not completely solved.
You can work this out.
But if you really want to work something out, let me tell you what the current questions are in computer vision.
People have worked for an awful long time on this recognition stuff and, to my mind, have neglected the more serious questions.
It's more serious questions are, how do you visually determine what's happening?
If you could write a program that would reliably determine when these verbs are happening in your field of view, I will sign your Ph.D. thesis tomorrow.
There are 48 of them there.
And that is today's challenge.
But since we're short on time, I want to skip over that and perform an experiment on you.
I want you to tell me what I'm doing.
STUDENT: [INAUDIBLE].
PATRICK WINSTON: So the best single-word answer is?
[INAUDIBLE]?
STUDENT: Drinking.
PATRICK WINSTON: OK, this is not a trick question.
OK, the best single-word answer.
Christopher, what do you think?
STUDENT: Toasting.
PATRICK WINSTON: Christopher.
Well, you.
You.
STUDENT: Toasting.
PATRICK WINSTON: What?
Toasting.
OK.
Not a trick question.
What's happening here?
Best single-word answer?
STUDENT: Drinking.
PATRICK WINSTON: Is drinking.
Which pair look more alike?
[LAUGHTER] PATRICK WINSTON: So that cat is drinking and nobody has any trouble recognizing that.
And I believe it's because you're telling a story.
So our power of storytelling even reaches down into our visual apparatus.
So the story here is that some animal has evidently had an urge to find something to drink and water is passing through that animal's mouth.
That's the drinking story.
So even though they look enormously different visually, the stuff at the bottom of our vision system provides enough evidence for our story apparatus so that we can give the left one and the right one different labels and recognize the cat is drinking.
And that's the end of the story.


Oscillator Player
Click to start making noise
Use slider to change frequency of the noise
Waveform
Sawtooth
Sine
Triangle
Square
JavaScript Sound Demo


|
The site has moved to http://mussard.github.io/ |
|
|
Bastien Mussard ... Softwares |
|
(from http://www.molpro.net) "Molpro is a comprehensive system of ab initio programs for advanced molecular electronic structure calculations. It comprises efficient and well parallelized programs for standard computational chemistry applications, such as DFT with a large choice of functionals, as well as state-of-the art high-level coupled-cluster and multi-reference wave function methods. Molpro is very easy to use for standard applications, but also includes many advanced options for expert applications." I have first implemented functionnalities in the MOLPRO quantum chemistry package at the beginning of my PhD thesis, from 2010 to 2013, but mainly I have been in charge of its management and support during my post-doc at the Laboratoire de Chimie Théorique at the Université Pierre et Marie Curie, from 2014 to 2016. I unified different pre-existing RPA developments and improved the performance of the code (memory management, CPU time of the transformation of bi-electronic integrals, etc). I also implemented all the tools necessary to the many projects underwent in that time, such as the generalization to open-shell systems and the calculations using fractional occupation numbers. |
|
(from https://sanshar.github.io/Dice) "Dice is a program principally written by Sandeep Sharma that implements the semistochastic heat bath configuration interaction (SHCI) algorithm for ab initio Hamiltonians of quantum chemical systems. Unlike full configuration interaction (FCI), SHCI can be used to treat active spaces containing 30 to 100 orbitals. SHCI is able to accomplish this by taking advantage of the fact that although the full Hilbert space may be enormous, only a small fraction of the determinants in the space have appreciable coefficients." In the Dice program, I am involved in the implementation of perturbative corrections (notably MRLCC) and the SCF feature. |
|
(from https://github.com/sunqm/pyscf) "PySCF is an ab initio computational chemistry program implemented in Python program language. The package aims to provide a simple, light-weight and efficient platform for electronic structure theory developing and simulation. Although most functions are written in Python, the computation critical modules are intensively optimized in C. The package works as efficient as other C/Fortran based quantum chemistry program." I implemented some simple modifications to the BLOCK and Dice interfaces with PySCF, notably for the calculation of fully internally contracted NEVPT and MRLCC. |
|
(from http://pages.physics.cornell.edu/~cyrus/champ.html) "CHAMP is a quantum Monte Carlo suite of programs for electronic structure calculations principally written by Cyrus Umrigar and Claudia Filippi with major contributions by Julien Toulouse and Devrim Guclu, postdocs at Cornell and smaller contributions by others. The following three basic capabilities define the package: VMC and DMC, optimization of many-body wave functions by variance minimization (FIT) and by any linear combination of energy and variance minimization (VMC)." In CHAMP, I implemented the necessary tools to calculate time-dependent linear-response properties in VMC, and I am involved in the implementation of very fast and efficient calculations of determinants and second-order derivatives. |


{% extends "instructions/Page.html" %}
{% load staticfiles otree %}
{% block title %}
INSTRUCTIONS - PART 1
FORMING PAIRS
{% endblock %}
{% block content %}
In each round, you will form a pair with another player.
In each market, pairs can only be formed between Group 1 players and Group 2 players.
For example, two players cannot form a pair if they are both members of Group 1.
Thus, in each round, 3 pairs will be formed within a market.
When you form a pair, you earn an amount of points that depends on the product of your multiplier and the multiplier of your partner.


Guardians of the Goats
Home
Join Us
Goats
Guardians
Resources
Resources
We've put together some resources dedicated to caring for goats, baby goats, and sick goats.
We also included a few of our favorite local Washington goat rescues right below if you're interested in volunteering.
How to care for Goats
Goat Care Basics
Goats 101
Caring for Goats in 3 Steps
Raising Goats
Caring for a Sick Goat
How to care for Baby Goats
Baby Goat Basics
Baby Goats 101
Caring for Kids
Raising Kids


Hi, I’m Liz and I am super excited to share with the world my passion for incense burners and art! Our journey started in my garage. I built an art studio for my work in 2020. Since then, I’ve been exploring different kinds of mediums, such as natural clay. Once I got a feel for the material, I immediately fell in love! I started making random objects with the clay and just plopping them in every corner of the house. Then one day, I decided to light an incense cone while I was working that day. I was sculpting a head. Then as the aroma of the incense filled the room, I stopped and thought to myself; “why don’t I create my own incense burners!”. And so I did, and the rest is history. I initially made them for myself but then saw that people were actually interested in buying them! I then decided to launch a small business where I made custom orders for my friends and family.
It doesn't stop here. My brother, Nelson, who specializes in Mechanical and Electrical Engineering, offered his skill to the company. (This is in the works, but) Nelson pitched the idea of mechanizing these burners to make the smoke blow out in certain patterns and shapes with tiny fans. He began planning for this and also teamed up with a colleague of his who would be able to mass produce these high-tech burners using 3D-printing. This is where our worlds collided. Never would I ever think of collaborating with my engineer brother. Our talents seemed like polar opposites but Incense Customs has inspired us to come together and create!
We appreciate all the love and support and look forward to showing you our new, high-tech incense burners *coming soon!*. For now, please feel free to look at our catalog of traditional incense burners.


Explanation
Bloc Jams is a dynamic web and mobile music player. The project consists of a landing page, a collection page, and an album page. On the landing page, we use animation to highlight the selling points of the website. On the collection page, the user may select an album to listen to. Finally, on the album page, users may play music from an album of their choice.
Problem
The most challenging part of the application was building dynamic and intuitive behavior for the music player, making sure the appropriate play or pause button element appears when it is hovered over or clicked, and what must happen to the interface when playing and pausing the music. It is a goal of this project to communicate these states to the user visually, so that they may play and pause the music as they please, in an easy interaction with a friendly user interface.
Solution
I used JavaScript and jQuery to implement the functionality. I used a clickHandler function to deal with what happens when you click anywhere along the song row, and the proper pause and play behavior. I also used an onHover and an offHover function to specify what the behavior should be when you hover over the row and hover away from the row, and what the state of the buttons should be depending upon whether or not a song is playing.
Using clickHandler, onHover and offHover functions, I implemented the following: when clicking a song to play it, the song number should change to a pause button. When the mouse leaves the table row of the currently playing song, the pause button should remain. When we switch songs, the previously playing song’s table cell should revert the content back to the song number. When we hover over each of the songs that aren’t playing, the play button should still appear; we don’t show the play button when we hover over the playing song.
In the clickHandler function, I wrote code for reverting the song number for currently playing song because the user played a new song. Other cases included switching from a play to pause button to indicate a new song is playing, and also switching from a pause to play button when the current song is paused, with the concurrent functionality of playing or pausing the song, depending upon the circumstance.
Results
The results of this code mean the user is able to click and hover, and see the correct buttons, in addition to the correct song-playing behavior.
Otherwise, on the home page, we animated the selling points so that they appear when the user scrolls down the page a certain length. The animation triggers when the user scrolls 200px into the selling points area. Otherwise, if their screen is already large enough, we animate the points automatically.
Conclusion
I spent this project coding with JavaScript and jQuery, as well as implementing complicated music player behavior that affords the user an intuitive and delightful experience. I also made this website mobile-friendly by using media queries, so the user can play their songs even on a smaller device, like a phone or tablet. I implemented and learned a lot during this project, and feel well-equipped to tackle music applications in the future.


---
sort_order: 71
tei_id: rdx_b5h9g.p.idm198210832
annotation_count: 0
images:
small-thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcknt/mini-thumbnail/
json: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcknt/info/
full: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcknt/fs/
page: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcknt/single-page/
thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcknt/thumbnail/
title: Page 71
number: 71
---
{% raw %}JACOB HODGES.{% endraw %}
{% raw %}6?{% endraw %}
{% raw %}" That is to say, set apart three times{% endraw %}
{% raw %}a day, and let nothing prevent."{% endraw %}
{% raw %}" Three times a day ? Any particular{% endraw %}
{% raw %}place ?"{% endraw %}
{% raw %}" In the barn when I am about home{% endraw %}
{% raw %}if not, in the woods. No worldly objec/{% endraw %}
{% raw %}shall stop me when I am pressed by thf{% endraw %}
{% raw %}Spirit of God ; and if I cannot go this{% endraw %}
{% raw %}moment, the Lord will make a way foi{% endraw %}
{% raw %}me to go the next."{% endraw %}
{% raw %}" You speak much of the Spirit of Got1{% endraw %}
{% raw %}pressing you."{% endraw %}
{% raw %}" Yes; driving me to do my duty tc{% endraw %}
{% raw %}my Master."{% endraw %}
{% raw %}" What measures do you use tp have{% endraw %}
{% raw %}the movings of the Spirit upon youi{% endraw %}
{% raw %}soul ?"{% endraw %}
{% raw %}" When I feel that I am left alone by{% endraw %}
{% raw %}the Spirit, I pray for the Spirit, and the{% endraw %}
{% raw %}Lord, according to the promise, sends his{% endraw %}
{% raw %}Spirit to comfort the mourning, weeping{% endraw %}
{% raw %}sinner."{% endraw %}
{% raw %}" Does the Bible help you any about{% endraw %}
{% raw %}this ?"{% endraw %}
{% raw %}" 0, yes; the Bible is my guide and{% endraw %}


test.lua
package.path = package.path .. ";;;../../?.lua;../../?/init.lua"
local sched = require "lumen.sched"
sched.run(function()
local A=sched.run(function()
print("A says: going to sleep couple seconds")
sched.sleep(2)
print("A says: emittig 'ev, data!'")
sched.signal('ev', 'data!')
print("A says: going to sleep")
sched.sleep(100)
end)
local B=sched.run(function()
print ("B says: waiting for a A to die")
sched.wait({A.EVENT_DIE})
print ("B says: hear that A died")
print ("B says: going to error with message 'xxx'")
error('xxx')
end)
print ("0 says: waiting for a 'ev' from A")
local _, x = sched.wait({'ev'})
print ("0 says: received a 'ev' from A, with:", x)
print ("0 says: going to kill A")
sched.kill(A)
print("0 says: finishing, returning", x)
return x
end)
sched.loop()


--- layout: page title: "Calendar" description: "Looking for a calendar and booking solution... Until then..." header-img: "img/calendar-bg.jpg" ---
Currently unavailable.


Class p.p.s.StreamingHTTPHandler(
urllib2.HTTPHandler
):
Part of
pymine
.
poster
.
streaminghttp
View In Hierarchy
Subclass of `urllib2.HTTPHandler` that uses StreamingHTTPConnection as its http connection class.
Method
http_open
Undocumented
Method
http_request
Undocumented
def http_open(self, req):
Undocumented
def http_request(self, req):
Undocumented
API Documentation
for pymine, generated by
pydoctor
at 2010-04-07 23:15:24.