Processed crime incidents, based on data supplied by SANDAG.
Important:
This dataset includes geocoded crime incidents from 1 Jan 2007 to 31 March 2013 that were returned by SANDAG for Public Records request 12-075.
The extracts from the dataset include both CSV files, for use in spreadsheet applications, and ESRI shapefiles, for use in GIS applications. Both files are partitioned by year and include the following fields. Shapefiles also include point geometries for each incident.
Many of the columns use Clarinova Place Codes (CPC) to identify places, such as neighborhoods, council districts and communities.
Four of the fields use custom codes to identify geographic regions:
These fields use Clarinova Place Codes, 6 character codes that are designed to be memorable and unambiguous. See the place codes Google spreadsheet for a list all of the codes.
The integer values in the asr_zone field are taken directly from the SANGIS parcel data. These values are:
SANDAG returns the position of incidents as a block address, and occasionally as an intersection. Block addresses are the original address of the incident, with the last two digits set to '00'.
Before geocoding, all of the original block addresses are normalized to be more consistent and to remove different versions of the same address. There are a few transformations performed on the address, including:
Many geocoders are designed to work with mailable addresses, and block addresses are not real postal addresses. This data is geocoded with custom code that uses the SANGIS streets database, matching the block addresses to a street segment. This produces more sensible results, because the crime is attributed to an entire block, rather than to an arbitrary point on the block. However, with the crime is represented as a point, it will appear at the location of the center of the street segment, usually in the middle of the block.
This means that all of the incidents on a block will appear at a single location. In most GIS programs, it is difficult to see that there are actually many points in one place. Be aware that each point you see may actually be dozens of incidents.
The files that SANDAG returned included 1,008,524 incident records, and 953,824 records were geocoded (95%). The 'gctype' field has a value of NONE when the record was not geocoded, and any field that depends on a locations, such as x, y, lon, lat, segment_id, community, and others, will have default values.
As with most crime data, there are many issues, limitations and problems that users must be aware of to avoid making incorrect conclusions.
Crime incident data is inherently problematic. Crime incident reports are collected by busy officers in stressful situations who are trying to describe complex situations with rigid categories. Virtually every point of the data collection process has multiple opportunities for errors and few opportunities for correction after the fact. Analysts must consider the difficulties of collecting crime data when assessing the validity of any conclusions.
Data is collected by 19 different agencies. While the data is all sourced from SANDAG, it originates with 19 different police departments. These departments may have different policies that can result in different categorizations for the same crime, and they may have different emphases on which crimes they pursue.
Many incidents at a single point. Because all of the crimes on a block are geocoded to the middle of the block, many incidents will appear as a single point.
5% of crimes are not geocoded. GIS users should consider that about 5% of the incidents were not properly geocoded, and are not included in the shapefiles. These crimes appear in the CSV files, and can be included in time series analysis, but they will not be available for spatial analysis.
Time and dates are often unreliable Time and dates for many incidents are unreliable, with times being more unreliable than dates.
Property crimes that occur while the owner is gone may be recorded as the time a responsible person left the property, arrived at the property to discover the crime, or the average between the two. There is no information available to select among these possibilities, so these incidents have very unreliable times.
Because the time is unreliable, so is the date, for crimes that occurred at night.
Times may have not been recorded in the original report. These times may be entered as midnight, or as another time.
Multiple crime incidents may not have all crimes recorded. If a single person is charged with multiple violations for a single arrest, departments may enter only the most serious charge, the last charge, or all of the charges. There is no information to disambiguate these possibilities.
Locations may be unreliable. Crimes that involve pursuits or violations committed and multiple locations may be recorded and any of many different locations. When the location is ambiguous, tt is common for incidents to have the address recorded as the location where the arrested person was charged. Because of this, the highest crime block in San Diego is the downtown police station. Check high crime locations to ensure they are not police stations.
Number of incidents by year:
year count
---------- ----------
2007 186014
2008 178445
2009 163646
2010 160133
2011 147270
2012 141318
2013 31699
Crime types, from the "type" field, and the number of that type
type count
------------------------ ----------
DRUGS/ALCOHOL VIOLATIONS 230462
THEFT/LARCENY 138030
VEHICLE BREAK-IN/THEFT 123955
MOTOR VEHICLE THEFT 97498
BURGLARY 91695
VANDALISM 83912
ASSAULT 70687
DUI 58311
FRAUD 55219
ROBBERY 22685
SEX CRIMES 22281
WEAPONS 11117
ARSON 2145
HOMICIDE 528
Incidents by city:
name code count
------------------------- ---------- ----------
San Diego SndSAN 401787
S.D. County SndSDO 342282
Oceanside SndOCN 44022
Chula Vista SndCHU 38387
Escondido SndESC 26079
Vista SndVIS 20044
Carlsbad SndCAR 18330
La Mesa SndLAM 17871
El Cajon SndELC 16548
National City SndNAT 16509
San Marcos SndSNM 14230
Santee SndSNT 12328
Encinitas SndENC 12302
Poway SndPOW 8565
Imperial Beach SndIMP 5442
Del Mar SndDEL 4876
Lemon Grove SndLEM 4198
Coronado SndCOR 2466
Solana Beach SndSOL 2259
Name of file, extracted from bundle source-dataset-subset-variation-0.0.1. San Diego Regional Data Library. http://sandiegodata.org
This data is released under the following terms and conditions.
Clarinova and the San Diego Regional Data Library disclaim any warranty for this data shall not be liable for loss or harm. See the SDRDL Disclaimers and Limitations web page for complete details.
This data is based on data from SANGIS, which is subject to its own terms and conditions. See the SANGIS Legal Notice for details.
This data is based on data from SANDAG, which is subject to its own terms and conditions. See the SANDAG Legal Notice for details.


--- layout: default ---
I am a Software Engineer on the Restaurants team at Square, and I graduated from Tufts University in 2021. I'm interested in software engineering, cybersecurity, and product management. I find space exploration and film fascinating, and I like to dabble in photography and Photoshop. I am also a big fan of the subway and cooking shows! I am based in New York City.
last updated: 7/29/21


