By definition, augmented reality technology, or AR tech, is a technology that superimposes a computer-generated image on a user's view of the real world, thus providing a composite view. It acts to enhance the surrounding existing reality instead of Virtual Reality technology, which acts to create a new reality for the user to interact with. This technology has many current uses, both commercially widespread and solely in use for advanced research, and great potential to continue to enhance our interaction with our world.
Augmented Reality, or at least the idea of it, has been around for a long time. Its development and attempts at commercialization have not always been met with success, but its research and development have served to improve many of the ways we view the relationship between our lives and our technology.
The history of AR tech begins in 1968, with American computer scientist and father of graphics Ivan Sutherland's development of the first head-mounted display system, the Sword of Damocles. With the help of his student Bob Sproull, Sutherland's device served to present the user with a display of wireframe rooms, changing the display depending on the movement of the user's head, necessitating head-tracking technology that resembled a giant arm descending from the ceiling onto the device, hence its name.
In 1974, American digital artist Myron Kreuger built "Videoplace", an "artificial reality" laboratory. Videoplace used a combination of projectors, video cameras, and user silhouettes in order to present the user with an environment to interact with. This technology was intended to further explore the capability of technology to enhance human capability concerning aesthetics rather than engineering, and Videoplace is still on display today in the State Museum of Natural History in the University of Connecticut.
In 1990, American Boeing employee Tom Caudell actually put a name to the developing technology: Augmented Reality. Caudell and another employee, David Mizell, also proposed supplying factory workers at Boeing, an airplane manufacturing company, with Head Mounted Devices equipped with AR tech to assist in making changes to airplane schematics.
In 1993, American inventor, entrepreneur, and writer Louis Rosenberg developed "Virtual Fixtures", one of the first pieces of AR tech built for the Air Force. At the time, 3D graphics could not provide a realistic or fast enough picture to convey a realistic environment to work with. Rosenberg's Virtual Fixtures allowed a user to control two robots with a worn upper-body exoskeleton to work in an immersive environment in real-time.
In 1994, American television writer and producer Julie Martin produced the first AR theater production: Dancing in Cyberspace. In this production, performers interacted with and danced around projected objects displayed in real-time through Silicon Graphics computers and the Polhemus sensing system.
In 1998, 1st & Ten, a graphics system, debuted on ESPN, casting a virtual yellow line down marker during an NFL game. This system would continue to be developed and
is currently used in most, if not all, televised sports, today.
In 1999, Naval researchers developed BARS, or Battlefield Augmented Reality Systems. BARS were developed in order to look into the problem of combat in close quarters or in situations with low visibility.
In 1999, NASA utilized a Hybrid Synthetic Vision system, also described as a "virtual cockpit", to fly the X-38 spacecraft. The Hybrid Synthetic Vision system overlayed navigational data to enhance visual navigation during flights.
In 2000, Japanese professor Hirokazu Kato created ARToolKit, a software library for building AR applications. This library served to help developers with common problems such as user tracking to assist in creating as real an interactive environment as possible.
In 2003, Sportvision enhanced the 1998 breakthrough of the 1st & Ten graphics system by inserting the system into the Skycam, the NFL camera that provides an aerial viewpoint of a game.
In 2009, the ARToolKit began to be used in web browsers.
In 2009, printed media, notably, Esquire Magazine, integrates AR in their work. Specifically, Esquire encouraged readers to scan a picture of Robert Downey Jr. to make him appear to come alive on the page.
In 2013, car manufacturers began implementing AR tech in order to assist customers with vehicle service. For example, the Volkswagen MARTA, or Mobile Augmented Reality Technical Assistance, app allowed technicians to see how prospective repair paths would affect the vehicle.
In 2014, the trend of wearable AR tech begins with Google's shipment of Google Glass, a type of smart glasses.
In 2016, two major implementations of AR were introduced to the public. The first was the release of Pokémon Go, an application for mobile devices that allows users to traverse through their everyday lives in search of Pokémon. In the app, a phone's camera was used to capture the world around the user, and then an image of a Pokémon would be superimposed on that. The second was the introduction of filters to Snapchat, a popular mobile device application that allows users to send pictures to one another. In this implementation, users would take images of themselves, and, using facial-recognition software, the application would place different images on the user's face, like makeup, animal features, and glasses.
While no extremely notable achievements have been made since 2016, investments in AR tech and research continue to grow, and the future holds many possibilities.
As with any technology, AR has both a strong following of proponents and dissenters. As the technology continues to develop, many people become increasingly aware of possible security risks, especially with technologies like smart glasses that can possibly be worn throughout the span of an entire day on a daily basis, generating paranoia of being recorded. Additionally, because the widespread commercialization of AR tech is still fairly new, laws and restrictions specifically pertaining to their technology has not yet been established and society as a whole is still adapting to the everyday use of these programs, as shown in problems with Pokémon Go wherein users were trespassing and endangering their lives by not fully paying attention to their surroundings.
Should AR continue to be developed, however, the possible benefits are boundless. Already, possible uses to help people with disabilities concerning their interaction with the world around them can be seen, as existing applications to assist blind people by reading printed labels or identifying common objects grow in popularity. In education and research, AR tech can help to provide in-depth visuals that may not otherwise be readily available, especially in diagram-heavy fields like medicine or engineering. In entertainment, there is, of course, an astounding potential in improving the way we consume media, especially concerning video games.
While Augmented Reality may seem to be a very exclusive technology, it's a lot more common than what is typically thought. From everyday uses like GPS, which can superimpose current speed, ETA, and nearby locations over the user's map, to video games, like Pokémon Go, Augmented Reality technology has played a large role in our every day lives for a long time.
Augmented Reality holds a lot of potential in continuing to enhance the way in which we go about our daily lives. Its development and research are integral in allowing us to continue to develop as a society in our relationship with our technology.
As previously mentioned, AR tech can greatly assist in research by providing interactive visuals that may not be readily available by other means. In medicine, students can be able to directly work with a three-dimensional model right before their eyes, and doctors can use similar methods using imagery from CT scans or MRIs to create a comprehensive diagram of a patient in order to assist with diagnosis, prognosis, and treatment. Similarly, in engineering or architecture, students and professionals can work directly with interactive models in order to understand physical relations to enhance their work.
Much of the problem with shopping is that many consumers oftentimes don't have a good idea of how the product will fit in their home or how to interact with the product. Some businesses are hoping to or are already in the process of developing AR tech that will allow consumers to have a scaled, interactive view of the product within their residence.
Like Ivan Sutherland, some artists have already begun to explore the idea of computer-aided aesthetics. Ideas for art museums requiring the use of Head-Mounted Devices have already been proposed, and there is a great potential for artwork made entirely with AR tech. There is also potential for performing arts, such as with Julie Martin's 1994 theater production.
Of course, finally, entertainment holds a lot of potential in the development of AR tech. In video games, most obviously, the idea of further integrating augmented reality has already been explored in apps like Pokémon Go and in services like the Nintendo 3DS animating a certain card when scanned. AR tech could be developed similarly to that of Virtual Reality gaming headsets to allow a more complete integration of an interactive virtual reality gameplay for a user. Entertainment use, however, is not solely limited to video games. Other media such as movies, shows, televised sports events, books, etc. can also be enhanced with this technology according to the user's preferences or needs in order to create a more stimulating environment when consuming such media.


Pittsburgh Steelers' Mason Rudolph to be fined, avoid suspension in brawl: reports
by Ryan GaydosPittsburgh Steelers quarterback Mason Rudolph is reportedly expected to be fined but avoid suspension for his role in a brawl with Cleveland Browns defensive end Myles Garrett on Thursday.
Rudolph was taken down by Garrett after a short pass and was seen grabbing at the lineman’s helmet. Their brawl continued into the end zone and Garrett removed Rudolph’s helmet and hit him with it.
CLEVELAND BROWNS' MYLES GARRETT TO APPEAL INDEFINITE SUSPENSION THIS WEEK: REPORTS
According to ESPN, Rudolph will be fined and, as per the league collective bargaining agreement, the penalty for a first-time fighting violation comes up to $35,096. The NFL Network reported Friday that Rudolph will not be suspended for his role in the fight.
The NFL has yet to announce officially whether Rudolph will be fined.
Rudolph’s representatives suggested Friday that the quarterback could pursue legal action against Garrett. However, the NFL Network reported that Rudolph wouldn’t file charges in the case and considered the situation to be an NFL issue.
“I thought it was cowardly and bush league,” Rudolph said after the game Thursday. “There is plenty of tape out there to watch. I haven’t seen it yet. I don’t know what the rules are. I know it was bush league and a total coward move on his part. It’s OK, I’ll take it. I’m not going to back down from any bully out there. We will see what happens.”
The NFL suspended Garrett indefinitely for the attack. Steelers center Maurkice Pouncey received a three-game suspension and Browns defensive lineman Larry Ogunjobi was suspended one game.
CLICK HERE FOR MORE SPORTS COVERAGE ON FOXNEWS.COM
Each suspended player is expected to appeal.