|
Panda3D
|
The base class for timeline components. More...
Public Types | |
| enum | EventType { ET_initialize = 0, ET_instant = 1, ET_step = 2, ET_finalize = 3, ET_reverse_initialize = 4, ET_reverse_instant = 5, ET_reverse_finalize = 6, ET_interrupt = 7 } |
| enum | State { S_initial = 0, S_started = 1, S_paused = 2, S_final = 3 } |
Public Member Functions | |
| __init__ (const CInterval) | |
| clearToInitial () | |
| Pauses the interval, if it is playing, and resets its state to its initial state, abandoning any state changes already in progress in the middle of the interval. More... | |
| finish () | |
| Stops the interval from playing and sets it to its final state. More... | |
| bool | getAutoFinish () |
| Returns the state of the 'auto_finish' flag. More... | |
| bool | getAutoPause () |
| Returns the state of the 'auto_pause' flag. More... | |
| str | getDoneEvent () |
| Returns the event that is generated whenever the interval reaches its final state, whether it is explicitly finished or whether it gets there on its own. More... | |
| double | getDuration () |
| Returns the duration of the interval in seconds. More... | |
| CIntervalManager | getManager () |
| Returns the CIntervalManager object which will be responsible for playing this interval. More... | |
| str | getName () |
| Returns the interval's name. More... | |
| bool | getOpenEnded () |
| Returns the state of the "open_ended" flag. More... | |
| double | getPlayRate () |
| Returns the play rate as set by the last call to start(), loop(), or set_play_rate(). More... | |
| CInterval::State | getState () |
| Indicates the state the interval believes it is in: whether it has been started, is currently in the middle, or has been finalized. More... | |
| double | getT () |
| Returns the current time of the interval: the last value of t passed to priv_initialize(), priv_step(), or priv_finalize(). More... | |
| bool | getWantsTCallback () |
| Returns the state of the 'wants_t_callback' flag. More... | |
| bool | isPlaying () |
| Returns true if the interval is currently playing, false otherwise. More... | |
| bool | isStopped () |
| Returns true if the interval is in either its initial or final states (but not in a running or paused state). More... | |
| loop (double start_t, double end_t, double play_rate) | |
| Starts the interval playing by registering it with the current CIntervalManager. More... | |
| output (Ostream out) | |
| double | pause () |
| Stops the interval from playing but leaves it in its current state. More... | |
| privDoEvent (double t, CInterval::EventType event) | |
| privFinalize () | |
| This is called to stop an interval, forcing it to whatever state it would be after it played all the way through. More... | |
| privInitialize (double t) | |
| This replaces the first call to priv_step(), and indicates that the interval has just begun. More... | |
| privInstant () | |
| This is called in lieu of priv_initialize() . More... | |
| privInterrupt () | |
| This is called while the interval is playing to indicate that it is about to be interrupted; that is, priv_step() will not be called for a length of time. More... | |
| privReverseFinalize () | |
| Called generally following a priv_reverse_initialize(), this indicates the interval should set itself to the initial state. More... | |
| privReverseInitialize (double t) | |
| Similar to priv_initialize(), but this is called when the interval is being played backwards; it indicates that the interval should start at the finishing state and undo any intervening intervals. More... | |
| privReverseInstant () | |
| This is called in lieu of priv_reverse_initialize() . More... | |
| privStep (double t) | |
| Advances the time on the interval. More... | |
| resume () | |
| Restarts the interval from its current point after a previous call to pause(). More... | |
| resume (double start_t) | |
| Restarts the interval from the indicated point after a previous call to pause(). More... | |
| resumeUntil (double end_t) | |
| Restarts the interval from the current point after a previous call to pause() (or a previous play-to-point-and-stop), to play until the indicated point and then stop. More... | |
| setAutoFinish (bool auto_finish) | |
| Changes the state of the 'auto_finish' flag. More... | |
| setAutoPause (bool auto_pause) | |
| Changes the state of the 'auto_pause' flag. More... | |
| setDoneEvent (str event) | |
| Sets the event that is generated whenever the interval reaches its final state, whether it is explicitly finished or whether it gets there on its own. More... | |
| setManager (CIntervalManager manager) | |
| Indicates the CIntervalManager object which will be responsible for playing this interval. More... | |
| setPlayRate (double play_rate) | |
| Changes the play rate of the interval. More... | |
| setT (double t) | |
| Explicitly sets the time within the interval. More... | |
| setupPlay (double start_time, double end_time, double play_rate, bool do_loop) | |
| Called to prepare the interval for automatic timed playback, e.g. More... | |
| setupResume () | |
| Called to prepare the interval for restarting at the current point within the interval after an interruption. More... | |
| setupResumeUntil (double end_t) | |
| Called to prepare the interval for restarting from the current point after a previous call to pause() (or a previous play-to-point-and-stop), to play until the indicated point and then stop. More... | |
| setWantsTCallback (bool wants_t_callback) | |
| Changes the state of the 'wants_t_callback' flag. More... | |
| start (double start_t, double end_t, double play_rate) | |
| Starts the interval playing by registering it with the current CIntervalManager. More... | |
| bool | stepPlay () |
| Should be called once per frame to execute the automatic timed playback begun with setup_play(). More... | |
| write (Ostream out, int indent_level) | |
| Public Member Functions inherited from TypedObject | |
| TypeHandle | getType () |
| int | getTypeIndex () |
| Returns the internal index number associated with this object's TypeHandle, a unique number for each different type. More... | |
| bool | isExactType (TypeHandle handle) |
| Returns true if the current object is the indicated type exactly. More... | |
| bool | isOfType (TypeHandle handle) |
| Returns true if the current object is or derives from the indicated type. More... | |
| Public Member Functions inherited from ReferenceCount | |
| int | getRefCount () |
| Returns the current reference count. More... | |
| ref () | |
| Explicitly increments the reference count. More... | |
| bool | testRefCountIntegrity () |
| Does some easy checks to make sure that the reference count isn't completely bogus. More... | |
| bool | testRefCountNonzero () |
| Does some easy checks to make sure that the reference count isn't zero, or completely bogus. More... | |
| bool | unref () |
| Explicitly decrements the reference count. More... | |
Static Public Member Functions | |
| static TypeHandle | getClassType () |
| Static Public Member Functions inherited from TypedReferenceCount | |
| static TypeHandle | getClassType () |
| Static Public Member Functions inherited from TypedObject | |
| static TypeHandle | getClassType () |
| Static Public Member Functions inherited from ReferenceCount | |
| static TypeHandle | getClassType () |
Public Attributes | |
| bool | auto_finish |
| Returns the state of the 'auto_finish' flag. More... | |
| bool | auto_pause |
| Returns the state of the 'auto_pause' flag. More... | |
| const String | done_event |
| Returns the event that is generated whenever the interval reaches its final state, whether it is explicitly finished or whether it gets there on its own. More... | |
| double | duration |
| Returns the duration of the interval in seconds. More... | |
| CIntervalManager | manager |
| Returns the CIntervalManager object which will be responsible for playing this interval. More... | |
| const String | name |
| Returns the interval's name. More... | |
| bool | open_ended |
| Returns the state of the "open_ended" flag. More... | |
| double | play_rate |
| Returns the play rate as set by the last call to start(), loop(), or set_play_rate(). More... | |
| bool | playing |
| Returns true if the interval is currently playing, false otherwise. More... | |
| CInterval::State | state |
| Indicates the state the interval believes it is in: whether it has been started, is currently in the middle, or has been finalized. More... | |
| bool | stopped |
| Returns true if the interval is in either its initial or final states (but not in a running or paused state). More... | |
| double | t |
| Returns the current time of the interval: the last value of t passed to priv_initialize(), priv_step(), or priv_finalize(). More... | |
| Public Attributes inherited from TypedObject | |
| TypeHandle | type |
| Returns the TypeHandle representing this object's type. More... | |
| Public Attributes inherited from ReferenceCount | |
| int | ref_count |
| The current reference count. More... | |
The base class for timeline components.
A CInterval represents a single action, event, or collection of nested intervals that will be performed at some specific time or over a period of time.
This is essentially similar to the Python "Interval" class, but it is implemented in C++ (hence the name). Intervals that may be implemented in C++ will inherit from this class; Intervals that must be implemented in Python will inherit from the similar Python class.
| enum EventType |
| enum State |
| __init__ | ( | const | CInterval | ) |
| clearToInitial | ( | ) |
Pauses the interval, if it is playing, and resets its state to its initial state, abandoning any state changes already in progress in the middle of the interval.
Calling this is like pausing the interval and discarding it, creating a new one in its place.
| finish | ( | ) |
Stops the interval from playing and sets it to its final state.
| bool getAutoFinish | ( | ) |
Returns the state of the 'auto_finish' flag.
See set_auto_finish().
| bool getAutoPause | ( | ) |
Returns the state of the 'auto_pause' flag.
See set_auto_pause().
|
static |
| str getDoneEvent | ( | ) |
Returns the event that is generated whenever the interval reaches its final state, whether it is explicitly finished or whether it gets there on its own.
| double getDuration | ( | ) |
Returns the duration of the interval in seconds.
| CIntervalManager getManager | ( | ) |
Returns the CIntervalManager object which will be responsible for playing this interval.
Note that this can only return a C++ object; if the particular CIntervalManager object has been extended in the scripting language, this will return the encapsulated C++ object, not the full extended object.
| str getName | ( | ) |
Returns the interval's name.
| bool getOpenEnded | ( | ) |
Returns the state of the "open_ended" flag.
This is primarily intended for instantaneous intervals like FunctionIntervals; it indicates true if the interval has some lasting effect that should be applied even if the interval doesn't get started until after its finish time, or false if the interval is a transitive thing that doesn't need to be called late.
| double getPlayRate | ( | ) |
| CInterval::State getState | ( | ) |
Indicates the state the interval believes it is in: whether it has been started, is currently in the middle, or has been finalized.
| double getT | ( | ) |
Returns the current time of the interval: the last value of t passed to priv_initialize(), priv_step(), or priv_finalize().
| bool getWantsTCallback | ( | ) |
Returns the state of the 'wants_t_callback' flag.
See set_wants_t_callback().
| bool isPlaying | ( | ) |
Returns true if the interval is currently playing, false otherwise.
| bool isStopped | ( | ) |
Returns true if the interval is in either its initial or final states (but not in a running or paused state).
| loop | ( | double | start_t, |
| double | end_t, | ||
| double | play_rate | ||
| ) |
Starts the interval playing by registering it with the current CIntervalManager.
The interval will play until it is interrupted with finish() or pause(), looping back to start_t when it reaches end_t.
If end_t is less than zero, it indicates the end of the interval.
| output | ( | Ostream | out | ) |
| double pause | ( | ) |
Stops the interval from playing but leaves it in its current state.
It may later be resumed from this point by calling resume().
| privDoEvent | ( | double | t, |
| CInterval::EventType | event | ||
| ) |
| privFinalize | ( | ) |
This is called to stop an interval, forcing it to whatever state it would be after it played all the way through.
It's generally invoked by set_final_t().
| privInitialize | ( | double | t | ) |
This replaces the first call to priv_step(), and indicates that the interval has just begun.
This may be overridden by derived classes that need to do some explicit initialization on the first call.
| privInstant | ( | ) |
This is called in lieu of priv_initialize() .
. priv_step() .. priv_finalize(), when everything is to happen within one frame. The interval should initialize itself, then leave itself in the final state.
| privInterrupt | ( | ) |
This is called while the interval is playing to indicate that it is about to be interrupted; that is, priv_step() will not be called for a length of time.
But the interval should remain in its current state in anticipation of being eventually restarted when the calls to priv_step() eventually resume.
The purpose of this function is to allow self-running intervals like sound intervals to stop the actual sound playback during the pause.
| privReverseFinalize | ( | ) |
Called generally following a priv_reverse_initialize(), this indicates the interval should set itself to the initial state.
| privReverseInitialize | ( | double | t | ) |
Similar to priv_initialize(), but this is called when the interval is being played backwards; it indicates that the interval should start at the finishing state and undo any intervening intervals.
| privReverseInstant | ( | ) |
This is called in lieu of priv_reverse_initialize() .
. priv_step() .. priv_reverse_finalize(), when everything is to happen within one frame. The interval should initialize itself, then leave itself in the initial state.
| privStep | ( | double | t | ) |
Advances the time on the interval.
The time may either increase (the normal case) or decrease (e.g. if the interval is being played by a slider).
| resume | ( | ) |
Restarts the interval from its current point after a previous call to pause().
| resume | ( | double | start_t | ) |
Restarts the interval from the indicated point after a previous call to pause().
| resumeUntil | ( | double | end_t | ) |
Restarts the interval from the current point after a previous call to pause() (or a previous play-to-point-and-stop), to play until the indicated point and then stop.
| setAutoFinish | ( | bool | auto_finish | ) |
Changes the state of the 'auto_finish' flag.
If this is true, the interval may be arbitrarily finished when the system needs to reset due to some external event by calling CIntervalManager::interrupt(). If this is false (the default), the interval must always be explicitly finished or paused.
| setAutoPause | ( | bool | auto_pause | ) |
Changes the state of the 'auto_pause' flag.
If this is true, the interval may be arbitrarily interrupted when the system needs to reset due to some external event by calling CIntervalManager::interrupt(). If this is false (the default), the interval must always be explicitly finished or paused.
| setDoneEvent | ( | str | event | ) |
Sets the event that is generated whenever the interval reaches its final state, whether it is explicitly finished or whether it gets there on its own.
| setManager | ( | CIntervalManager | manager | ) |
Indicates the CIntervalManager object which will be responsible for playing this interval.
This defaults to the global CIntervalManager; you should need to change this only if you have special requirements for playing this interval.
| setPlayRate | ( | double | play_rate | ) |
| setT | ( | double | t | ) |
| setupPlay | ( | double | start_time, |
| double | end_time, | ||
| double | play_rate, | ||
| bool | do_loop | ||
| ) |
Called to prepare the interval for automatic timed playback, e.g.
via a Python task. The interval will be played from start_t to end_t, at a time factor specified by play_rate. start_t must always be less than end_t (except for the exception for end_t == -1, below), but if play_rate is negative the interval will be played backwards.
Specify end_t of -1 to play the entire interval from start_t.
Call step_play() repeatedly to execute the interval.
| setupResume | ( | ) |
Called to prepare the interval for restarting at the current point within the interval after an interruption.
| setupResumeUntil | ( | double | end_t | ) |
Called to prepare the interval for restarting from the current point after a previous call to pause() (or a previous play-to-point-and-stop), to play until the indicated point and then stop.
| setWantsTCallback | ( | bool | wants_t_callback | ) |
Changes the state of the 'wants_t_callback' flag.
If this is true, the interval will be returned by CIntervalManager::get_event() each time the interval's time value has been changed, regardless of whether it has any external events.
| start | ( | double | start_t, |
| double | end_t, | ||
| double | play_rate | ||
| ) |
Starts the interval playing by registering it with the current CIntervalManager.
The interval will play to the end and stop.
If end_t is less than zero, it indicates the end of the interval.
| bool stepPlay | ( | ) |
Should be called once per frame to execute the automatic timed playback begun with setup_play().
Returns true if the interval should continue, false if it is done and should stop.
| write | ( | Ostream | out, |
| int | indent_level | ||
| ) |
| bool auto_finish |
Returns the state of the 'auto_finish' flag.
See set_auto_finish().
| bool auto_pause |
Returns the state of the 'auto_pause' flag.
See set_auto_pause().
| const String done_event |
Returns the event that is generated whenever the interval reaches its final state, whether it is explicitly finished or whether it gets there on its own.
| double duration |
Returns the duration of the interval in seconds.
| CIntervalManager manager |
Returns the CIntervalManager object which will be responsible for playing this interval.
Note that this can only return a C++ object; if the particular CIntervalManager object has been extended in the scripting language, this will return the encapsulated C++ object, not the full extended object.
| const String name |
Returns the interval's name.
| bool open_ended |
Returns the state of the "open_ended" flag.
This is primarily intended for instantaneous intervals like FunctionIntervals; it indicates true if the interval has some lasting effect that should be applied even if the interval doesn't get started until after its finish time, or false if the interval is a transitive thing that doesn't need to be called late.
| double play_rate |
| bool playing |
Returns true if the interval is currently playing, false otherwise.
| CInterval::State state |
Indicates the state the interval believes it is in: whether it has been started, is currently in the middle, or has been finalized.
| bool stopped |
Returns true if the interval is in either its initial or final states (but not in a running or paused state).
| double t |
Returns the current time of the interval: the last value of t passed to priv_initialize(), priv_step(), or priv_finalize().