#assign WhoModified = "true">
Along with WhoCreated is a property maintained by Ebean via a CurrentUserProvider that is supplied to ServerConfig.
WhoCreated
CurrentUserProvider
Refer to Who feature for details.


A microbial fingerprint is made up of the unique combinations of bacteria and viruses living on a particular surface. Anything can have a microbial fingerprint -- phone screen, door nobs, and city subways. The microbial fingerprint is gathered by taking a swab from the surface in question, and then using a next generation sequencing machine to determine the DNA found in the swab. The amount of bacteria in the samples is much greater than the amount of viruses, because viruses are smaller and much harder to detect. However, this is the case for every sample so when comparing them to each other the amount of viruses does not affect the analysis.
The purpose of this project is to compare the microbial fingerprint of Boston, New York City and Sacramento. The subways from these three cities were swabbed by different labs and the data was acquired from blah and blah. In order to compare the microbial fingerprints of subways to a control group, the microbial fingerprint from a human mouth is also included in this project. The data was acquired from blah. The accompanying interactive visuals are intended to illustrate the similarities between the different microbial fingerprints. Click on the 3 visuals below to interact with them and explore the subway microbes!
On average the Orange line had the greatest abundance of pathogenic microbes. This can be seen in the 'MBTA Microbes' visual. The orange bubbles are on average larger than the green and red. The 'cleanest' line is the Green Line. The Green line has the smallest ridership numbers accourding to the MBTA Service and Infrastructure Profile. This may account for its lack of microbes. The ridership/microbe theory applies to the Red Line and Orange Line as well because the Orange Line has more riders than the Red Line.
The City with the most microbes is blah. The annual subway riders in blah city is blah. This does/does not fit the riderships/microbe trend.
 The high abundance of these microbes in human mouths could acount for their high abundance on the subway. The microbes could travel from riders mouths to their hands onto to the subway handles. Or the mouth microbes could be transferred when a rider coughs, sneezes etc.
Regardless of their presence on the subway, many microbes are constantly present in our mouths. Our immune systems keep us from constantly getting sick. In conclusion, although dangerous microbes are present on the subway they do not pose a huge threat to riders as long as the rider's have a healthy immune system. Practicing basic hygeine can also further protect riders from subway microbes. For example, after riding the subway riders can wash their hands.
These datasets were collected by different labs. Each lab used their own sequencing machine and data collection protocols. In addition I used my own protocl when converting the mouth samples to a usuable format. The dispartity in method across samples introduces some error. In an ideal world, all the data would have been collected and processed by the same lab using the same methods.
Furthermore, not all of the city datasets included what part of the subway car was sampled. For example, one sample could be taken from the subway handle, while another could be taken from the subway seat. When comparing the city datasets it is possible that different subway car locations are being compared across each city. Therefore some of the differences/similarities across cities could be due to the location of the sample and not the city itself. In my analysis, I assumed possible subway car location disparities were negligent. Again, in a perfect world all the samples would be taken from analagous subway car locations.
The Subway data samples were found at insertlink and insertlink. The human mouth microbiome was found at insertlink.
Not all the microbes were identified at the specied level. Some of them were only identified by phylum class or order. I had to filter the data for the most specific classification.
The raw fasta files were just lines of various permutations of "GCAT." In order to convert them to csv filed with microbe abundance I used a website called Cyverse. Cyverse allowed me to use an HPC remotely to compare the DNA strings to databases and generate the names and abundances of the bacteria.
When initially looking for 'stories' in the data I first did simple bar plots using Python. I plotted bacterial abundance in each sample to see which cities had the highest instances of certain bacteria. Then I started using bubble plots, and realized the information was more intuitively represented as bubbles. After finding variables to focus on I animated the plots using plotly.
I used Boostraps to quickly and efficiently create a website. I embeded each of my interactive visualizations into the website along with textual explanations. I used github pages to host the website for free.
Recent technological advancements have made it exponentially easier to profile microbial fingerprints. The Metasub Project is slowly but surely collecting the microbial fingerprints from subway cars around the world… but why do they care about this data?
It is a fact of life that there will be at least some harmful microbes in any environment. The point of collecting this data is not to show how dirty the world is or to discourage people from taking the subway. Similarly, the purpose of this project is not to show that Boston’s subways are dirty and should be cleaned more. As illustrated in the Subway vs Mouth visual, harmful microbes are living inside us already, but ultimately aren’t harmful. Instead, the point of this project is to show how microbial fingerprints reflect the lives of the city inhabitants. Any time someone passes through an area they leave a little bit of their microbial fingerprint behind to contribute to the greater "city microbial fingerprint." These microbes can answer questions about where citizens are from, where they are going, and how they interact with their city.
I suspect the increased microbial diversity in [insert city] is a product of the comparatively greater ridership numbers in that subway system. In other words, the more people who ride the subways, the more opportunities there are for new microbes to be introduced. Similarly, the Orange Line has many more riders than the Green Line, and also more microbes. I chose the cities Boston, Sacramento, and New York because they were readily available. However, as more data from the Metasub Project becomes available the data can be used to further analyze the ridership patterns of subways all over the world.
In addition, if microbial samples are taken from a certain subway system at different increments throughout the day/week, the microbial patterns can be used to track riders throughout different lines. I worked on a project with a similar concept to this last year. I used the microbial fingerprints of high school bathrooms and the doorknobs of different classrooms to track students around the school. I believe with enough datasets a similar setup can be used to also track people around a city.
In conclusion, the takeaway from this project is that no two subway microbial fingerprints are the same in the same way that no two subway cars have the same riders. Microbial fingerprint data have incredible potential to unlock information about the lives of the people represented in the fingerprint. I look forward to more microbial datasets becoming available and analyzed in depth. I am eager to play a part in discoveries from these types of data. This project has inspired me to pursue a “Northeastern Microbiome” project this summer. I am planning to sequence the microbial fingerprints of different areas around campus (eg: Snell Library Computers, Hurtig Hall doorknobs) to see what the microbial communities say about the habits of the Northeastern community.
“Team Effort” Creative Commons XKCD
Mia Kotalik - Website, Analysis, Visuals, and Ruggles Photography
♥ A special thanks to my brilliant roomate Hanieka Balint for creating custom Bostonian and New Yorker microbe clip art!
Hotz, Robert Lee. “Big Data and Bacteria: Mapping the New York Subway's DNA.” The Wall Street Journal, Dow Jones & Company, 5 Feb. 2015, www.wsj.com/articles/big-data-and-bacteria-mapping-the-new-york-subways-dna-1423159629.
Hsu, Tiffany, et al. “Urban Transit System Microbial Communities Differ by Surface Type and Interaction with Humans and the Environment.” MSystems, American Society for Microbiology Journals, 28 June 2016, msystems.asm.org/content/1/3/e00018-16.
MetaSUB. “Mapping the Urban Biome.” MetaSUB, Weill Cornell Medical College, 2019, metasub.org/.
Mia Kotalik - Website, Analysis, Visuals, and Ruggles Photography
♥ A special thanks to my brilliant roomate Hanieka Balint for creating custom Bostonian and New Yorker microbe clip art!
Hotz, Robert Lee. “Big Data and Bacteria: Mapping the New York Subway's DNA.” The Wall Street Journal, Dow Jones & Company, 5 Feb. 2015, www.wsj.com/articles/big-data-and-bacteria-mapping-the-new-york-subways-dna-1423159629.
Hsu, Tiffany, et al. “Urban Transit System Microbial Communities Differ by Surface Type and Interaction with Humans and the Environment.” MSystems, American Society for Microbiology Journals, 28 June 2016, msystems.asm.org/content/1/3/e00018-16.
MetaSUB. “Mapping the Urban Biome.” MetaSUB, Weill Cornell Medical College, 2019, metasub.org/.


- Source:
- Theatre.js, line 36
Classes
Methods
-
<static> define
-
Export the given name as the given object or as an empty Object if pObject is not given.
Parameters:
Name Type Description pName
string The name to define. pObject
Object The Object to define. pRoot
Object=global The root Object to define to. - Source:
- Theatre.js, line 76
Returns:
The defined object.- Type
- Object


There are new comments you might be interested in:
If you don't want to receive these messages, you can configure your preferences on your account page.


Etymap Story
Jump to the process book, directly to the demo (screencast) or to Github.
Words & etymologies interactive visualization
We all know that that some of our common used words, and even expressions take their origin in Latin or Ancient Greek, like 'Carpe diem' for example. Apart from showing how our languages and words were built, these etymological relationships can hide much more than you think. This might be common knowledge to linguists, or avid users of Wikitionnary Our main dataset Etymwn is actually built on Wikitionnary., but there is more to the words we use everyday. This is why we built an interactive visualization about etymology.
Before getting into these secrets, let's remind ourselves of the general setting. Our world has seen many languages come and go, and are widely distributed around our globe. The small visualization below will let you explore the languages we will be discussing here.
Now we are going to get a bit more specific. As mentioned in the introduction, we know that most European languages are heavily influenced by Latin. But are they actually all directly related to Latin? Which ones are not? The map below will show you exactly this. You'll quickly notice how practically none of the Asian languages are related to Latin. Already this information hints to the historical separation of these two regions, there is definitely more information to these words than their meaning!
Actually, the links on this map show both kinds of relationships - the languages which were influenced by Latin and those which influenced Latin.
The remaining part to explore are the etymological trees of words. These are all the words which are etymologically derived from a given word or the etymological origin of it. We've handpicked an interesting first one for you: the tomato! We know it doesn't seem like it, but just bear with us for a moment here. As you can see on the graph below, the word "tomato" in english is derived from the Spanish "tomate" which is itself derived from the Classical Nahuatl "tomatl". Classical Nahuatl is also known as Aztec. You'll also notice how 'tomatl' is the origin of practically every language's word for tomato and more importantly that the tree starts growing from the Spanish word "tomate". This is a clear effect of the Spanish colonization of the Americas, specifically the Spanish conquest of the Aztec during the 16th-century. You can learn more about the Spanish colonization on Wikipedia.
The information etymology hides is much greater then what appears at first sight. It's time for you to continue on your own or watch the screencast:
Inspiration & references
- Mledoze, Countries
- Gerard de Melo, Etymological Wordnet: Tracing the History of Words
- Glottolog, Languages coordinates
- SIL ISO 639-3, Macrolanguage mappings
- Yago-Naga, UWN / MENTA: Towards a Universal Multilingual Wordnet
- Dave Liepmann, Tufte CSS


Hello people,
I am totally new in the world of energy monitor stuff. Some time ago i stumbled upon a site where they sell hardware and some software to read out your smart meters. I was planning to buy hardware from this site but then i came across openenergy.org and the Emoncms implementation. This really caught my attention. I still intent to buy the hardware from that site but i am curious if it will work with the ssytems provided on this open energy project builds.
Please if somebody can advice:
Energy meters reader gas and electric from the P1 port with a P1-ETH V4 Converter Module (ETHERNET)
And for the water meter the S0 Pulse Counter Module (5 Poorten) (USB)
This website also provides software for the hardware.
So my questions are;
What kind of standards are used
Can you implement existing software to the open energy monitor
Link of the website: (in dutch)
http://www.smartmeterdashboard.nl/webshop
Best regards,
HJ
Re: Compatible hardware
It's very very easy!
When building this device and integrating it with open energy monitor I explored several options but my final recommendation is to just build a simple script that collects the info from your sensors via the included software and loads it into the emoncms feeds by querying the appropriate URL.. E.g. wget http://microhydroelectric.ca/emoncms/feed/update.json?id=0&value=100.0. To update the value for feed #0, don't forget to add your read/write key to the end though... More info under the feeds->API help page. On your emoncms dashboard.
If you need help writing a script let me know, I can help!
Jon


Provides functionality to interact with Google data APIs Subclasses exist to implement service-specific features
As the Google data API protocol is based upon the Atom Publishing Protocol (APP), Gdata functionality extends the appropriate Zend_Gdata_App classes
Located in /Gdata.php (line 44)
Zend_Gdata_App | --Zend_Gdata
| Class | Description |
|---|---|
| Zend_Gdata_Media | Service class for interacting with the services which use the media extensions |
| Zend_Gdata_Geo | Service class for interacting with the services which use the GeoRSS + GML extensions. |
| Zend_Gdata_Photos | Service class for interacting with the Google Photos Data API. |
| Zend_Gdata_Gbase | Service class for interacting with the Google Base data API |
| Zend_Gdata_Exif | Service class for interacting with the services which use the EXIF extensions |
| Zend_Gdata_Spreadsheets | Gdata Spreadsheets |
| Zend_Gdata_Health | Service class for interacting with the Google Health Data API |
| Zend_Gdata_Gapps | Service class for interacting with the Google Apps Provisioning API. |
| Zend_Gdata_DublinCore | Service class for interacting with the services which use the DublinCore extensions. |
| Zend_Gdata_Docs | Service class for interacting with the Google Document List data API |
| Zend_Gdata_Books | Service class for interacting with the Books service |
| Zend_Gdata_Calendar | Service class for interacting with the Google Calendar data API |
Namespaces used for Gdata data
Client object used to communicate in static context
Default URI to which to POST.
Client object used to communicate
Packages to search for classes when using magic __call method, in order.
Inherited from Zend_Gdata_App
Zend_Gdata_App::$_gzipEnabled
Zend_Gdata_App::$_httpMethodOverride
Zend_Gdata_App::$_majorProtocolVersion
Zend_Gdata_App::$_maxRedirects
Zend_Gdata_App::$_minorProtocolVersion
Zend_Gdata_App::$_useObjectMapping
Zend_Gdata_App::$_verboseExceptionMessages
Imports a feed located at $uri.
Create Gdata object
Retrieve entry as string or object
Retrieve feed as string or object
Determines whether service object is authenticated.
Performs a HTTP request using the specified method.
Overrides the definition in the parent (Zend_Gdata_App) and uses the Zend_Gdata_HttpClient functionality to filter the HTTP requests and responses.
Inherited From Zend_Gdata_App
Zend_Gdata_App::__construct()
Zend_Gdata_App::delete()
Zend_Gdata_App::enableRequestDebugLogging()
Zend_Gdata_App::generateIfMatchHeaderData()
Zend_Gdata_App::get()
Zend_Gdata_App::getEntry()
Zend_Gdata_App::getFeed()
Zend_Gdata_App::getGzipEnabled()
Zend_Gdata_App::getHttpClient()
Zend_Gdata_App::getHttpMethodOverride()
Zend_Gdata_App::getMajorProtocolVersion()
Zend_Gdata_App::getMaxRedirects()
Zend_Gdata_App::getMinorProtocolVersion()
Zend_Gdata_App::getNextFeed()
Zend_Gdata_App::getPreviousFeed()
Zend_Gdata_App::getStaticHttpClient()
Zend_Gdata_App::getVerboseExceptionMessages()
Zend_Gdata_App::import()
Zend_Gdata_App::importFile()
Zend_Gdata_App::importString()
Zend_Gdata_App::importUrl()
Zend_Gdata_App::insertEntry()
Zend_Gdata_App::performHttpRequest()
Zend_Gdata_App::post()
Zend_Gdata_App::prepareRequest()
Zend_Gdata_App::put()
Zend_Gdata_App::registerPackage()
Zend_Gdata_App::retrieveAllEntriesForFeed()
Zend_Gdata_App::setGzipEnabled()
Zend_Gdata_App::setHttpClient()
Zend_Gdata_App::setHttpMethodOverride()
Zend_Gdata_App::setMajorProtocolVersion()
Zend_Gdata_App::setMaxRedirects()
Zend_Gdata_App::setMinorProtocolVersion()
Zend_Gdata_App::setStaticHttpClient()
Zend_Gdata_App::setVerboseExceptionMessages()
Zend_Gdata_App::updateEntry()
Zend_Gdata_App::useObjectMapping()
Zend_Gdata_App::usingObjectMapping()
Zend_Gdata_App::__call()
Service name for use with Google's authentication mechanisms
Inherited from Zend_Gdata_App
Zend_Gdata_App::DEFAULT_MAJOR_PROTOCOL_VERSION
Zend_Gdata_App::DEFAULT_MINOR_PROTOCOL_VERSION
Documentation generated on Wed, 25 Aug 2010 03:43:54 +0400 by phpDocumentor 1.4.2