location_on
find-a-doc
search
DOCTORS
face
ABOUT
rss_feed
BLOG
menu_open
MORE
Filter by name, district, location or zipcode
Doctors' name-*
District-*
Select...
...
Type-*
Select...
...
Gender-*
...
...
Specialist-*
No
Yes
Search
Clear filter
Search Results found 3 Doctor(s).


Space Invaders
Background and Motivations
Released in 1978, Space Invaders is one of the earliest shooting games to enter the arcade and handheld game arena. Drawing inspiration from Breakout and Gunfight, the game was built with a simple objective: to defeat waves of aliens with a laser and earn as many points as possible.
The day I discovered this game still occupies a special place in my memories. Dad brought home a blue box that read SPACE INVADER with a rectangular black box below it. Both of these had me confused (cut me some slack, I was five). I turned it on to see the same sequence of letters appear, asking me to hit one of the yellow buttons on the bottom of the device. It took me to a screen with a bunch of numbers and dots, some bigger than the others.
And that was that. I don’t remember understanding why the dots were differently sized or why the numbers changed by different amounts. I just played and played. Not once did I care to try and figure out what I was shooting (It was only in 6th grade that someone explained what the actual objective of the game was.) When it comes to gaming, my primary goal is to have fun. Spending time on the details and the side quests always came after. Just play.
Regretfully, I no longer own the Space Invader handheld device (I only understood what nostalgia meant in my early teens. By then it was too late). This was my motivation to choose this game for my final project, because creating this game brings back the memories of old.
Shown below is a snippet of the GUI for the arcade version.


About
Wikipedia is one of the top 10 most used websites in the world and the most widely used encyclopedia. Yet it's estimated that 84%-92% of all Wikipedia entries are edited or produced by men. This means that as litle as 8% will be edited by women. This creates a systemic bias of our world's knowledge, you can go here, here or here to read more about this.
Hear the Gap was hacked by gabs from the original Listen to Wikipedia project created by Stephen LaPorte and Mahmoud Hashemi. It estimates the number of male editors based on surveys that have been conducted by Wikipedia. The edits are real time however the male and female edits are randomly assigned.
Recent changes
For more, see Wikipedia's RecentChanges pages for each language.


The photos show some borders. This occurs firstly because I used zero padding, and secondly because I used very large kernels. As a result, the border values became particularly small. If I change to a smaller kernel size, e.g. 5 or 7, or used mirror padding, the border would almost disappear.
The Gaussian filter I used was created by Dr. Xiao. It is based off of the Gaussian formula and MATLAB’s fspecial Gaussian filter.
I created the Gaussian kernel for the lowpass filter using the function I defined. To create the highpass filter, I used the formula (1-G), where G is another Gaussian filter. The filters have different sigmas. Each sigma and kernel size is explained at the bottom of this document. I convolved the images (one highpass filter, one lowpass filter) using the imfilter function I defined. Then I combined the resulting highpass and lowpass images into a hybrid image. using the formula H = I1*G1 + I2*(1-G2). Each R G B value was added separately.
I also calculated and displayed the FFT magnitude for the original images, filtered images, and hybrid image.
To plot the cut-off frequencies, I plotted y as the magnitude in the Fourier domain and x as the frequency in the Fourier domain. I define the cut-off frequency as x when y = 0.5.
The HTML website shows the lowpass and highpass images, the hybrid images, the cut-off frequency plots, and the magnitudes of the FFTs of all the images.
Kernel sizes and sigma values:
Pair 1 (Einstein and Marilyn)
lowpass kernel size: 35x35
lowpass sigma: 7
highpass kernel size: 35x35
highpass sigma: 1
Pair 2 (cat and dog):
lowpass kernel size: 25x25
lowpass sigma: 11
highpass kernel size: 25x25
highpass sigma: 5
Pair 3 (bird and plane):
lowpass kernel size: 25x25
lowpass sigma: 11
highpass kernel size: 25x25
highpass sigma: 5
Pair 4 (fish and submarine):
lowpass kernel size: 25x25
lowpass sigma: 9
highpass kernel size: 25x25
highpass sigma: 3
Pair 5 (bike and motorcycle):
lowpass kernel size: 41x41
lowpass sigma: 15
highpass kernel size: 31x31
highpass sigma: 3