Feature Films
Short Films
Technology
Careers
Extras
About
Careers at Pixar
Soul Trailer
Inclusion and Outreach


Accessing Enriched Content using Link
You can access enriched content through the Manager Asset Fetch APIs, gnsdk_manager_asset_fetch2()
, or through the Link Module.
Enriched data includes:
Using the Link Module
You can use the Link Module to retrieve enriched content. Link requires the following define:
#define GNSDK_LINK 1
And making the following initializing API call with your SDK Manager handle:
gnsdk_link_initialize(sdkmgr_handle);
Before your program exits, it needs to make the following API call to release Link resources:
gnsdk_link_shutdown();
Retrieving Cover Art and Artist Images
To retrieve cover art or an artist image, you need an album or contributor GDO from media that has been identified using GNSDK recognition features. For example, you might have identified an album using a CD TOC or a text-based lookup, or you might have identified a contributor using a text-based lookup. For more information, see Identifying Music.
Once you have a GDO, you can use the Link APIs to retrieve enriched content immediately, or you can serialize the GDO and deserialize it later, when you are ready to retrieve content.
In general, to access enriched image content:
- Initialize the Manager, Music, and Link modules.
- Create a Link query.
- Set the GDO for the query.
- Set the desired image size.
- Retrieve the image, specifying the image type.
- When finished using the image, free the image.
Note: Images that are retrieved with an online query can be cached locally, depending on the lookup mode option, and whether caching has been enabled. For more information, see Setting Local and Online Lookup Modes and Using SQLite for Storage and Caching.
Use the following function to create a Link query:
gnsdk_link_query_create(user_handle, GNSDK_NULL, GNSDK_NULL, &query_handle);
In this example, the callback parameters have been set to GNSDK_NULL, but you can use them to provide a callback function that will give status updates for the query, if you wish.
Next, set the GDO for the query. The GDO should be one that you've retrieved using a GNSDK recognition feature:
gnsdk_link_query_set_gdo(query_handle, input_gdo);
Set the desired image size. For a list of available image sizes, see Image Formats and Dimensions.
gnsdk_link_query_option_set(query_handle, GNSDK_LINK_OPTION_KEY_IMAGE_SIZE, GNSDK_LINK_OPTION_VALUE_IMAGE_SIZE_170);
Finally, call the gnsdk_link_query_content_retrieve() function to retrieve the image. You must specify the type of image to retrieve, by using one of the following constants:
- gnsdk_link_content_cover_art for album cover art
- gnsdk_link_content_genre_art for genre art
- gnsdk_link_content_image_artist for an artist image
gnsdk_link_query_content_retrieve( query_handle, gnsdk_link_content_cover_art, 1, &data_type, &buffer, &buffer_size);
When finished using the image, free the image buffer:
gnsdk_link_query_content_free(buffer);
Retrieving Genre Art
Gracenote recommends retrieving and displaying genre art in the following cases:
- You've identified an album or contributor, but no cover art or artist image is found.
- You are not able to identify an album or contributor, but you are still able to identify the genre of the album or contributor.
Retrieving Genre Art with a GDO
If you've identified an album or contributor, but no cover art or artist image is found, you can retrieve genre art by using the identified GDO. Create a Link query, as described in Retrieving Cover Art and Artist Images, and set the image type to gnsdk_link_content_genre_art.
Retrieving Genre Art without a GDO
If you are not able to identify an album or contributor, you might still be able to identify the genre by using the ID3 tags of the MP3 file. Create a Link query, as described in Retrieving Cover Art and Artist Images, and set the image type to gnsdk_link_content_genre_art. However, instead of setting the GDO for the query, use the genre string to get the list element handle for the genre.
For example, use the following function to retrieve the list element handle:
gnsdk_manager_list_get_element_by_string(genre_list_handle, genre_string, &element_handle);
Then set the list element handle for the Link query:
gnsdk_link_query_set_list_element(query_handle, element_handle);
Setting Image Size Retrieval Order
You can specify an order in which GNSDK will retrieve image sizes, by setting the image size option multiple times. The first size that you set will be the first image size that GNSDK tries to retrieve. If an image of that size isn't found, the second size will be the next size that GNSDK tries to retrieve, and so on. For example, the following code calls the gnsdk_link_query_option_set() function three times, so that GNSDK will try to retrieve images in the following order: 300, 450, 170:
gnsdk_link_query_option_set(query_handle, GNSDK_LINK_OPTION_KEY_IMAGE_SIZE, GNSDK_LINK_OPTION_VALUE_IMAGE_SIZE_300); gnsdk_link_query_option_set(query_handle, GNSDK_LINK_OPTION_KEY_IMAGE_SIZE, GNSDK_LINK_OPTION_VALUE_IMAGE_SIZE_450); gnsdk_link_query_option_set(query_handle, GNSDK_LINK_OPTION_KEY_IMAGE_SIZE, GNSDK_LINK_OPTION_VALUE_IMAGE_SIZE_170);
The images sizes that you set will apply to the query handle for the life of the handle. If you want to retrieve images of a different size, you'll need to call the gnsdk_link_query_options_clear() function to clear the options on the handle. Then you can reset the image sizes before retrieving additional images.
Example: Accessing Album Cover Art
This example shows how to access album cover art. It does a text search and finds images based on gdo type (album or contributor). It also finds an image based on genre.


Quench-induced precipitation in 6005A after different cooling rates [ 128]: ( A) OM and ( B) SEM secondary electron micrographs of quench-induced β-Mg 2Si particles originating from the HTRs; ( C) TEM images of quench-induced rod-shaped B’ or β’ particles. In each case, the particle dimensions are substantially reduced with increasing cooling rate.


Alcatel 3V comes to Canada, now available at Freedom Mobile
The 3V starts at $0 with Freedom Mobile
by Jonathan LamontTCL announced that its Alcatel 3V (2019) smartphone is now available in Canada.
The China-based manufacturer first announced the Alcatel 3V earlier this month along with news that it would come to Freedom Mobile. However, the phone is now officially available.
The 3V sports a giant 6.7-inch 1440 x 720 pixel resolution HD+ 18:9 display, which takes up most of the front of the device. While there is a bit of a chin and forehead, it isn’t substantial by any means. Additionally, the 3V offers 3GB of RAM and 32GB of storage expandable up to an additional 32GB with a microSD card.
A MediaTek MT6762 2.0GHz octa-core processor powers the phone, and it has a 4,000mAh battery. Around back, the 3V includes a rear-mounted fingerprint scanner and a dual-camera setup. The first camera is a 16-megapixel shooter along with a second 5-megapixel camera. The front camera comes in at 8-megapixel.
Impressively, the 3V sports a 3.5mm headphone jack — a rare commodity in phones these days.
Customers interested in the Alcatel 3V will be able to pick one up with Freedom Mobile for $0 with a $5 per month MyTab charge. In other words, you’ll get a $5 per month charge tacked onto the plan of your choice that covers the cost of the phone. Alternatively, you can pay $120 upfront and get the device with no tab charge. Freedom says the MSRP of the 3V is $220.
At the time of writing, no other major Canadian carrier offered the Alcatel 3V.
You can learn more about the new phone here.


WITNESS LIST Licensing & Administrative Procedures Committee May 6, 1997-10:30A SB 332 For: Bill Dalrymple (TX Counseling Assoc) Registering, but not testifying: Against: Tom Milholland (Self) On: Caroline Scott (Dept. of Insurance) Douglas Beran (Board of Dental Exam.) SB 525 For: Bill Stinson (TAR) On: William Kuntz (TX Real Estate Cmn.) Registering, but not testifying: For: Ronald Walker (TAR) SB 1031 For: Marta Greytok (Singer Asset Financial) On: Ridgley Bennett (Lottery Commission) SB 1100 For: Bill Stinson (TAR) On: William Kuntz (TX Real Estate Cmn.) Registering, but not testifying: On: Jay Brummett (TX Real Estate Cmn.) SB 1190 On: Guy Joyner (Sec. of State) Registering, but not testifying: For: Karen Wood (Baylor University)


Director: {{ movie.director | capitalize }}
Release year: {{ movie.release_year }}
Gross income: {{ movie.gross_income }}
Genre: {{ item }}
Overview: {{ movie.overview }}
There aren't actors added to this movie. If you want to add one click here Add actor.


---
layout: page
title: CV
description: This is what I did.
background: '/img/bg-desk.jpg'
---
| 2019-Present |
PhD-TA candidate |
Eindhoven University of Technology |
|
For academic activities, see the Publications page. |
|
|
Supervised Master students: |
|
|
Dmitrii Orlov |
Static typing for SQL + Exploring the knowledge engineering pipeline |
|
Willem Aerts |
Using LLMs to generate SQL questions and answers |
|
Jeroen Besems |
SQL Misconceptions on Stack Overflow |
|
Leonardo Mathon |
Awareness of SQL anti-patterns for novices |
|
Alex Odynchuk |
Visual representations of SQL scoping errors |
|
Courses: |
|
|
Data modeling and Databases (BSc) |
Instructor: 2020, 2021, 2022, |
|
Data Analytics for Engineers (BSc) |
Supervisor: 2020, 2021, 2022, 2023 |
|
Knowledge Engineering (MSc) |
Course (re)design, lecturer: 2022, 2023 |


public interface SpectrumFile extends Comparable
| Modifier and Type | Method and Description |
|---|---|
int |
getCharge()
This method reports on the charge of the precursor ion.
|
String |
getFilename()
This method reports on the filename for the file.
|
double |
getHighestIntensity()
This method returns the intensity of the highest intensity peak in
this spectrum.
|
double |
getIntensity()
This method reports on the intensity of the precursor ion.
|
HashMap |
getPeaks()
This method reports on the peaks in the spectrum, with the
Doubles for the masses as keys in the HashMap, and the intensities
for each peak as Double value for that mass key.
|
double |
getPrecursorMZ()
This method reports on the precursor M/Z
|
double |
getTotalIntensity()
This method returns the total intensity contributed by all the ions
in this spectrum.
|
void |
setCharge(int aCharge)
This method sets the charge of the precursor ion.
|
void |
setFilename(String aFilename)
This method sets the filename for the file.
|
void |
setIntensity(double aIntensity)
This method sets the intensity of the precursor ion.
|
void |
setPeaks(HashMap aPeaks)
This method sets the peaks on the spectrum.
|
void |
setPrecursorMZ(double aPrecursorMZ)
This method sets the precursor M/Z on the file.
|
void |
writeToFile(File aParentDir)
This method allows the caller to write the spectrum file to the specified folder
using its current filename.
|
void |
writeToStream(OutputStream aOut)
This method allows to write the spectrum file to the specified OutputStream.
|
compareTo
int getCharge()
void setCharge(int aCharge)
aCharge
- int with the charge of the precursor ion.String getFilename()
void setFilename(String aFilename)
aFilename
- String with the filename for the file.HashMap getPeaks()
void setPeaks(HashMap aPeaks)
aPeaks
- HashMap with Doubles as keys (the masses) and Doubles as values (the intensities).double getPrecursorMZ()
void setPrecursorMZ(double aPrecursorMZ)
aPrecursorMZ
- double with the precursor M/Zdouble getIntensity()
void setIntensity(double aIntensity)
aIntensity
- double with the intensity of the precursor ion.double getTotalIntensity()
double getHighestIntensity()
void writeToStream(OutputStream aOut) throws IOException
aOut
- OutputStream to write the file to. This Stream
will NOT be closed by this method.IOException
- when the write operation fails.void writeToFile(File aParentDir) throws IOException
aParentDir
- File with the parent directory to put the file in.IOException
- whenever the write process failed.Copyright © 2020. All rights reserved.


--- layout: post title: Two conference papers accepted tags: - News - Research ---
Our papers The Importance of Balanced Data Sets: Analyzing a Vehicle Trajectory Prediction Model based on Neural Networks and Distributed Representations and Analyzing the Capacity of Distributed Vector Representations to Encode Spatial Information were accepted at the IEEE International Joint Conference on Neural Networks (IJCNN), which will be held as part of the IEEE World Congress on Computational Intelligence (IEEE WCCI) in Glasgow.


FIFA 20 gets South America's Copa Libertadores exclusively in March 2020
Good gol.
by Wesley Yin-PooleFIFA 20 will get the Copa Libertadores tournament exclusively in March 2020, EA Sports has announced.
South America's biggest club tournament hits the game as part of a free update that also includes the Sudamericana and Recopa. The update is for the PC, PlayStation 4 and Xbox One versions of the game. EA's note to press does not mention the Switch version, which will come as no surprise to FIFA fans who play on Nintendo's console.
The update adds a host of new clubs from Uruguay, Perú, Paraguay, Ecuador, Brazil, Argentina and more, such as River Plate, Boca Juniors, Flamengo, Corinthians, Racing, Indepentiente U. Católica and Colo-Colo.
It's worth picking out Argentinian arch rivals River Plate and Boca Juniors, which are mentioned by EA as a teams coming to FIFA 20 in the update. These teams are not officially licensed currently in FIFA 20, although they are in the game under unlicensed names (Núñez and Buenos Aires). With the update, FIFA 20 will be able to authentically recreate the dramatic Copa Libertadores final of 2018, which saw its return leg played at the Santiago Bernabeu Stadium in Madrid, Spain, due to a lack of security in Buenos Aires.