.dex
— Dalvik Executable Format
Copyright © 2007 The Android Open Source Project
This document describes the layout and contents of .dex
files, which are used to hold a set of class definitions and their associated
adjunct data.
Guide To Types
| Name |
Description |
| byte |
8-bit signed int |
| ubyte |
8-bit unsigned int |
| short |
16-bit signed int, little-endian |
| ushort |
16-bit unsigned int, little-endian |
| int |
32-bit signed int, little-endian |
| uint |
32-bit unsigned int, little-endian |
| long |
64-bit signed int, little-endian |
| ulong |
64-bit unsigned int, little-endian |
| sleb128 |
signed LEB128, variable-length (see below) |
| uleb128 |
unsigned LEB128, variable-length (see below) |
| uleb128p1 |
unsigned LEB128 plus 1 , variable-length (see below) |
LEB128
LEB128 ("Little-Endian Base 128") is a
variable-length encoding for
arbitrary signed or unsigned integer quantities. The format was
borrowed from the DWARF3
specification. In a .dex
file, LEB128 is only ever used to
encode 32-bit quantities.
Each LEB128 encoded value consists of one to five
bytes, which together represent a single 32-bit value. Each
byte has its most significant bit set except for the final byte in the
sequence, which has its most significant bit clear. The remaining
seven bits of each byte are payload, with the least significant seven
bits of the quantity in the first byte, the next seven in the second
byte and so on. In the case of a signed LEB128 (sleb128
),
the most significant payload bit of the final byte in the sequence is
sign-extended to produce the final value. In the unsigned case
(uleb128
), any bits not explicitly represented are
interpreted as 0
.
| Bitwise diagram of a two-byte LEB128 value |
| First byte
| Second byte
|
1 |
bit6 |
bit5 |
bit4 |
bit3 |
bit2 |
bit1 |
bit0 |
0 |
bit13 |
bit12 |
bit11 |
bit10 |
bit9 |
bit8 |
bit7 |
The variant uleb128p1
is used to represent a signed
value, where the representation is of the value plus one encoded
as a uleb128
. This makes the encoding of -1
(alternatively thought of as the unsigned value 0xffffffff
)
— but no other negative number — a single byte, and is
useful in exactly those cases where the represented number must either
be non-negative or -1
(or 0xffffffff
),
and where no other negative values are allowed (or where large unsigned
values are unlikely to be needed).
Here are some examples of the formats:
| Encoded Sequence |
As sleb128 |
As uleb128 |
As uleb128p1 |
| 00 | 0 | 0 | -1 |
| 01 | 1 | 1 | 0 |
| 7f | -1 | 127 | 126 |
| 80 7f | -128 | 16256 | 16255 |
Overall File Layout
Bitfield, String, and Constant Definitions
DEX_FILE_MAGIC
embedded in header_item
The constant array/string DEX_FILE_MAGIC
is the list of
bytes that must appear at the beginning of a .dex
file
in order for it to be recognized as such. The value intentionally
contains a newline ("\n"
or 0x0a
) and a
null byte ("\0"
or 0x00
) in order to help
in the detection of certain forms of corruption. The value also
encodes a format version number as three decimal digits, which is
expected to increase monotonically over time as the format evolves.
ubyte[8] DEX_FILE_MAGIC = { 0x64 0x65 0x78 0x0a 0x30 0x33 0x35 0x00 }
= "dex\n035\0"
Note: At least a couple earlier versions of the format have
been used in widely-available public software releases. For example,
version 009
was used for the M3 releases of the
Android platform (November-December 2007),
and version 013
was used for the M5 releases of the Android
platform (February-March 2008). In several respects, these earlier versions
of the format differ significantly from the version described in this
document.
ENDIAN_CONSTANT
and REVERSE_ENDIAN_CONSTANT
embedded in header_item
The constant ENDIAN_CONSTANT
is used to indicate the
endianness of the file in which it is found. Although the standard
.dex
format is little-endian, implementations may choose
to perform byte-swapping. Should an implementation come across a
header whose endian_tag
is REVERSE_ENDIAN_CONSTANT
instead of ENDIAN_CONSTANT
, it would know that the file
has been byte-swapped from the expected form.
uint ENDIAN_CONSTANT = 0x12345678;
uint REVERSE_ENDIAN_CONSTANT = 0x78563412;
NO_INDEX
embedded in class_def_item
and
debug_info_item
The constant NO_INDEX
is used to indicate that
an index value is absent.
Note: This value isn't defined to be
0
, because that is in fact typically a valid index.
Also Note: The chosen value for NO_INDEX
is
representable as a single byte in the uleb128p1
encoding.
uint NO_INDEX = 0xffffffff; // == -1 if treated as a signed int
access_flags
Definitions
embedded in class_def_item
,
field_item
, method_item
, and
InnerClass
Bitfields of these flags are used to indicate the accessibility and
overall properties of classes and class members.
| Name |
Value |
For Classes (and InnerClass annotations) |
For Fields |
For Methods |
| ACC_PUBLIC |
0x1 |
public : visible everywhere |
public : visible everywhere |
public : visible everywhere |
| ACC_PRIVATE |
0x2 |
*
private : only visible to defining class
|
private : only visible to defining class |
private : only visible to defining class |
| ACC_PROTECTED |
0x4 |
*
protected : visible to package and subclasses
|
protected : visible to package and subclasses |
protected : visible to package and subclasses |
| ACC_STATIC |
0x8 |
*
static : is not constructed with an outer
this reference |
static : global to defining class |
static : does not take a this argument |
| ACC_FINAL |
0x10 |
final : not subclassable |
final : immutable after construction |
final : not overridable |
| ACC_SYNCHRONIZED |
0x20 |
|
|
synchronized : associated lock automatically acquired
around call to this method. Note: This is only valid to set when
ACC_NATIVE is also set. |
| ACC_VOLATILE |
0x40 |
|
volatile : special access rules to help with thread
safety |
|
| ACC_BRIDGE |
0x40 |
|
|
bridge method, added automatically by compiler as a type-safe
bridge |
| ACC_TRANSIENT |
0x80 |
|
transient : not to be saved by default serialization |
|
| ACC_VARARGS |
0x80 |
|
|
last argument should be treated as a "rest" argument by compiler |
| ACC_NATIVE |
0x100 |
|
|
native : implemented in native code |
| ACC_INTERFACE |
0x200 |
interface : multiply-implementable abstract class |
|
|
| ACC_ABSTRACT |
0x400 |
abstract : not directly instantiable |
|
abstract : unimplemented by this class |
| ACC_STRICT |
0x800 |
|
|
strictfp : strict rules for floating-point arithmetic |
| ACC_SYNTHETIC |
0x1000 |
not directly defined in source code |
not directly defined in source code |
not directly defined in source code |
| ACC_ANNOTATION |
0x2000 |
declared as an annotation class |
|
|
| ACC_ENUM |
0x4000 |
declared as an enumerated type |
declared as an enumerated value |
|
| (unused) |
0x8000 |
|
|
|
| ACC_CONSTRUCTOR |
0x10000 |
|
|
constructor method (class or instance initializer) |
ACC_DECLARED_ SYNCHRONIZED |
0x20000 |
|
|
declared synchronized . Note: This has no effect on
execution (other than in reflection of this flag, per se).
|
* Only allowed on for InnerClass
annotations,
and must not ever be on in a class_def_item
.
MUTF-8 (Modified UTF-8) Encoding
As a concession to easier legacy support, the .dex
format
encodes its string data in a de facto standard modified UTF-8 form, hereafter
referred to as MUTF-8. This form is identical to standard UTF-8, except:
- Only the one-, two-, and three-byte encodings are used.
- Code points in the range
U+10000
…
U+10ffff
are encoded as a surrogate pair, each of
which is represented as a three-byte encoded value.
- The code point
U+0000
is encoded in two-byte form.
- A plain null byte (value
0
) indicates the end of
a string, as is the standard C language interpretation.
The first two items above can be summarized as: MUTF-8
is an encoding format for UTF-16, instead of being a more direct
encoding format for Unicode characters.
The final two items above make it simultaneously possible to include
the code point U+0000
in a string and still manipulate
it as a C-style null-terminated string.
However, the special encoding of U+0000
means that, unlike
normal UTF-8, the result of calling the standard C function
strcmp()
on a pair of MUTF-8 strings does not always
indicate the properly signed result of comparison of unequal strings.
When ordering (not just equality) is a concern, the most straightforward
way to compare MUTF-8 strings is to decode them character by character,
and compare the decoded values. (However, more clever implementations are
also possible.)
Please refer to The Unicode
Standard for further information about character encoding.
MUTF-8 is actually closer to the (relatively less well-known) encoding
CESU-8 than to UTF-8
per se.
encoded_value
Encoding
embedded in annotation_element
and
encoded_array_item
An encoded_value
is an encoded piece of (nearly)
arbitrary hierarchically structured data. The encoding is meant to
be both compact and straightforward to parse.
Value Formats
| Type Name |
value_type |
value_arg Format |
value Format |
Description |
| VALUE_BYTE |
0x00 |
(none; must be 0 ) |
ubyte[1] |
signed one-byte integer value |
| VALUE_SHORT |
0x02 |
size - 1 (0…1) |
ubyte[size] |
signed two-byte integer value, sign-extended |
| VALUE_CHAR |
0x03 |
size - 1 (0…1) |
ubyte[size] |
unsigned two-byte integer value, zero-extended |
| VALUE_INT |
0x04 |
size - 1 (0…3) |
ubyte[size] |
signed four-byte integer value, sign-extended |
| VALUE_LONG |
0x06 |
size - 1 (0…7) |
ubyte[size] |
signed eight-byte integer value, sign-extended |
| VALUE_FLOAT |
0x10 |
size - 1 (0…3) |
ubyte[size] |
four-byte bit pattern, zero-extended to the right, and
interpreted as an IEEE754 32-bit floating point value
|
| VALUE_DOUBLE |
0x11 |
size - 1 (0…7) |
ubyte[size] |
eight-byte bit pattern, zero-extended to the right, and
interpreted as an IEEE754 64-bit floating point value
|
| VALUE_STRING |
0x17 |
size - 1 (0…3) |
ubyte[size] |
unsigned (zero-extended) four-byte integer value,
interpreted as an index into
the string_ids section and representing a string value
|
| VALUE_TYPE |
0x18 |
size - 1 (0…3) |
ubyte[size] |
unsigned (zero-extended) four-byte integer value,
interpreted as an index into
the type_ids section and representing a reflective
type/class value
|
| VALUE_FIELD |
0x19 |
size - 1 (0…3) |
ubyte[size] |
unsigned (zero-extended) four-byte integer value,
interpreted as an index into
the field_ids section and representing a reflective
field value
|
| VALUE_METHOD |
0x1a |
size - 1 (0…3) |
ubyte[size] |
unsigned (zero-extended) four-byte integer value,
interpreted as an index into
the method_ids section and representing a reflective
method value
|
| VALUE_ENUM |
0x1b |
size - 1 (0…3) |
ubyte[size] |
unsigned (zero-extended) four-byte integer value,
interpreted as an index into
the field_ids section and representing the value of
an enumerated type constant
|
| VALUE_ARRAY |
0x1c |
(none; must be 0 ) |
encoded_array |
an array of values, in the format specified by
"encoded_array Format" below. The size
of the value is implicit in the encoding.
|
| VALUE_ANNOTATION |
0x1d |
(none; must be 0 ) |
encoded_annotation |
a sub-annotation, in the format specified by
"encoded_annotation Format" below. The size
of the value is implicit in the encoding.
|
| VALUE_NULL |
0x1e |
(none; must be 0 ) |
(none) |
null reference value |
| VALUE_BOOLEAN |
0x1f |
boolean (0…1) |
(none) |
one-bit value; 0 for false and
1 for true . The bit is represented in the
value_arg .
|
encoded_array
Format
encoded_annotation
Format
annotation_element
Format
String Syntax
There are several kinds of item in a .dex
file which
ultimately refer to a string. The following BNF-style definitions
indicate the acceptable syntax for these strings.
SimpleName
A SimpleName is the basis for the syntax of the names of other
things. The .dex
format allows a fair amount of latitude
here (much more than most common source languages). In brief, a simple
name may consist of any low-ASCII alphabetic character or digit, a few
specific low-ASCII symbols, and most non-ASCII code points that are not
control, space, or special characters. Note that surrogate code points
(in the range U+d800
… U+dfff
) are not
considered valid name characters, per se, but Unicode supplemental
characters are valid (which are represented by the final
alternative of the rule for SimpleNameChar), and they should be
represented in a file as pairs of surrogate code points in the MUTF-8
encoding.
| SimpleName → |
|
SimpleNameChar (SimpleNameChar)* |
| SimpleNameChar → |
|
'A' …  U+1fff |
| | |
U+2010 … U+2027 |
| | |
U+2030 … U+d7ff |
| | |
U+e000 … U+ffef |
| | |
U+10000 … U+10ffff |
MemberName
used by field_id_item
and method_id_item
A MemberName is the name of a member of a class, members being
fields, methods, and inner classes.
| MemberName → |
|
SimpleName |
| | |
'<' SimpleName '>' |
FullClassName
A FullClassName is a fully-qualified class name, including an
optional package specifier followed by a required name.
| FullClassName → |
|
OptionalPackagePrefix SimpleName |
| OptionalPackagePrefix → |
|
(SimpleName '/' )* |
TypeDescriptor
used by type_id_item
A TypeDescriptor is the representation of any type, including
primitives, classes, arrays, and void
. See below for
the meaning of the various versions.
| TypeDescriptor → |
|
'V' |
| | |
FieldTypeDescriptor |
| FieldTypeDescriptor → |
|
NonArrayFieldTypeDescriptor |
| | |
('[' * 1…255)
NonArrayFieldTypeDescriptor |
| NonArrayFieldTypeDescriptor→ |
|
'Z' |
| | |
'B' |
| | |
'S' |
| | |
'C' |
| | |
'I' |
| | |
'J' |
| | |
'F' |
| | |
'D' |
| | |
'L' FullClassName ';' |
ShortyDescriptor
used by proto_id_item
A ShortyDescriptor is the short form representation of a method
prototype, including return and parameter types, except that there is
no distinction between various reference (class or array) types. Instead,
all reference types are represented by a single 'L'
character.
| ShortyDescriptor → |
|
ShortyReturnType (ShortyFieldType)* |
| ShortyReturnType → |
|
'V' |
| | |
ShortyFieldType |
| ShortyFieldType → |
|
'Z' |
| | |
'B' |
| | |
'S' |
| | |
'C' |
| | |
'I' |
| | |
'J' |
| | |
'F' |
| | |
'D' |
| | |
'L' |
TypeDescriptor Semantics
This is the meaning of each of the variants of TypeDescriptor.
| Syntax |
Meaning |
| V |
void ; only valid for return types |
| Z |
boolean |
| B |
byte |
| S |
short |
| C |
char |
| I |
int |
| J |
long |
| F |
float |
| D |
double |
| Lfully/qualified/Name; |
the class fully.qualified.Name |
| [descriptor |
array of descriptor , usable recursively for
arrays-of-arrays, though it is invalid to have more than 255
dimensions.
|
Items and Related Structures
This section includes definitions for each of the top-level items that
may appear in a .dex
file.
header_item
appears in the header
section
alignment: 4 bytes
map_list
appears in the data
section
referenced from header_item
alignment: 4 bytes
This is a list of the entire contents of a file, in order. It
contains some redundancy with respect to the header_item
but is intended to be an easy form to use to iterate over an entire
file. A given type may appear at most once in a map, but there is no
restriction on what order types may appear in, other than the
restrictions implied by the rest of the format (e.g., a
header
section must appear first, followed by a
string_ids
section, etc.). Additionally, the map entries must
be ordered by initial offset and must not overlap.
map_item
Format
Type Codes
| Item Type |
Constant |
Value |
Item Size In Bytes |
| header_item |
TYPE_HEADER_ITEM |
0x0000 |
0x70 |
| string_id_item |
TYPE_STRING_ID_ITEM |
0x0001 |
0x04 |
| type_id_item |
TYPE_TYPE_ID_ITEM |
0x0002 |
0x04 |
| proto_id_item |
TYPE_PROTO_ID_ITEM |
0x0003 |
0x0c |
| field_id_item |
TYPE_FIELD_ID_ITEM |
0x0004 |
0x08 |
| method_id_item |
TYPE_METHOD_ID_ITEM |
0x0005 |
0x08 |
| class_def_item |
TYPE_CLASS_DEF_ITEM |
0x0006 |
0x20 |
| map_list |
TYPE_MAP_LIST |
0x1000 |
4 + (item.size * 12) |
| type_list |
TYPE_TYPE_LIST |
0x1001 |
4 + (item.size * 2) |
| annotation_set_ref_list |
TYPE_ANNOTATION_SET_REF_LIST |
0x1002 |
4 + (item.size * 4) |
| annotation_set_item |
TYPE_ANNOTATION_SET_ITEM |
0x1003 |
4 + (item.size * 4) |
| class_data_item |
TYPE_CLASS_DATA_ITEM |
0x2000 |
implicit; must parse |
| code_item |
TYPE_CODE_ITEM |
0x2001 |
implicit; must parse |
| string_data_item |
TYPE_STRING_DATA_ITEM |
0x2002 |
implicit; must parse |
| debug_info_item |
TYPE_DEBUG_INFO_ITEM |
0x2003 |
implicit; must parse |
| annotation_item |
TYPE_ANNOTATION_ITEM |
0x2004 |
implicit; must parse |
| encoded_array_item |
TYPE_ENCODED_ARRAY_ITEM |
0x2005 |
implicit; must parse |
| annotations_directory_item |
TYPE_ANNOTATIONS_DIRECTORY_ITEM |
0x2006 |
implicit; must parse |
string_id_item
appears in the string_ids
section
alignment: 4 bytes
string_data_item
appears in the data
section
alignment: none (byte-aligned)
type_id_item
appears in the type_ids
section
alignment: 4 bytes
proto_id_item
appears in the proto_ids
section
alignment: 4 bytes
field_id_item
appears in the field_ids
section
alignment: 4 bytes
method_id_item
appears in the method_ids
section
alignment: 4 bytes
class_def_item
appears in the class_defs
section
alignment: 4 bytes
class_data_item
referenced from class_def_item
appears in the data
section
alignment: none (byte-aligned)
Note: All elements' field_id
s and
method_id
s must refer to the same defining class.
encoded_field
Format
encoded_method
Format
type_list
referenced from class_def_item
and
proto_id_item
appears in the data
section
alignment: 4 bytes
type_item
Format
code_item
referenced from method_item
appears in the data
section
alignment: 4 bytes
try_item
Format
encoded_catch_handler_list
Format
encoded_catch_handler
Format
encoded_type_addr_pair
Format
debug_info_item
referenced from code_item
appears in the data
section
alignment: none (byte-aligned)
Each debug_info_item
defines a DWARF3-inspired byte-coded
state machine that, when interpreted, emits the positions
table and (potentially) the local variable information for a
code_item
. The sequence begins with a variable-length
header (the length of which depends on the number of method
parameters), is followed by the state machine bytecodes, and ends
with an DBG_END_SEQUENCE
byte.
The state machine consists of five registers. The
address
register represents the instruction offset in the
associated insns_item
in 16-bit code units. The
address
register starts at 0
at the beginning of each
debug_info
sequence and may only monotonically increase.
The line
register represents what source line number
should be associated with the next positions table entry emitted by
the state machine. It is initialized in the sequence header, and may
change in positive or negative directions but must never be less than
1
. The source_file
register represents the
source file that the line number entries refer to. It is initialized to
the value of source_file_idx
in class_def_item
.
The other two variables, prologue_end
and
epilogue_begin
, are boolean flags (initialized to
false
) that indicate whether the next position emitted
should be considered a method prologue or epilogue. The state machine
must also track the name and type of the last local variable live in
each register for the DBG_RESTART_LOCAL
code.
The header is as follows:
The byte code values are as follows:
| Name |
Value |
Format |
Arguments |
Description |
| DBG_END_SEQUENCE |
0x00 |
|
(none) |
terminates a debug info sequence for a code_item |
| DBG_ADVANCE_PC |
0x01 |
uleb128 addr_diff |
addr_diff : amount to add to address register |
advances the address register without emitting a positions entry |
| DBG_ADVANCE_LINE |
0x02 |
sleb128 line_diff |
line_diff : amount to change line register by |
advances the line register without emitting a positions entry |
| DBG_START_LOCAL |
0x03 |
uleb128 register_num
uleb128p1 name_idx
uleb128p1 type_idx
|
register_num : register that will contain local
name_idx : string index of the name
type_idx : type index of the type
|
introduces a local variable at the current address. Either
name_idx or type_idx may be
NO_INDEX to indicate that that value is unknown.
|
| DBG_START_LOCAL_EXTENDED |
0x04 |
uleb128 register_num
uleb128p1 name_idx
uleb128p1 type_idx
uleb128p1 sig_idx
|
register_num : register that will contain local
name_idx : string index of the name
type_idx : type index of the type
sig_idx : string index of the type signature
|
introduces a local with a type signature at the current address.
Any of name_idx , type_idx , or
sig_idx may be NO_INDEX
to indicate that that value is unknown. (If sig_idx is
-1 , though, the same data could be represented more
efficiently using the opcode DBG_START_LOCAL .)
Note: See the discussion under
"dalvik.annotation.Signature " below for caveats about
handling signatures.
|
| DBG_END_LOCAL |
0x05 |
uleb128 register_num |
register_num : register that contained local |
marks a currently-live local variable as out of scope at the current
address
|
| DBG_RESTART_LOCAL |
0x06 |
uleb128 register_num |
register_num : register to restart |
re-introduces a local variable at the current address. The name
and type are the same as the last local that was live in the specified
register.
|
| DBG_SET_PROLOGUE_END |
0x07 |
|
(none) |
sets the prologue_end state machine register,
indicating that the next position entry that is added should be
considered the end of a method prologue (an appropriate place for
a method breakpoint). The prologue_end register is
cleared by any special (>= 0x0a ) opcode.
|
| DBG_SET_EPILOGUE_BEGIN |
0x08 |
|
(none) |
sets the epilogue_begin state machine register,
indicating that the next position entry that is added should be
considered the beginning of a method epilogue (an appropriate place
to suspend execution before method exit).
The epilogue_begin register is cleared by any special
(>= 0x0a ) opcode.
|
| DBG_SET_FILE |
0x09 |
uleb128p1 name_idx |
name_idx : string index of source file name;
NO_INDEX if unknown
|
indicates that all subsequent line number entries make reference to this
source file name, instead of the default name specified in
code_item
|
| Special Opcodes |
0x0a…0xff |
|
(none) |
advances the line and address registers,
emits a position entry, and clears prologue_end and
epilogue_begin . See below for description.
|
Special Opcodes
Opcodes with values between 0x0a
and 0xff
(inclusive) move both the line
and address
registers by a small amount and then emit a new position table entry.
The formula for the increments are as follows:
DBG_FIRST_SPECIAL = 0x0a // the smallest special opcode
DBG_LINE_BASE = -4 // the smallest line number increment
DBG_LINE_RANGE = 15 // the number of line increments represented
adjusted_opcode = opcode - DBG_FIRST_SPECIAL
line += DBG_LINE_BASE + (adjusted_opcode % DBG_LINE_RANGE)
address += (adjusted_opcode / DBG_LINE_RANGE)
annotations_directory_item
referenced from class_def_item
appears in the data
section
alignment: 4 bytes
Note: All elements' field_id
s and
method_id
s must refer to the same defining class.
field_annotation
Format
method_annotation
Format
parameter_annotation
Format
annotation_set_ref_list
referenced from parameter_annotations_item
appears in the data
section
alignment: 4 bytes
annotation_set_ref_item
Format
annotation_set_item
referenced from annotations_directory_item
,
field_annotations_item
,
method_annotations_item
, and
annotation_set_ref_item
appears in the data
section
alignment: 4 bytes
annotation_off_item
Format
annotation_item
referenced from annotation_set_item
appears in the data
section
alignment: none (byte-aligned)
Visibility values
These are the options for the visibility
field in an
annotation_item
:
encoded_array_item
referenced from class_def_item
appears in the data
section
alignment: none (byte-aligned)
System Annotations
System annotations are used to represent various pieces of reflective
information about classes (and methods and fields). This information is
generally only accessed indirectly by client (non-system) code.
System annotations are represented in .dex
files as
annotations with visibility set to VISIBILITY_SYSTEM
.
dalvik.annotation.AnnotationDefault
appears on methods in annotation interfaces
An AnnotationDefault
annotation is attached to each
annotation interface which wishes to indicate default bindings.
dalvik.annotation.EnclosingClass
appears on classes
An EnclosingClass
annotation is attached to each class
which is either defined as a member of another class, per se, or is
anonymous but not defined within a method body (e.g., a synthetic
inner class). Every class that has this annotation must also have an
InnerClass
annotation. Additionally, a class may not have
both an EnclosingClass
and an
EnclosingMethod
annotation.
dalvik.annotation.EnclosingMethod
appears on classes
An EnclosingMethod
annotation is attached to each class
which is defined inside a method body. Every class that has this
annotation must also have an InnerClass
annotation.
Additionally, a class may not have both an EnclosingClass
and an EnclosingMethod
annotation.
dalvik.annotation.InnerClass
appears on classes
An InnerClass
annotation is attached to each class
which is defined in the lexical scope of another class's definition.
Any class which has this annotation must also have either an
EnclosingClass
annotation or an
EnclosingMethod
annotation.
dalvik.annotation.MemberClasses
appears on classes
A MemberClasses
annotation is attached to each class
which declares member classes. (A member class is a direct inner class
that has a name.)
dalvik.annotation.Signature
appears on classes, fields, and methods
A Signature
annotation is attached to each class,
field, or method which is defined in terms of a more complicated type
than is representable by a type_id_item
. The
.dex
format does not define the format for signatures; it
is merely meant to be able to represent whatever signatures a source
language requires for successful implementation of that language's
semantics. As such, signatures are not generally parsed (or verified)
by virtual machine implementations. The signatures simply get handed
off to higher-level APIs and tools (such as debuggers). Any use of a
signature, therefore, should be written so as not to make any
assumptions about only receiving valid signatures, explicitly guarding
itself against the possibility of coming across a syntactically
invalid signature.
Because signature strings tend to have a lot of duplicated content,
a Signature
annotation is defined as an array of
strings, where duplicated elements naturally refer to the same
underlying data, and the signature is taken to be the concatenation of
all the strings in the array. There are no rules about how to pull
apart a signature into separate strings; that is entirely up to the
tools that generate .dex
files.
dalvik.annotation.Throws
appears on methods
A Throws
annotation is attached to each method which is
declared to throw one or more exception types.


LAST DANCE A film review by James Berardinelli Copyright 1996 James Berardinelli
RATING (0 TO 10): 6.5 Alternative Scale: **1/2 out of ****
United States, 1996 U.S. Release Date: 5/3/96 (wide) Running Length: 1:43 MPAA Classification: R (Profanity, violence, mature themes) Theatrical Aspect Ratio: 1.85:1
Cast: Sharon Stone, Rob Morrow, Randy Quaid, Peter Gallagher, Jack Thompson, Jayne Brook, Charles S. Dutton Director: Bruce Beresford Producer: Steven Haft Screenplay: Ron Koslow based on a story by Steven Haft and Ron Koslow Cinematography: Peter James Music: Mark Isham U.S. Distributor: Touchstone Pictures
Arriving at theaters in the wake of the far superior DEAD MAN WALKING, LAST DANCE starts out with a serious handicap. This less compelling tale of living on death row has neither the depth nor feeling of Tim Robbins' film, and, while Sharon Stone acquits herself admirably as the prisoner, Rob Morrow leaves something to be desired as the man on the outside who develops feelings for her. Hollywood rarely does this sort of hard-hitting story as well as independent productions, and this is a case-in-point.
While LAST DANCE isn't strictly a gender-switched re-telling of DEAD MAN WALKING, there are a number of obvious similarities. In this film, the death row inmate is Cindy Liggett (Sharon Stone), a woman tried and convicted for the brutal beating deaths of two high school kids. There's no doubt that she's guilty, and Cindy never pleads innocence, although she does claim to have been high on crack at the time of the deed. As a result of various appeals, she has been awaiting death for twelve years, and the execution order has been handed down three times. On this occasion, barring a last minute miracle, it appears that the lethal injection will be administered.
Enter Rick Hayes (Rob Morrow), a new hire at the Clemency Board. After reviewing Cindy's case, he thinks she might have been given a raw deal -- her lawyer didn't bring up the drugs in her defense. So, after breaking through Cindy's hard-as-nails exterior, he begins to gather evidence to obtain another stay of execution. The deeper he digs, the more he becomes emotionally involved, risking his career for the life of this friendless woman he has learned to care for.
Director Bruce Beresford, whose erratic resume includes titles ranging from the sublime DRIVING MISS DAISY to the pointless A GOOD MAN IN AFRICA, injects a little too much manipulation and melodrama into LAST DANCE. There's all sorts of legal maneuvering going on here. Often, instead of being captivated by the characters and their interaction, we're distracted by wondering whether Cindy is actually going to die in the last reel. I kept recalling the movie at the end of Robert Altman's THE PLAYER (where Bruce Willis rushes in to save Julia Roberts from the gas chamber), and worrying that something similar might happen here.
In actuality, LAST DANCE is more Rick's story than Cindy's. Her character doesn't have much of an arc; his does. When we first meet him, he's a brash lawyer looking for a handout from his brother (Peter Gallagher), the Governor's chief of staff. After taking Cindy's case for the Clemency Board, he becomes a crusader, not so much against the death penalty but for her life (although the film's message is clearly anti-death penalty). Unfortunately, Rob Morrow doesn't display enough depth as an actor to make Rick a real person -- there are too many scenes where he comes across as flat.
Sharon Stone is not a revelation, but, dressed in drab clothes with dirty brown hair, she gives the most impressive performance of a rather lackluster career. Throughout most of the film, there is a believable, haunted look in Stone's eyes, and the questionably-structured conclusion has power largely because of the way she reacts to events.
Ultimately, one of the biggest problems with LAST DANCE is that it doesn't take risks or break new ground. It's a little too safe, and, at times, that results in mediocre drama. DEAD MAN WALKING showed the power this kind of film can have when handled well; this picture illustrates the effects of softening it for mainstream appeal. There are moments when LAST DANCE generates a legitimate emotional impact, but the road to the closing credits is littered with too many unnecessary distractions (like the last-minute efforts to save Cindy).
- James Berardinelli e-mail<EMAIL_ADDRESS>web: http://www.cybernex.net/~berardin
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Djbdns Agent backend¶
Djbdns User documentation¶
This page documents the Agent backend for djbdns.
The agent runs on the same host as the tinydns resolver. It receives DNS messages from Mini DNS using private DNS OPCODEs and classes and creates or deletes zones in the data.cdb file using axfr-get and tinydns-data
Setting up Djbdns on Ubuntu Trusty¶
Assuming no DNS resolver is already installed, run as root:
set -u
datadir=/var/lib/djbdns
ug_name=djbdns
tinydns_ipaddr=<IP_ADDRESS>
[[ -d $datadir ]] && echo "$datadir already exists" && exit 1
set -e
apt-get update
apt-get install dbndns daemontools
if ! getent passwd $ug_name >/dev/null; then
adduser --quiet --system --group --no-create-home --home /nonexistent $ug_name
fi
tinydns-conf $ug_name $ug_name $datadir $tinydns_ipaddr
cd $datadir/root
tinydns-data data
chown -Rv $ug_name:$ug_name $datadir
Setup the a Systemd service or, alternatively, an initfile to start TinyDNS.
In the contrib/djbdns directory there are example files for both.
systemctl daemon-reload
service tinydns start
service tinydns status
If needed, create the rootwrap filters, as root:
cat > /etc/designate/rootwrap.d/djbdns.filters <<EOF
# cmd-name: filter-name, raw-command, user, args
[Filters]
tcpclient: CommandFilter, /usr/bin/tcpclient, root
axfr-get: CommandFilter, /usr/bin/axfr-get, root
EOF
# Check the filter:
sudo /usr/local/bin/designate-rootwrap /etc/designate/rootwrap.conf tcpclient -h
sudo /usr/local/bin/designate-rootwrap /etc/designate/rootwrap.conf axfr-get -h
Configure the “service.agent” and “backend.agent.djbdns” sections in /etc/designate/designate.conf
Look in designate.conf.example for examples.
Create an agent pool:
# Fetch the existing pool(s) if needed or start from scratch
designate-manage pool generate_file --file /tmp/pool.yaml
# Edit the file (see below) and reload it as:
designate-manage pool update --file /tmp/pool.yaml
The “targets” section in pool.yaml should look like:
targets:
- description: gdnsd agent
masters:
- host: <MiniDNS IP addr>
port: 5354
options: {}
options:
- host: <Agent IP addr>
port: 5358
type: agent
Testing¶
Create new zones and records. Monitor the agent logfile and the contents of the TinyDNS datadir. The data.cdb file should be receiving updates.
openstack zone create --email<EMAIL_ADDRESS>example.org.
openstack recordset create example.org. --type A foo --records <IP_ADDRESS>
dig example.org @<tinydns_ipaddr> SOA
dig foo.example.org @<tinydns_ipaddr> A


About Me
Born and raised in Berkeley, California. Attended private school from Kindergarten through 8th grade at The School of the Madeleine, Saint Mary's College High School from 9-12, and after attending community college in California, graduated from the University of Hawai'i at Manoa in the spring of 2013 with an Interdisciplinary Studies degree in Nutrition and Exercise.
My professional experience has been in lifeguarding throughout my academic career, and then working in fulfillment in e-commerce previous to graduation from College. I'm able to work both indepentantly and in team settings, and respond well to high-stress environments as well as deadline driven schedules.


Derek Eder
@derekeder
As technologists, we have power. The power to build, but also to *not* build.
Kudos to the employees at Google who organized to stop this work. Much more can be done
https://www.washingtonpost.com/news/the-switch/wp/2018/06/01/google-to-drop-pentagon-ai-contract-after-employees-called-it-the-business-of-war/
6/1/2018, 7:43:08 PM
Favs: 6
Retweets: 1
link


%@ has requested to be friends with you on FreshPlan. Please accept or decline your friend request on the app.


Q. How does the LA215 compare to the LA206 and the LA112?
A. It's the BIG DOG of these line array cabinets. Much larger and heavier for larger venues. When you need to cover a larger area at higher volumes, the LA215 is the way to go if you can handle the size and weight.
Q. What are the pole mounting options
A. A single LA215 cabinet can be pole mounted on a set of 2 SAW 118 subwoofer cabinets using two poles as shown in on the photo page. The T-hat mounts on the LA215 are 24" apart and designed to align with the 24" width of the SAW 118 subwoofer cabinets. However, any subwoofers should work that can be placed with their T-hat mounts 24" apart.
Q. What are other mounting options
A. Ground stacking with the interlocking feet for stability. Also, the LA215 is 48" wide with is aligned with 2 SAW118 subwoofers which are 24" wide.
Q. Can these cabinets be hung
A. There is not currently an option to provide any hanging rigging for these cabinets. Nothing is physically keeping them from being hung but one would have to design and fabricate a hanging rigging that would be safe and secure and is usually beyond the scope of most home cabinet builders.
Q. What do you mean by "Open" design?
A. Most Line Array designs use proprietary, custom built components which can greatly raise the cost and be very expensive to repair as you are stuck buying their replacement components. In fact, it is common practice in many industries to change a part just so they can charge more for parts and repairs even though a stock part would have been just fine. Without an engineering degree and lots of research, one is stuck buying the original part at an inflated price. If you have ever had to replace a motor controller board on your home air conditioner or a heater for your spa you will know what I mean.
The LA215 uses parts that anyone can readily buy from Parts Express or USpeaker and we provide the part numbers and replacement options.
Q. How many LA215 cabinets can I run with a single amp?
A. The LA215 is a 3 way active design and requires 3 amplifier channgels and an active crossover and is dependent on how the drivers are wired and their impedence. The stock plans wire the two 15" 8 ohm woofers in parallel putting them at a 4 ohm load. So if two cabinets were stacked and ran with a single amplifier, it would be a 2 ohm load. The 6.5" MF drivers are each 8 ohms and wired in a series parallel combinations for an overall 8 ohm load. The two HF 8 ohm compression drivers are wired in parallel for a 4 ohm load. If one were to stack cabinets the HF drivers could be rewired in series putting each cabinet at a 16 ohm load for the HF and would be 8 ohms when stack. There are many options for wiring and configuing the cabinets
Q. Can I build the cabinets myself?
Yes, if you have decent skills in woodworking with access to a 10" table saw and other standard woodworking tools you can purchase plans.
Q. Where can I get the plans?
A. Please see the Plans page


Android is an operating system based on the Linux kernel, and designed primarily for touchscreen mobile devices such as smartphones and tablet computers. Initially developed by Android, Inc., which Google backed financially and later bought in 2005, Android was unveiled in 2007 along with the founding of the Open Handset Alliance—a consortium of hardware, software, and telecommunication companies devoted to advancing open standards for mobile devices. The first publicly available smartphone running Android, the HTC Dream, was released on October 22, 2008.
The user interface of Android is based on direct manipulation, using touch inputs that loosely correspond to real-world actions, like swiping, tapping, pinching, and reverse pinching to manipulate on-screen objects. Internal hardware—such as accelerometers, gyroscopes, and proximity sensors—is used by some applications to respond to additional user actions, for example adjusting the screen from portrait to landscape depending on how the device is oriented. Android allows users to customize their home screens with shortcuts to applications and widgets, which allow users to display live content, such as emails and weather information, directly on the home screen. Applications can further send notifications to the user to inform them of relevant information, such as new emails and text messages.
As of 2013, "Android dwarfs any other computing platform" in device shipments, shipping more than Windows and iOS/Mac OS combined.
As of July 2013, Android has the largest number of applications ("apps"), available for download in Google Play store which has had over 1 million apps published, and over 50 billion downloads. A developer survey conducted in April–May 2013 found that Android is the most used platform among developers; it is used by 71% of the mobile developers population.
Android's source code is released by Google under the Apache License 2.0, which allows everyone to freely modify and distribute Android under various names except by reusing the "Android" trademark; however, device manufacturers and wireless carriers have licensed the trademark from Google. Most Android devices ship with a combination of open source and proprietary software. Android is popular with technology companies which require a ready-made, low-cost and customizable operating system for high-tech devices. Despite being primarily designed for phones and tablets, it also has been used in televisions, games consoles, digital cameras, and other electronics. Android's open nature has encouraged a large community of developers and enthusiasts to use the open-source code as a foundation for community-driven projects, which add new features for advanced users or bring Android to devices which were officially released running other operating systems.
As of May 2012, Android became the most popular mobile OS, having the largest installed base, and is a market leader in most countries[22] including the United States; there it has had the highest installed base of mobile phones for years.[23] In the third quarter of 2013, Android's share of the global smartphone shipment market—led by Samsung products—was 81.3%, the highest ever. In most markets Android-powered phones are the most popular comprising more than half of the overall smartphone sales, including the United States market starting with the September–November 2013 period. The operating system's success has made it a target for patent litigation as part of the so-called "smartphone wars" between technology companies.[28][29] As of September 2013, one billion Android devices have been activated.


Actually, Woodstock was not the first outdoor festival to feature multiple bands over several days performing on a stage set up out in the middle of a farmer’s field, We were hauling a piano through.
The third Monday of January is supposed to be the most depressing day of the year. Whether you believe that or not, the long nights, cold weather and trying to keep leads to spectacular views and experiences.
UX Designer is still a relatively new profession, and one that is still being defined. Emil suggests it is an often misinterpreted role and that ‘User Experience Designer’
To make 2019 your most lucrative year yet, you may have to do some things differently than what you've done in the past.Here are 15 action items that can put you ahead.
Actually, Woodstock was not the first outdoor festival to feature multiple bands over several days performing on a stage set up out in the middle of a farmer’s field, We were hauling a piano through.
The third Monday of January is supposed to be the most depressing day of the year. Whether you believe that or not, the long nights, cold weather and trying to keep leads to spectacular views and experiences.


Choose a service
You can have a maximum of 2 services. You are currently using 1 of 2.
 It takes little effort to create a website.
Host a server for your favourite games such as: Minecraft, Counterstrike, TF2 and many more.
A VPS is a full linux(or windows) operating system in a virtual enviroment that lets you host whatever you want such as game servers, websites and scripts. This may require a bit more knowledge to get started but check out this guide and feel free to ask for help on the forum. Each server has 2 cores and 2GB of of RAM with 30GB of hard drive space. Contact us if you think you may need more
Want a service that is not on here making? Contact us and we may be able to hook you up


CHAPTER 1
INTRODUCTION
1.1 This Part of the Report alludes to some of the fundamental principles which must provide the context for any consideration of the role of the press in the United Kingdom. It does so principally for the purpose of brief overview and explanation, and to set the scene for the narrative, analysis and recommendations which follow.
1.2 The principles which are set out are not simply derived from philosophical or jurisprudential writings. Proprietors, editors and journalists wrote and spoke about the importance of what they do for all of us in the UK, and the value it has for our common life. Politicians described the principles informing their own relationship with the media, including as policy-makers. Commentators suggested the matters that the Inquiry should bear particularly in mind in approaching its task. This brief overview seeks to distil, without necessarily fully rehearsing, the essence of the points of principle which were put before the Inquiry.
1.3 Without seeking, or needing, to do full justice to the fine nuances of opinion which it is possible to hold and debate about such matters, this Part of the Report aims simply to set out a framework of understanding which is relatively uncontroversial. It is therefore the intention simply to underline, to put beyond doubt, the extent to which the Inquiry has itself proceeded on the basis of the perspectives set out, and to do so in terms with which I believe that most of the public would be able broadly to agree.
1.4 It is also the intention of this Part of the Report to clarify some of the strands of thought which have been woven through a great deal of the evidence the Inquiry has received. Concepts such as the freedom of the press, freedom of expression and the public interest have been much referred to in the course of the evidence. These are potent expressions, and powerful and important concepts; commensurate clarity and care is needed in their deployment in the context of a Report on the culture, practices and ethics of the press. They are concepts which are capable of being, and have been, used both rhetorically and analytically to explain and support a range of different perspectives, arguments and conclusions.
1.5 Attempting an all-embracing definition of concepts of this sort, even within the limitations of the Inquiry’s Terms of Reference, is neither necessary nor appropriate. Some measure of clarification is nevertheless attempted, both to underline the importance of these concepts and also to indicate the traps they can sometimes set for the unwary. This is not intended to make any claims to an especial authority in doing so, but only to give some indication of why they are important, and the limits of the uses and justifications to which they can be put. These are precious and fundamental principles, to which great respect must be paid; at the same time, they must be handled thoughtfully and with care.
1.6 The Inquiry was considerably assisted in this respect not only by the way that the issue has been put by so many journalists but, in particular by the expert witness evidence it received, in both written and oral form.1 I recognise that I have freely borrowed from their observations in some of what follows and I am grateful to them. In doing so and while acknowledging this debt, I should make clear, that the analysis set out here is entirely that of the Inquiry and is not to be taken to be representative of the entirety of the views of the expert witnesses, collectively or individually. As with other aspects of the evidence that I have sought to summarise, I can only commend those interested to the original evidence: any summary cannot attempt to do full justice to it.


Please note: The floating action button is placed at the bottom right corner of the page.
The floating action button is always shown with a close-icon when in its opened state. In order to show the icon correctly it needs to be configured as described in the project readme .
(Optional) if you need to obtain data back from the fab sheet, you can pass a callback function:
onItemSelect
can be e.g.:


Climate Change and Water Partner Organizations
- Alliance for Climate Education
- Climate Adaptation Knowledge Exchange (CAKE)
- Georgetown Climate Center
- Institute for Tribal Environmental Professionals (ITEP)
-
Water Utility Climate Alliance
The following links exit the site Exit
The Alliance for Climate Education (ACE) is a national leader in high school climate science education. ACE is dedicated to educating America's high school students about the science behind climate change and inspiring them to take action while having fun.
This site aims to build a shared knowledge base for managing natural and built systems in the face of climate change. It also intends to build an innovative community of practice. CAKE builds an interactive online platform, creates a directory of practitioners to share knowledge, and identifies and explains climate data tools and information.
The Georgetown Climate Center seeks to advance effective climate, energy, and transportation policies that reduce greenhouse gas emissions and help communities adapt to climate change. The Center works with government officials, academics, and an array of stakeholders to strengthen state and federal climate partnerships.
This site provides information and resources tailored to helping native people gain a better understanding of climate change and its impacts on their communities. The site offers training, education materials, and a variety of other resources.
The Water Environment Research Foundation (WERF) is an independent scientific research organization focused on wastewater and stormwater issues. Subscribers include wastewater treatment plants, stormwater utilities, and regulatory agencies, industry, equipment companies, engineers and environmental consultants also lend their support and expertise.
The Water Research Foundation is a leader in water research and dedicated to advancing the science of water by sponsoring cutting-edge research and promoting collaboration. The Foundation’s research provides industry insights and practical solutions to complex challenges facing the water community.
The Water Utility Climate Alliance is dedicated to collaborating on climate change issues affecting drinking water utilities. By enhancing climate change research and developing adaptation strategies, water utilities will be positioned to respond to climate change and protect our water supplies.


Welcome to The Afrofuturist Podcast Website!  We strive to create an online community for our audience through our stream of episodes, blog articles, and upcoming events. We invite you to explore our website and learn more about the world of afrofuturism.
Welcome to The Afrofuturist Podcast Website!  We strive to create an online community for our audience through our stream of episodes, blog articles, and upcoming events. We invite you to explore our website and learn more about the world of afrofuturism.
The Afrofuturist Podcast will bring the people and ideas that strive to shape the future from places seldom discussed but equally valuable. From artists and engineers to technologists and thought leaders, our show will showcase those that are passionate about diversifying and democratizing the building of the future.
Stay tuned - Exciting news is coming soon in our upcoming blog page.
We have an exciting line-up of guests in conversation with Ahmed Best for 2018 along with some upcoming live podcasts that will explore playable media, digital wearables, Afrofuturist art and transforming education in the future.
Ahmed Best earned his MFA from the American Film Institute in Los Angeles. He's a Founding member of the Hip Hop jazz group The Jazzhole and starred in the Broadway musical STOMP in New York City, the national touring and international touring companies. He's widely known for his role as Jar Jar Binks in Star Wars Episode One: The Phantom Menace, Attack of The Clones and Revenge of the Sith.
Ahmed is an Annie Award winner in Robot Chicken, an Ovation, Stage Raw and LACC award winner in Backyard-Mickey Birnbaum and a GLAAD media award winner in DL Chronicles. Creator and Director of the talk show series Dinner at LOLA (TAG media), Creator and Director of the sci-fi web comedy The Nebula, Writer and Director for the web series This Can't Be My Life and star of the upcoming series Two Black Dudes by Fuzzy Door Productions. Ahmed has currently entered the podcast world as Creator and Host of The Afrofuturist Podcast. Ahmed is obsessed with culture and is committed to democratizing the future.
Lonny J Avi Brooks is an Associate professor in the Communication Department at California State University, East Bay, which is, in turn, part of the newly formed School of Arts Media. He teaches in the Public, Professional and Organizational concentration in Communication and he is the Co-Principal Investigator for the Long Term and Futures Thinking in Education Project and has piloted the integration of long term and futures thinking into his Communication courses for the last four years.
His current manuscript is Working in the Future Tense@Futureland: Circulating Afrofuturetypes of Work, Culture and Racial Identity (in review). His latest articles include the forthcoming “Minority Reports from 2054: Building Collective and Critical Forecasting Imaginaries and Afrofuturetypes in Game Jamming” for the special 2018 issue of the Canadian journal TOPIA: Black Lives, Black Politics, Black Futures and “Cruelty and Afrofuturism,” a special commentary section on Cruelty in the Age of Trump for the Communication and Critical/Cultural Studies journal. With Dr. Reynaldo Anderson, Dr. Brooks published “Student visions of multiple urban futures 2050” in Envisioning futures for environmental and sustainability education.
If you have questions, are interested in being featured in an episode, or would like to sponsor our show, contact us using the button below and allow us to respond back as soon as we can.


Cardboard Templates and demos for Google Cardboard
BVH Reader Fast amnd simple motion capature data reader makes your characters come alive
j3qUE
Shows you an easy way to work with both jQuery and Three.js. The HTML and jQuery goes in the main HTML file.
The Three.js goes into its own file called in by an IFRAME into the main page.
In the main file, you write in jQuery style. In the iframe, you write in Three.js style.
oSome Globe
The world like she has never been seen before.
unFlatland
The map like she has never been seen before.
Video Surfaces & Video Folding Polygons
The TV like she has never been seen before.


YJ Lin
Index
About Me
<-->
Resume
Contact Me
Index
About Me
<-->
Resume
Contact Me
menu
About Me
Greeting!
Hi there,
This is Yu-Jing Lin.
Living in Taipei, Taiwan.
I'm a graduate student which is major in
Computer Science
.


Fulfulde Ajami (QWERTY) keyboard developed for use for the Adamawa Fulfulde, Maasina Fulfulde, Nigerian Fulfulde, Pular, Pulaar, and Western Niger Fulfulde languages.
This keyboard makes use of rotas for a few characters. For example: typing » twice will produce ›. Doing this works with «, ”, and “. It also works with turning fatha, kasra, and damma into fathatan, kasratan, and dammatan respectively.
It may be difficult to tell, but kashida is on the SHIFT+7 key, and the hyphen is available on the RALT+- key.
© SIL International


Humour and Dialect
by Paul Laurence Dunbar
Chrismus on the Plantation
Additional Information
- Year Published: 1913
- Language: English
- Country of Origin: United States of America
- Source: Dunbar, P.L. (1913). The Complete Poems of Paul Laurence Dunbar. New York: Dodd, Mead, and Company.
-
Readability:
- Flesch–Kincaid Level: 6.5
- Word Count: 644
- Genre: Poetry
- ✎ Cite This
Downloads
It was Chrismus Eve, I mind hit fu’ a mighty gloomy day—
Bofe de weathah an’ de people—not a one of us was gay;
Cose you ‘ll t’ink dat ’s mighty funny ‘twell I try to mek hit cleah,
Fu’ a da’ky ’s allus happy when de holidays is neah.
But we wasn’t, fu’ dat mo’nin’ Mastah ‘d tol’ us we mus’ go,
He ‘d been payin’ us sence freedom, but he couldn’t pay no mo’;’
He wa’n’t nevah used to plannin’ ‘fo’ he got so po’ an’ ol’,
So he gwine to give up tryin’, an’ de homestead mus’ be sol’.
I kin see him stan’in’ now erpon de step ez cleah ez day,
Wid de win’ a–kind o’ fondlin’ thoo his haih all thin an’ gray;
An’ I ‘membah how he trimbled when he said, “It’s ha ‘d fu’ me,
Not to mek yo’ Chrismus brightah, but I ‘low it wa’n’t to be.”
All de women was a–cryin’, an’ de men, too, on de sly,
An’ I noticed somep’n shinin’ even in ol’ Mastah’s eye.

Ef my membry has n’t fooled me, seem dat whut I hyead you say.

Well, ef dat ’s de way dis freedom ac’s on people, white er black,
You kin jes’ tell Mistah Lincum fu’ to tek his freedom back.
“We gwine wo’k dis ol’ plantation fu’ whatevah we kin git,
Fu’ I know hit did suppo’t us, an’ de place kin do it yit.
Now de land is yo’s, de hands is ouahs, an’ I reckon we ‘ll be brave,
An’ we ‘ll bah ez much ez you do w’en we has to scrape an’ save.”
Ol’ Mastah stood dah trimblin’, but a–smilin’ thoo his teahs,
An’ den hit seemed jes’ nachul–like, de place fah rung wid cheahs,
An’ soon ez dey was quiet, some one sta’ted sof an’ low:
“Praise God,” an’ den we all jined in, “from whom all blessin’s flow!”
Well, dey was n’t no use tryin’, ouah min’s was sot to stay,
An’ po’ ol’ Mastah could n’t plead ner baig, ner drive us ‘way,
An’ all at once, hit seemed to us, de day was bright agin,
So evahone was gay dat night, an’ watched de Chrismus in.


sksurgerycore.transforms package¶
Submodules¶
sksurgerycore.transforms.matrix module¶
Construct 3x3 rotation matrices for rotating around the x, y and z axes individually, as well as 3x3 rotation matrices from sequences of three Euler angles.
-
sksurgerycore.transforms.matrix.
construct_rigid_transformation
(rot_m, trans_v)¶ Construct a 4x4 rigid-body transformation from a 3x3 rotation matrix and a 3x1 vector as translation
- Parameters
rot_m – 3x3 rotation matrix, numpy array
trans_v – 3x1 vector as translation, numpy array
- Returns
rigid_transformation – 4x4 rigid transformation matrix,
numpy array
-
sksurgerycore.transforms.matrix.
construct_rotm_from_euler
(angle_a, angle_b, angle_c, sequence, is_in_radians=True)¶ Construct a rotation matrix from a sequence of three Euler angles, to pre-multiply column vectors. In the case of tracking, the column vector is under the local coordinate system and the resulting vector is under the world (reference) coordinate system. The three elemental rotations represented by the Euler angles are about the INTRINSIC axes. They can also be interpreted to be about the EXTRINSIC axes, in the reverse order.
- Parameters
angle_a – first Euler angle, float
angle_b – second Euler angle, float
angle_c – third Euler angle, float
sequence – the sequence of axes the three elemental rotations are
about, with respect to the intrinsic axes, string :param is_in_radians: if the angles are in radians, default being True, bool :returns: rot_m – the 3x3 rotation matrix, numpy array
-
sksurgerycore.transforms.matrix.
construct_rx_matrix
(angle, is_in_radians=True)¶ Construct a rotation matrix for rotation around the x axis.
- Parameters
angle – the angle to rotate, float
is_in_radians – if angle is in radians, default being True, bool
- Returns
rot_x – the 3x3 rotation matrix constructed, numpy array
-
sksurgerycore.transforms.matrix.
construct_ry_matrix
(angle, is_in_radians=True)¶ Construct a rotation matrix for rotation around the y axis.
- Parameters
angle – the angle to rotate, float
is_in_radians – if angle is in radians, default being True, bool
- Returns
rot_y – the 3x3 rotation matrix constructed, numpy array
-
sksurgerycore.transforms.matrix.
construct_rz_matrix
(angle, is_in_radians=True)¶ Construct a rotation matrix for rotation around the z axis.
- Parameters
angle – the angle to rotate, float
is_in_radians – if angle is in radians, default being True, bool
- Returns
rot_z – the 3x3 rotation matrix constructed, numpy array
sksurgerycore.transforms.transform_manager module¶
Class implementing a general purpose 4x4 transformation matrix manager.
-
class
sksurgerycore.transforms.transform_manager.
TransformManager
¶ Bases:
object
Class for managing 4x4 transformation matrices. This class is NOT designed to be thread-safe.
The transforms are required to be 4x4 matrices. There is no checking that the upper left 3x3 is an orthonormal rotation matrix.
Usage:
tm = TransformManager() # Imagine some example transformations: t1 = np.eye(4) t2 = np.eye(4) t3 = np.eye(4) # Add transformations to the TransformManager. tm.add("model2world", t1) tm.add("hand2eye",t2) tm.add("hand2world",t3) # Returns a transform from model to eye, # by working through the above transforms. t4 = tm.get("model2eye")
and so on.
-
add
(name, transform)¶ Adds a transform called name. If the name already exists, the corresponding transform is replaced without warning.
- Parameters
name – the name of the transform, e.g. model2world
transform – the transform, e.g. 4x4 matrix
-
count
()¶ Returns how many transforms are in the manager. Internally this class also stores the inverse, so this method will count those matrices as well.
-
exists
(name)¶ Returns True if the transform exists in the manager, and False otherwise. Internally this class stores the inverse. So, if you add model2world, you are also implicitly adding world2model, so this method will return True for both the originally added transform, and its own inverse.
-
static
flip_name
(name)¶ Returns the inverse name.
- Parameters
name – the name of a transformation, e.g. model2world
- Returns
str – the opposite transformation name, e.g. world2model
-
get
(name)¶ Returns the named transform or throws ValueError.
- Raises
ValueError
-
static
is_valid_name
(name)¶ Validates the name, which must match “^([a-z]+)2([a-z]+)$”.
i.e. one or more lowercase letters, followed by the number 2, followed by one or more lowercase letters.
For example:
a2b model2world
Identity transforms such as model2model raise ValueError.
- Parameters
name – the name of the transform, eg. model2world
- Raises
TypeError, ValueError
- Returns
str, str – parts of string before and after the 2.
-
static
is_valid_transform
(transform)¶ Validates the transform as a 4x4 numpy matrix.
- Parameters
transform – 4x4 transformation matrix.
- Raises
TypeError, ValueError
-
multiply_point
(name, points)¶ Multiplies points (4xN) by the named transform (4x4).
- Returns
ndarray – 4xN matrix of transformed points
- Raises
ValueError
-
remove
(name)¶ Removes a transform from the manager. If the transform name doesn’t exist, will throw ValueError.
- Raises
ValueError
-


May 2023 Hacker News Hiring Trends
Change is happening fast in the software developer hiring landscape. Let's jump in and take a look at the results from May's Hacker News "Ask HN: Who is hiring?" thread.
First, in a positive sign, there were 431 postings (as of May 21), which marks a 12% increase over April. April's total was the lowest in over 7 years, so it's good to see some growth in job opportunites.
The most significant change for May's "Who is hiring?" thread may be the ever-evolving situation of remote work. There was a big drop in remote positions, down to just over 50%, a drop of 11% from April. Hybrid is picking up the difference for the most part still.
Compare Remote vs Onsite vs Hybrid
The Top 3 for May remain the same, Python, TypeScript, and Go. But, Rust gets back to #4, matching its all time high. Also getting back into the Top 10 is Swift, at #10. Swift has been been in the Top 10. I can't recall the last time it has been there.
Compare Top 10 Programming Languages
In the AI category, probably the most covered technology of 2023, it is hard to say with certainty if there are significant changes. Mentions of Machine Learning were down a bit, while AI was up a bit.
Compare AI, Machine Learning, Deep Learning, and ChatGPT
| Tech | Rank | Last Month | Change | Last Year | Change |
|---|---|---|---|---|---|
| Remote | 1 | 1 | 0 | 1 | 0 |
| Senior | 2 | 2 | 0 | 2 | 0 |
| Full Stack | 3 | 3 | 0 | 3 | 0 |
| Python | 4 | 7 | +3 | 8 | +4 |
| Back End | 5 | 4 | -1 | 5 | 0 |
| Onsite | 6 | 8 | +2 | 9 | +3 |
| React | 7 | 5 | -2 | 4 | -3 |
| Machine Learning | 8 | 10 | +2 | 12 | +4 |
| TypeScript | 9 | 9 | 0 | 7 | -2 |
| Front End | 10 | 6 | -4 | 6 | -4 |
| AI | 11 | 14 | +3 | 24 | +13 |
| Cloud | 12 | 13 | +1 | 13 | +1 |
| Hybrid | 13 | 12 | -1 | 21 | +8 |
| Postgresql | 14 | 16 | +2 | 10 | -4 |
| Open Source | 15 | 17 | +2 | 20 | +5 |
| golang | 16 | 18 | +2 | 15 | -1 |
| AWS | 17 | 11 | -6 | 11 | -6 |
| DevOps | 18 | 19 | +1 | 16 | -2 |
| Next.js | 19 | 15 | -4 | 14 | -5 |
| Security | 20 | 20 | 0 | 17 | -3 |


Eat In Happiness
Start Your Appetite
Main Menu
Desserts
Drinks
Separator
Food
Food yada yada
17.50
Separator
Drink
3.3dl
4.50


Shakira talks depression following 2017 vocal cord hemorrhage
by Nate DayShakira is talking about the depression she experienced after a 2017 hemorrhage of her right vocal cord.
The performer, who will headline the 2020 Super Bowl Halftime Show with Jennifer Lopez, told The Guardian that not being able to sing was "unbearable."
“It was my identity," Shakira, 42, said.
The hemorrhage resulted in her having to use sign language to communicate with her family, Including her husband, soccer star Gerard Pique, and their two young sons.
The "Hips Don't Lie" singer was also forced to postpone a world tour.
“I was not positive," she recalled. "I was so pessimistic. I was a bitter person to be around. Gerard saw the worst of me.”
Despite advice from doctors to go under the knife, Shakira tried some alternative healing methods like hypnosis and meditation. She drank holy water from Lourdes, France.
DRAKE BOOED OFFSTAGE AT CAMP FLOG GNAW, AND TYLER, THE CREATOR RESPONDS
Shakira told The Guardian that she either needed surgery or "divine intervention."
Ultimately, Shakira's alternative methods worked, though, and she was able to begin singing again in 2018, calling each night of her El Dorado tour "a gift."
The Grammy winner is hard at work preparing for the Super Bowl and is excited to take part in a show that will honor Latino culture.
“I think it’s the right thing to do for the Latino community because we’ve also been through so much in Trump’s America, with walls being built,” she said. “It’s an opportunity to celebrate our culture, you know?”
CLICK HERE TO GET THE FOX NEWS APP
Shakira and Lopez, 50, will take the stage on Feb. 2/