#import <NTMapView.h>
Inherits GLKView.
Class Methods | |
| (BOOL) | + registerLicense: |
MapView is a view class supporting map rendering and interaction.
| - (void) cancelAllTasks |
Cancels all qued tasks such as tile and vector data fetches. Tasks that have already started may continue until they finish. Tasks that are added after this method call are not affected.
| - (void) clearAllCaches |
Releases memory occupied by all caches. Calling this means that everything has to be fetched again, including the visible area.
| - (void) clearPreloadingCaches |
Releases the memory occupied by the preloading area. Calling this method releases some memory if preloading is enabled, but means that the area right outside the visible area has to be fetched again.
| - (NTMapPos *) getFocusPos |
Returns the position that the camera is currently looking at.
| - (NTLayers *) getLayers |
Returns the Layers object, that can be used for adding and removing map layers.
| - (NTMapEventListener *) getMapEventListener |
Returns the map event listener. May be null.
| - (NTMapRenderer *) getMapRenderer |
Returns the MapRenderer object, that can be used to control rendering options.
| - (NTOptions *) getOptions |
Returns the Options object, that can be used for modifying various map options.
| - (float) getRotation |
Returns the map rotation in degrees. 0 means looking north, 90 means west, -90 means east and 180 means south.
| - (float) getTilt |
Returns the tilt angle in degrees. 0 means looking directly at the horizon, 90 means looking directly down.
| - (float) getZoom |
Returns the zoom level. The value returned is never negative, 0 means absolutely zoomed out and all other values describe some level of zoom.
| - (NTScreenPos *) mapToScreen: | (NTMapPos*) | mapPos |
Calculates the screen position corresponding to a map position in base projection coordinate system, using the current view parameters.
| mapPos | The map position in base projection coordinate system. |
| - (void) moveToFitBounds: | (NTMapBounds*) | mapBounds | |
| screenBounds: | (NTScreenBounds*) | screenBounds | |
| integerZoom: | (BOOL) | integerZoom | |
| durationSeconds: | (float) | durationSeconds | |
Animate the view parameters (focus position, tilt, rotation, zoom) so that the specified bounding box becomes fully visible. This method does not work before the screen size is set.
| mapBounds | The bounding box on the map to be made visible in the base projection's coordinate system. |
| screenBounds | The screen bounding box where to fit the map bounding box. |
| integerZoom | If true, then closest integer zoom level will be used. If false, exact fractional zoom level will be used. |
| durationSeconds | The duration in which the operation will be completed in seconds. |
| - (void) moveToFitBounds: | (NTMapBounds*) | mapBounds | |
| screenBounds: | (NTScreenBounds*) | screenBounds | |
| integerZoom: | (BOOL) | integerZoom | |
| resetRotation: | (BOOL) | resetRotation | |
| resetTilt: | (BOOL) | resetTilt | |
| durationSeconds: | (float) | durationSeconds | |
Animate the view parameters (focus position, tilt, rotation, zoom) so that the specified bounding box becomes fully visible. Also supports resetting the tilt and rotation angles over the course of the animation. This method does not work before the screen size is set.
| mapBounds | The bounding box on the map to be made visible in the base projection's coordinate system. |
| screenBounds | The screen bounding box where to fit the map bounding box. |
| integerZoom | If true, then closest integer zoom level will be used. If false, exact fractional zoom level will be used. |
| resetTilt | If true, view will be untilted. If false, current tilt will be kept. |
| resetRotation | If true, rotation will be reset. If false, current rotation will be kept. |
| durationSeconds | The duration in which the operation will be completed in seconds. |
| - (void) pan: | (NTMapVec*) | deltaPos | |
| durationSeconds: | (float) | durationSeconds | |
Pans the view relative to the current focus position. The deltaPos vector is expected to be in the coordinate system of the base projection. The new calculated focus position will be clamped to the world bounds and to the bounds set by Options::setPanBounds.
If durationSeconds > 0 the panning operation will be animated over time. If the previous panning animation has not finished by the time this method is called, it will be stopped.
| deltaPos | The coordinate difference the map should be moved by. |
| durationSeconds | The duration in which the tilting operation will be completed in seconds. |
| + (BOOL) registerLicense: | (NSString*) | licenseKey |
Registers the SDK license. This is class method and must be called before
creating any actual MapView instances.
| licenseKey | The license string provided for this application. |
| - (void) rotate: | (float) | deltaAngle | |
| durationSeconds: | (float) | durationSeconds | |
Rotates the view relative to the current rotation value. Positive values rotate clockwise, negative values counterclockwise. The new calculated rotation value will be wrapped to the range of (-180 .. 180]. Rotations are ignored if Options::setRotatable is set to false.
If durationSeconds > 0 the rotating operation will be animated over time. If the previous rotating animation has not finished by the time this method is called, it will be stopped.
| deltaAngle | The delta angle value in degrees. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |
| - (void) rotate: | (float) | deltaAngle | |
| targetPos: | (NTMapPos*) | targetPos | |
| durationSeconds: | (float) | durationSeconds | |
Rotates the view relative to the current rotation value. Positive values rotate clockwise, negative values counterclockwise. The new calculated rotation value will be wrapped to the range of (-180 .. 180]. Rotations are ignored if Options::setRotatable is set to false.
Rotating is done around the specified target position, keeping it at the same location on the screen.
If durationSeconds > 0 the rotating operation will be animated over time. If the previous rotating animation has not finished by the time this method is called, it will be stopped.
| deltaAngle | The delta angle value in degrees. |
| targetPos | The zooming target position in the coordinate system of the base projection. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |
| - (NTMapPos *) screenToMap: | (NTScreenPos*) | screenPos |
Calculates the map position in base projection coordinate system corresponding to a screen position, using the current view parameters.
| screenPos | The screen position. |
| - (void) setFocusPos: | (NTMapPos*) | pos | |
| durationSeconds: | (float) | durationSeconds | |
Sets the new absolute focus position. The new focus position is expected to be in the coordinate system of the base projection. The new focus position will be clamped to the world bounds and to the bounds set by Options::setPanBounds.
If durationSeconds > 0 the panning operation will be animated over time. If the previous panning animation has not finished by the time this method is called, it will be stopped.
| pos | The new focus point position in base coordinate system. |
| durationSeconds | The duration in which the tilting operation will be completed in seconds. |
| - (void) setMapEventListener: | (NTMapEventListener*) | mapEventListener |
Sets the map event listener. If a null pointer is passed no map events will be generated. The default is null.
| mapEventListener | The new map event listener. |
| - (void) setRotation: | (float) | angle | |
| durationSeconds: | (float) | durationSeconds | |
Sets the new absolute rotation value. 0 means look north, 90 means west, -90 means east and 180 means south. The rotation value will be wrapped to the range of (-180 .. 180]. Rotations are ignored if Options::setRotatable is set to false.
If durationSeconds > 0 the rotating operation will be animated over time. If the previous rotating animation has not finished by the time this method is called, it will be stopped.
| angle | The new absolute rotation angle value in degrees. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |
| - (void) setRotation: | (float) | angle | |
| targetPos: | (NTMapPos*) | targetPos | |
| durationSeconds: | (float) | durationSeconds | |
Sets the new absolute rotation value. 0 means look north, 90 means west, -90 means east and 180 means south. The rotation value will be wrapped to the range of (-180 .. 180]. Rotations are ignored if Options::setRotatable is set to false.
Rotating is done around the specified target position, keeping it at the same location on the screen.
If durationSeconds > 0 the rotating operation will be animated over time. If the previous rotating animation has not finished by the time this method is called, it will be stopped.
| angle | The new absolute rotation angle value in degrees. |
| targetPos | The zooming target position in the coordinate system of the base projection. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |
| - (void) setTilt: | (float) | tilt | |
| durationSeconds: | (float) | durationSeconds | |
Sets the new absolute tilt value. 0 means look directly at the horizon, 90 means look directly down. The minimum tilt angle is 30 degrees and the maximum is 90 degrees. The tilt value can be further constrained by the Options::setTiltRange method. Values exceeding these ranges will be clamped.
If durationSeconds > 0 the tilting operation will be animated over time. If the previous tilting animation has not finished by the time this method is called, it will be stopped.
| tilt | The new absolute tilt value in degrees. |
| durationSeconds | The duration in which the tilting operation will be completed in seconds. |
| - (void) setZoom: | (float) | zoom | |
| durationSeconds: | (float) | durationSeconds | |
Sets the new absolute zoom value. The minimum zoom value is 0, which means absolutely zoomed out and the maximum zoom value is 24. The zoom value can be further constrained by the Options::setZoomRange method. Values exceeding these ranges will be clamped.
If durationSeconds > 0 the zooming operation will be animated over time. If the previous zooming animation has not finished by the time this method is called, it will be stopped.
| zoom | The new absolute zoom value. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |
| - (void) setZoom: | (float) | zoom | |
| targetPos: | (NTMapPos*) | targetPos | |
| durationSeconds: | (float) | durationSeconds | |
Sets the new absolute zoom value. The minimum zoom value is 0, which means absolutely zoomed out and the maximum zoom value is 24. The zoom value can be further constrained by the Options::setZoomRange method. Values exceeding these ranges will be clamped.
Zooming is done towards the specified target position, keeping it at the same location on the screen.
If durationSeconds > 0, the zooming operation will be animated over time. If the previous zooming animation has not finished by the time this method is called, it will be stopped.
| zoom | The new absolute zoom value. |
| targetPos | The zooming target position in the coordinate system of the base projection. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |
| - (void) tilt: | (float) | deltaTilt | |
| durationSeconds: | (float) | durationSeconds | |
Tilts the view relative to the current tilt value. Positive values tilt the view down towards the map, negative values tilt the view up towards the horizon. The new calculated tilt value will be clamped to the range of [30 .. 90] and to the range set by Options::setZoomRange.
If durationSeconds > 0 the tilting operation will be animated over time. If the previous tilting animation has not finished by the time this method is called, it will be stopped.
| deltaTilt | The number of degrees the camera should be tilted by. |
| durationSeconds | The duration in which the tilting operation will be completed in seconds. |
| - (void) zoom: | (float) | deltaZoom | |
| durationSeconds: | (float) | durationSeconds | |
Zooms the view relative to the current zoom value. Positive values zoom in, negative values zoom out. The new calculated zoom value will be clamped to the range of [0 .. 24] and to the range set by Options::setZoomRange.
If durationSeconds > 0 the zooming operation will be animated over time. If the previous zooming animation has not finished by the time this method is called, it will be stopped.
| deltaZoom | The delta zoom value. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |
| - (void) zoom: | (float) | deltaZoom | |
| targetPos: | (NTMapPos*) | targetPos | |
| durationSeconds: | (float) | durationSeconds | |
Zooms the view relative to the current zoom value. Positive values zoom in, negative values zoom out. The new calculated zoom value will be clamped to the range of [0 .. 24] and to the range set by Options::setZoomRange.
Zooming is done towards the specified target position, keeping it at the same location on the screen.
If durationSeconds > 0 the zooming operation will be animated over time. If the previous zooming animation has not finished by the time this method is called, it will be stopped.
| deltaZoom | The delta zoom value. |
| targetPos | The zooming target position in the coordinate system of the base projection. |
| durationSeconds | The duration in which the zooming operation will be completed in seconds. |


GoodBooks
Userpage
Signup
Login
Logout
menu
textsms
Search user
Go
Follow
Following
Favourite book
Add your favourite book
Add
Favourite books
More on GoodReads
Second Line
grade
Recommended books


| I l@ve RuBoard |
The use of Microsoft messaging products is becoming quite common in larger organizations. The Microsoft Exchange Server is often used at the backend, and various versions of Microsoft Exchange or Microsoft Outlook may be used as the client.
One key feature of Microsoft Exchange is that it exposes a rich and powerful API developers can use to extend their applications. Tasks such as form processing, or processing appointments or contact lists, can all be accessed from a COM interface. Although we will only discuss sending a simple message using Microsoft Exchange, you should peruse the documentation supplied with Exchange to get a feel for its capabilities.
Collaboration Data Objects (CDO) is a general-purpose COM automation interface for working with Microsoft Exchange. Because CDO is an automation interface, it's suitable for use with scripting languages, such as Visual Basic, JavaScript, and of course, Python.
CDO has gone through various name changes over its long life. Its evolution can be traced through "Simple MAPI," a set of APIs for Visual Basic 1, through a more general-purpose Visual Basic Extension (VBX), then into a general-purpose COM interface known as Active Messaging, and finally receiving even more features and being renamed CDO.
It provides a rich object model; there are objects for messages, folders, users, distribution lists, etc. The object model is "rooted" from a MAPI session object. The session object identifies the mailbox and provides a list of subfolders, each of which has its own list of messages and subfolders.
First, let's experiment with MAPI from a Python prompt. Create a MAPI session using the standard COM technique:
>>> from win32com.client import Dispatch >>> s=Dispatch("Mapi.Session") >>>
Then log on to the MAPI session. This presents a dialog box to authenticate the session:
>>> s.Logon() >>>
By consulting the documentation for the MAPI session object, you can see there is an Inbox property, which is a Folder object. You can see how many messages this folder contains:
>>> len(s.Inbox.Messages) 304
And look at the first one:
>>> s.Inbox.Messages.Item(1).Subject 'Free WinZip Self-Extractor 2.1 Upgrade'
The procedure to send an email with CDO is simple; create a new message in the outbox, set the message's properties, and send it. Let's do this interactively using the session object created previously. First, create a new message in the outbox using the Add() method. The CDO documentation states that this takes two parameters: the subject of the message and the text of the message:
>>> newMsg = s.Outbox.Messages.Add("Hi from Python", "Hello") >>>
Now add a single recipient using the message's Recipients property. The Recipients.Add() method takes two parameters: the display name of the recipient and the email address. Note that the email address must be prefixed with the Exchange Transport to be used; in this case, use the SMTP transport for Internet email addresses:
>>> recip = newMsg.Recipients.Add("Mark Hammond"<EMAIL_ADDRESS>>>>
And send the message:
>>> newMsg.Send() >>>
Now the message is sitting in the outbox, waiting to be delivered. Depending on the local configuration options, it may be some time before the next scheduled connection for delivery and receipt of mail. You can force this by calling the DeliverNow() method on the session:
>>> s.DeliverNow() >>>
Now that we have sent out message using Microsoft Exchange, let's write a few lines to read the message back. Depending on the speed of your email server and the route the email takes before getting back, it may take some time for the mail to be returned. At any time you can force the client to connect to the server to check for new messages by calling the DeliverNow() method.
The first thing to do is print the subject of the last message in the inbox:
>>> print s.Inbox.Messages[len(s.Inbox.Messages)].Subject Hi from Python >>>
Another demonstration would be to loop over all messages in the inbox, find the test message sent previously, and delete it. CDO provides special methods for iterating over all messages, in either a forward or reverse direction. You could even allow CDO to perform additional filtering of the message, but for now, try it for yourself.
The methods we will use for iterating are GetFirst() and GetNext() . These are methods of a Messages collection, so the first thing to do is save the Messages collection to a local variable:
>>> messages = s.Inbox.Messages
You can then write a loop checking each message, and when you find one to delete, call the Delete() method on the message. Here's the code:
>>> msg = messages.GetFirst() >>> while msg is not None: ... if msg.Subject == "Hi from Python": ... print "Deleting msg from", msg.Sender.Name ... msg.Delete() ... msg = messages.GetNext() ... Deleting msg from Mark Hammond >>>
As you can see, the code found and deleted exactly one message. CDO exposes a rich object model for folders and messages; every property imaginable about a message can be obtained. See the CDO documentation for more details.
| I l@ve RuBoard |


|
GPGPU-Sim
|
#include <event_router.hpp>
Classes | |
| struct | tWaiting |
Public Types | |
| enum | eNextVCState { idle, busy, tail_pending } |
Public Member Functions | |
| EventNextVCState (const Configuration &config, Module *parent, const string &name) | |
| eNextVCState | GetState (int vc) const |
| int | GetPresence (int vc) const |
| int | GetCredits (int vc) const |
| int | GetInput (int vc) const |
| int | GetInputVC (int vc) const |
| bool | IsWaiting (int vc) const |
| bool | IsInputWaiting (int vc, int w_input, int w_vc) const |
| void | PushWaiting (int vc, tWaiting *w) |
| void | IncrWaiting (int vc, int w_input, int w_vc) |
| tWaiting * | PopWaiting (int vc) |
| void | SetState (int vc, eNextVCState state) |
| void | SetCredits (int vc, int value) |
| void | SetPresence (int vc, int value) |
| void | SetInput (int vc, int input) |
| void | SetInputVC (int vc, int in_vc) |
| Public Member Functions inherited from Module | |
| Module (Module *parent, const string &name) | |
| virtual | ~Module () |
| const string & | Name () const |
| const string & | FullName () const |
| void | DisplayHierarchy (int level=0, ostream &os=cout) const |
| void | Error (const string &msg) const |
| void | Debug (const string &msg) const |
| virtual void | Display (ostream &os=cout) const |
Private Attributes | |
| int | _buf_size |
| int | _vcs |
| vector< int > | _credits |
| vector< int > | _presence |
| vector< int > | _input |
| vector< int > | _inputVC |
| vector< list< tWaiting * > > | _waiting |
| vector< eNextVCState > | _state |
Additional Inherited Members | |
| Protected Member Functions inherited from Module | |
| void | _AddChild (Module *child) |
Definition at line 44 of file event_router.hpp.
| Enumerator | |
|---|---|
| idle | |
| busy | |
| tail_pending |
Definition at line 46 of file event_router.hpp.
| EventNextVCState::EventNextVCState | ( | const Configuration & | config, |
| Module * | parent, | ||
| const string & | name | ||
| ) |
Definition at line 750 of file event_router.cpp.
Definition at line 777 of file event_router.cpp.
Definition at line 783 of file event_router.cpp.
Definition at line 789 of file event_router.cpp.
Definition at line 771 of file event_router.cpp.
| EventNextVCState::eNextVCState EventNextVCState::GetState | ( | int | vc | ) | const |
Definition at line 765 of file event_router.cpp.
Definition at line 813 of file event_router.cpp.
Definition at line 830 of file event_router.cpp.
| bool EventNextVCState::IsWaiting | ( | int | vc | ) | const |
Definition at line 795 of file event_router.cpp.
| EventNextVCState::tWaiting * EventNextVCState::PopWaiting | ( | int | vc | ) |
Definition at line 850 of file event_router.cpp.
Definition at line 801 of file event_router.cpp.
Definition at line 868 of file event_router.cpp.
Definition at line 880 of file event_router.cpp.
Definition at line 886 of file event_router.cpp.
Definition at line 874 of file event_router.cpp.
| void EventNextVCState::SetState | ( | int | vc, |
| eNextVCState | state | ||
| ) |
Definition at line 862 of file event_router.cpp.
|
private |
Definition at line 57 of file event_router.hpp.
|
private |
Definition at line 60 of file event_router.hpp.
|
private |
Definition at line 62 of file event_router.hpp.
|
private |
Definition at line 63 of file event_router.hpp.
|
private |
Definition at line 61 of file event_router.hpp.
|
private |
Definition at line 67 of file event_router.hpp.
|
private |
Definition at line 58 of file event_router.hpp.
|
private |
Definition at line 65 of file event_router.hpp.


New Page: {{page}} / {{numPages}} id Measurements {{measurement.ID}} Filter type File OID Condition File Name Enable alias Enable Disable OID Condition type Equal than Less than Greater than Greater equal than Less or equal than Match string Not Match String Value Description Submit Reset Cancel id Measurements {{measurement.ID}} Filter type" File OID Condition File Name Enable alias Enable Disable OID Condition type Equal than Less than Greater than Greater equal than Less or equal than Match String Not Match String Value Description Submit Reset Cancel
Page: {{page}} / {{numPages}}


Source code for selenium_page.page
from collections import namedtuple, OrderedDict
from .utils import unique_key_generator, chunks, make_valid_field_names
[docs]class BasePage(object):
"""Base class to init the base selenium_page will be called from all pages
Attributes:
driver (:class:`selenium.webdriver`): browser instance
"""
def __init__(self, driver):
self.driver = driver
self.main_window_handle = driver.current_window_handle
[docs] @staticmethod
def get_element_next_sibling(element):
"""
Helper function to return the next sibling from element
Args:
element: A web element
Returns:
element: Sibling element
"""
sibling = element.find_element_by_xpath('following-sibling::*[1]')
return sibling
def _change_window(self):
"""Selects the other window, assuming only two handles are present.
Raises:
AssertionError: When more than 2 handles are present
"""
driver = self.driver
current_window_handle = driver.current_window_handle
handles = driver.window_handles
assert len(handles) == 2, (
'Expected two handles found {}, '
'unable to determine note pop-up'.format(
len(handles)
)
)
for handle in handles:
if handle != current_window_handle:
driver.switch_to_window(handle)
def _select_main_window(self):
"""Selects the main window
"""
self.driver.switch_to.window(self.main_window_handle)
[docs]class BaseResultsPage(BasePage):
"""
Base class for single table results pages like Invoices, Matters, etc.
If only one data element is found in the table_data, row_objects will empty.
Attributes:
table_data (list(elements)): A list of data elements
table_headers (list(elements)): A list of table header elements
data_name (str): Name for the container class
key_field_index (int): Index of the field to use as the container instance's key.
Note: The objects will exist in the class instance's 'row_objects' attribute.
row_objects (:class:`OrderedDict` of :class:`namedtuple`): An ordered dictionary of results objects
as namedtuples. The key_field_index will be used to generate key names. If a key is duplicated,
for example multiple invoice results with the same invoice number, a postfix counting the occurrences will
be inserted by a :func:`unique_key_generator` so each result row maintains a unique key.
"""
table_body = None
table_data = None
table_headers = None
data_name = 'Container'
key_field_index = 0
def __init__(self, driver):
super().__init__(driver)
self.row_objects = self._get_row_objects()
def _build_data_container(self):
names = [h.text for h in self.table_headers]
field_names = make_valid_field_names(names)
return namedtuple(self.data_name, field_names)
def _get_row_objects(self):
container = self._build_data_container()
row_dict = OrderedDict()
# It isn't enough to use rows, because some results pages split a single
# object's data across multiple rows. Chunking is more reliable.
generator = chunks(self.table_data, len(container._fields))
# create a co-routine instance that checks our row_dict
unique_key_coroutine = unique_key_generator(row_dict)
for data_set in generator:
data_count, field_count = len(data_set), len(container._fields)
# Handle 1 returned element, which indicates no results
if data_count == 1:
return row_dict
# If we have results, make sure the headers and data match
assert data_count == field_count, (
'{} data elements found in a set but {} object has {} fields'.format(
data_count, container, field_count
)
)
container_obj = container(*data_set)
key_text = container_obj[self.key_field_index].text
# Insure a unique key
key = unique_key_coroutine.send(key_text)
row_dict[key] = container_obj
return row_dict


--- layout: page title: Portraits of Medieval Eastern Europe ---
Portraits of Medieval Eastern Europe provides imagined biographies of twenty different figures from all walks of life living in Eastern Europe from 900 to 1400. Moving beyond the usual boundaries of speculative history, the book presents innovative and creative interpretations of the people, places, and events of medieval Eastern Europe and provides an insight into medieval life from Scandinavia to Byzantium.
Each chapter explores a different figure and together they present snapshots of life across a wide range of different social backgrounds. Among the figures are both imagined and historical characters, including the Byzantine Princess Anna Porphyrogenita, a Jewish traveller, a slave, the Mongol general Sübodei, a woman from Novgorod, and a Rus' pilgrim. A range of different narrative styles are also used throughout the book, from omniscient third-person narrators to diary entries, letters, and travel accounts.
By using primary sources to construct the lives of, and give a voice to, the types of people who existed within medieval European history, Portraits of Medieval Eastern Europe provides a highly accessible introduction to the period. Accompanied by a new and interactive companion website, it is the perfect teaching aid to support and excite students of medieval Eastern Europe.
Balancing on an intricate edge between facts and fiction, this thoughtfully edited volume offers an excellent selection of 'real' and 'imaginary' biographies of individuals, from slaves to kings, who populated the eastern half of Europe in the centuries before and after the first Millennium. The expert authors provide a refreshing and instructive read to students of history and to anyone who has roots in this region or wishes to broaden her mental horizon.
Katalin Szende, Central European University, Budapest


%@page import="daoObjects.Employee"%> <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
| Date Submitted | Event Name | Work Time Missed | Justification | Projected Amount | Status | Amount Awarded |
|---|---|---|---|---|---|---|
| {{reimbursement.dateSubmitted}} | {{reimbursement.workTimeMissed}} | {{reimbursement.justification}} | {{reimbursement.projectedAmount | currency}} | {{reimbursement.reimbursementStatus}} | {{reimbursement.amountAwarded | currency}} |


Our mission is to help borrowers to become budgeters and budgeters become savers.
Wherever you are on this journey we may be able to help you. You can make an appointment to see one of our mentors, or you can use the self-help tools in this website, just signup.
Being in control of your money is most often about having a good understanding of your income and expenses, while making provision for the unexpected moments in life when an unplanned event happens for which you need money, or for the expenses that occur less frequently. Most people not only need a budget, but also a cash flow view for a year.
There are many ways our mentors may be able to help you:
- Preparing budgets and cash flow forecast.
- Advice on debt consolidation and debt repayment relief.
- Finding allowances and/or benefits you may not be aware are available.
- Assisting with hardship applications.


Learn more about the creation (powerpoint) here and see the Github repository for changelogs here
We are a non-profit...
As a non-profit, we dedicate a lot of our own time maintaining this website and helping those who are unemployed. Please donate now to help support us here: Donate
Please share
So how would you rate us? Please leave a review on...


CouchDB
Erlang / Elixir library for Apache CouchDB or IBM Cloudant. CouchDB provides you a full featured and easy-to-use client to access and manage multiple nodes.
Prerequisites
- Working C/C++ compiler in environment
Rebar3 or Mix
Usage
Most of the Erlang/Elixir CouchDB API takes Database or Server record as an argument. This record contains information about the
server's FQDN, the database name, etc. Parts of the API dealing with 'the server' will take a server record
, while functions
performing actions on databases and documents take a database record
. Consider:
erlang
{ok, Server} = couchdb:server_record(<<"http://localhost:5984">>, []).
elixir
{:ok, server} = :couchdb.server_record("http://localhost:5984", [])
After a server or database record has been created one can now make the first actual call:
erlang
{ok, Info} = couchdb_server:info(Server).
elixir
{:ok, info} = :couchdb_server.info(server)
Contribute
For issues, comments or feedback please create an issue.
Notes
V2.1.0 JSON library is now Jiffy
Version 2.1.0 switched to Jiffy as the JSON library. This fixes a bug with strings containing UTF-8 characters. Furthermore it improves performance and brings this CouchDB client closer to Apache CouchDB itself as it uses Jiffy too.
It should be noted that this change means a prerequisite is now introduced, the target environment must have a working C/C++ compiler.
Forked from Couchbeam
CouchDB is a a fork of couchbeam
Semantic versioning
To comply with Semantic Versioning the version number has been bumped to 2.0.0
.
New uuid implementation
In Beta6 the original Apache CouchDB uuid implementation was added.