Background: I usually only use weed and pills for recreation; however, I am a study Chemical Engineer and have become very interested in the interworkings of harder drugs. It began as a search on LSD to learn where it comes from and how it is extracted. This led me to this website where I began to read about morning glory seeds and became fascinated with the Lysergic acid alkaloids contained in them and their chemical relation to LSD.
Experiment 1: I ground up approximately 300 Heavenly Blue Morning Glory (containing approximately 300 ug of LSA) seeds to a rough power, and ingested them with bottled spring water to wash away the taste. Having read that chlorinated tap water would destroy the LSA compounds if come in to contact with them I did not drink my tap which has a lot of chlorine it. I decided not to eat anything while dosing or after dosing and having not eaten anything that day I had a completely empty stomach. I dosed at about 7:00 pm. For the first hour I felt nothing aside from some anxiety for whatever was going to happen to me.
At about 8:00 pm about 1 hour after dosing I began to watch a nature presentation on PBS about the falling lakes of Croatia. I found the early effects to be intense relaxation, sensitivity to light and sound which caused some annoyance, mostly in people trying to talk to me too much, and a profound sense of euphoria like I was being calmed by some force and that I loved my life, I also noticed some pupil dilation. In watching the program I noticed the pictures of the mountains and the lakes to be very real like I was there seeing them. This made me think about nature and how beautiful it is and the universe and life. I remembered feeling some nausea and indigestion however this was calmed by some pretty well concentrated chamomile tea.
At 9:00 pm the program ended and I felt like going up to bed to listen to music and such, but my friend wasn’t tired so we started watching a movie together. My friend had not taken anything. It was called “The Clearing” and I found it very difficult to follow the plot and kept trying to predict what was going to happen next thinking that some characters had complexities that weren’t there or that the were hiding something. Sometimes it seemed like they were overacting so it seemed kind of fake but this was easily ignorable.
At about 10:00 pm I decided to go up to my room giving up on the movie. I put on Bob Marley on my sound system and lied down. It was amazing it was as if I could hear every instrument playing alone and together simultaneously. I listened to the entire CD and decided to play a video gaming, feeling kind of antsy but still euphoric I would space out a lot I started playing GTA and I noticed that I kept going around killing people with my bare hands then I got in the car and kept running them down eventually the cop level would get really high they’d kill me and I’d come back.
I noticed I was distracted by the seeming reality of the fake sunflowers on the desk next to me but I could ignore it. I stopped play the game around 12:00am when I started to trip pretty hard I listened to more music like Bob Dylan something I had been wanting to do because I wanted to see if I could understand some of the more complex metaphors and poetry while on lysergic acid, but I couldn’t even begin to understand them though I found the sound of his harmonica calming and vivid.
After listening to about a whole CD of him I began looking through my huge botany book with photos of flowers and they looked more intense than ever, as if I was watching a close-up of them in High Definition. When staring at them I could imagine and to some extent make them sway in the wind. I had to go to the bathroom, peeing was like an orgasmic experience. After looking myself over in the mirror I resolved to get a better diet and to exercise as my physical appearance was starting to deteriorate. I then began staring at the bathroom shag rug and squeezing it with my toes I became fascinated with how it seemed to flow and bubble and I did this for like a half hour. I spaced out a lot during this trip, just staring at things or at nothing and thinking. The euphoria was still with me.
I decided to turn on the TV at about 1:00 am everything I was watching was very bright and intense (it being hard to grasp the dialog and the plot). I decided to put on a DVD. And ironically enough I decided to put on Fear and Loathing in Las Vegas (a favorite). After watching the opening replay behind the main menu of hands using an ink pen to write out the title I became fascinated and frightened by the things I saw and the sounds that were playing. I really understood everything Hunter S Thompson (Johnny Depp) was saying in the movie. I felt kindred to him as if I was feeling all of the things that he was talking about in the movie and like I knew how he felt, which I guess I did because we were both tripping on lysergic acid.
After watching about half of it I decided to go down and get something to eat feeling very hungry. It was a magnificent experience, every sound taste and feeling coming together in a symphony of pleasure. I ate a lot and began to feel like I didn’t know when to stop. This experience was tainted somewhat by the intense feeling of being watched and that someone would wake up hearing what sounded like very loud chewing sounds I was making. This paranoia and many others at different times lead to brief tangents of insanity where I believe I had gone insane. I talked to myself a lot and could not figure out who I was talking to when doing this. I then began to have thoughts of self-grandiosity in which I was some how special. I felt like I was the center of the universe kind of like maybe everyone I ever saw was just acting and playing their role in my life.
I went up to my room at about 2:00 am and tried to go to sleep to no avail when I was in the dark if I concentrated I could see a beautiful kaleidoscope of rainbow colors of the walls. I felt really antsy so I took a muscle relaxant. This helped me go to sleep at nearly 4:00 am. When I woke up the next day I felt chills, little antsy still, and when looking at colors they were more deep and vivid than normal I found myself staring at them a little bit, but that was all. I also didn’t eat much the day after. One thing to note is I had bad gas from the seeds, no real cramping just flatulence, so beware.
Experiment 2: Being ecstatic with the results of my first test I decided to dose with about 560 seeds, which included about 260 of the flying saucer variety, a couple days later. I dosed and immediately ate dinner. I ate a lot of tuna salad sandwiches. This time I felt some of the euphoria after many hours of waiting that I had felt before during the onset but to my supreme dismay there was no trip. Just a weak sensitivity to light and sound and euphoria that occurred late and wore off fast.
Experiment 3: being enraged and vexed by the bizarre problems of the second experiment I decided to dose high. I had started doing the ether ethanol extraction a few days earlier with 700 seeds and dosed myself with the resulting brown goo which I pressed into a kind of pill at 12:00 pm. I reasoned that the goo probably contained at least 500 ug of LSA when taking into account side reactions and exposure to sunlight. I felt intense euphoria like at the beginning of a trip but no trip. Now I was very angry.
At about 3:00 pm I proceded to eat 830 seeds (apprx. 830 ug). I took them with spring water and the experience was quite unpleasant. I took a 25 mg pill of hydroxyzine pamoate for the nausea which I expected to be intense. This pill is for people who can’t stop throwing up because of anxiety so I knew it would allow me to absorb the LSA regularly because it would work in my brain to soothe the feelings of nausea.
It was about 5:00 pm with not many results. Then very angry and beginning to believe that I had built up a resistance to the drug I went to the mall. On the way there the other cars’ headlights had rainbows glowing from them.
[Erowid Note: Driving while intoxicated or tripping is dangerous and irresponsible because it endangers other people. Don't do it!]
It started to really kick in hard in waves of feeling at the mall I took in an amazing amount of information smells, people, light, feeling it was in tense I had a $30 gift card which I had used earlier just grabbing a few items which caught my eye and upon giving them to the clerk he said it was forty dollars so I had to get rid of something which I did quickly. The mall was pretty empty it being a weekday night. In the mall people started to look at me funny. Many people that I passed were staring at me or at least I thought they were. This made me very paranoid and uncomfortable.
I went into a sports collectables store. And asked the clerk if they had any Mike Schmitt jerseys, which I was certain he wouldn't, he then said something to the effect of ‘I’m pretty sure we do, I’ll check’ which made me very happy for I thought he would get one out of the back. It was very hard to put words together while talking to him and to express what I wanted to ask him aloud. He just sat their on the computer for a while. I started getting agitated and asked him what he was doing and he said he was checking the website to order them. I felt humiliated. I thought he was going to check for them in the back when he was done on the computer.
Walking in the mall I felt very uncomfortable and paranoid, though my senses were alive. I kept listening to the music they were playing over the speaker system and trying to name the songs which is really weird because I normally don’t listen to the music. I decided to go into Spencer’s gifts for the many things they would have to trip to this was a mistake as I realized that being in the mall was enough without the added stimulation of flashing colors and static and lava lamps in that store. I had to leave quickly. On my way out I got lost in Macy’s for like 45 min. before realizing that there was no exit to the mall from that department store. While there I tripped out to a TV screen playing music and changing colors which was magnificent.
Then I went to the bathroom which was exceedingly hard to find. Peeing was an almost orgasmic experience. I looked in the mirror and saw that my pupils were heavily dilated. I decided I had to go after asking some one where I could leave from I went back into the mall to walk toward the exit I noticed how weird peoples’ faces looked like they were characters in a painting more people were staring at me. This made me think of the fact that lysergic acid makes you show schizophrenic symptoms. I began to think they were looking at me because I was weird and it startled them I then gained a profound empathy for and understanding of the pain that psychotic people must go through in their daily lives.
I got out of the mall at about 7:30 pm and after some difficulty finding my car I drove home. I had some trouble driving. On the way there drove really fast for I was euphoric and so loved the feeling of driving. Needless to say I made some very dangerous maneuvers. So on the way back I drove about 10 MPH below the speed limit the whole way in the right lane people kept passing me angrily but this was o.k. I think the only reason I made home or back was because to get to the mall was about the same route I took to school and back everyday when I was in high school for four years so I could do it effortlessly.
I got home at 8:00 pm and changed my close and got my portable CD player together with new headphones I had bought to listen to the music I had bought downstairs. This seems like a simple sequence of tasks, but for me it was intense and challenging mentally. I sat and peacefully listened to Emenem feeling a strong empathy for him and the personal pain he expressed in his lyrics. It was and older CD and really enjoyed all the sounds that came together beautifully in each song.
I relaxed listening to this CD and others, like Nirvana which was beautiful, as I gazed at the amazing visuals I getting from the room. When the lights were on I saw rainbows reverberating and flowing off every object in the room. When I stared at them I was amazed that I could see the entire electromagnetic spectrum of visual light. It was dancing before me. When I went outside I saw these same rainbows reverberating in different directions off the clouds in the sky. The paranoia and uncomfortableness that I felt was soothed when I was at home and the euphoria took over completely. I remember feeling my dog’s fur for a long time because of how amazing it felt.
Then at about 9:30 pm I went up stairs and tripped out and thought deeply to the reverberating colors. I also noticed on my way up while staring at the runner carpet in the hallway that the pattern of fruits and flowers on the rug seemed to flow and grow and swirl. I relaxed on my bed which felt amazing and stared at these color patterns. I then began looking through a big book of French Impressionist paintings and staring at Monets, Renoirs, and Van Goghs in awe of how the colors in the backgrounds flowed and swirled. A way I can describe the visuals is like being in a Van gogh painting except all the swirls of color coming off objects are rainbow colored. It wasn’t so intense that I couldn’t see my way around, but it was cool enough to stare at things for hours. I could see the whole universe in all its beauty and splendor it I thought how I loved life, nature and the universe intensely.
At about 11:30 pm I went back downstairs to watch TV I watched one episode of Cheers and one episode of Friends and loved it. I had never been so involved in these shows before. I love the characters and plot lines and underlying emotions. I remember thinking what a smug egotistical jerk Ted Danson was, but then felt bad when I realized it was just his character on the show. On Friends I noticed how uninhibited and open with their femininity Monica, Rachel and Phoebe. And how beautiful it was that they could be like that. I thought if I ever settled down with a girl I would want her to be like them. I then ordered “Eternal Sunshine of the Spotless Mind” a movie on On Demand Cable. I remember loving the brand of comedy and seeing the plot play out. I was especially entranced by the quote which had the movie title in it. While on my trip I felt poetry and loved it I thought of Emenem’s music as poetry and listened to a lot of Bob Dylan just soaking in every metaphor.
At About 3:00 am after much restlessness I decided to take two 5 mg abien tabs and half a 10 mg valium to help me fall asleep. I got in bed after about, and hour of looking at the patterns and thinking deep thoughts about how beautiful the world is the pills knocked me out. And I fell into a peaceful dreamless sleep.
The next day I felt a little restless, shaky and uneasy pretty much all day. I think it’s possible to build up a resistance to lysergic acid and that this is what caused my second experiment to come up negative. I also believe that I had a fairly intense and very good acid trip. I would like to know from anybody with a lot of experience with LSD if I did. This would further support my hypothesis.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


In POSIX sh, += is undefined.
(or "In dash, ... is not supported." when using dash
)
var="Hello "
var+="World"
var="Hello "
var="${var}World"
Using +=
to concatenate to an existing variable is a ksh/bash extension. For POSIX sh or dash, write out the full expression. Be careful to use braces if the text you append could be confused for a variable (as in the example, to avoid $varWorld
being interpreted as ${varWorld}
)
None.


Smelly has been moved. Please go to
Please go to http://smelly.lbl.gov
You will be redirected in 5 min. Please update your bookmark. This page will soon be removed.


Infinispan is an open-source in-memory data grid that offers flexible deployment options and robust capabilities for storing, managing, and processing data. Infinispan provides a key/value data store that can hold all types of data, from Java objects to plain text. Infinispan distributes your data across elastically scalable clusters to guarantee high availability and fault tolerance, whether you use Infinispan as a volatile cache or a persistent data store.
Get to your data from multiple protocols and data formats.
Ensure data is always available to meet demanding workloads.
Guarantee the integrity of your data.
Maximize resources to process data in real-time.
Quickly and efficiently look up values in the data store.
Infinispan turbocharges applications by storing data closer to processing logic, which reduces latency and increases throughput.
Available as a Java library, you simply add Infinispan to your application dependencies and then you’re ready to store data in the same memory space as the executing code.
If you want to provision a data layer that is independent of your applications, you can use Infinispan Server for remote access to data with in-memory performance. Clients are a single network hop away from data through consistent hashing techniques and can make requests over HTTP or with a custom binary TCP protocol called Hot Rod.
Learn MoreInfinispan provides trusted open-source technology to deliver scalability to meet workload demands and reduce resource utilization.
One popular use for Infinispan is as a shared store for stateful data, such as user HTTP sessions. Applications can stay lightweight and avoid heap usage by externalizing sessions to Infinispan clusters, which act as an independent data layer.
Learn MoreInfinispan clusters running in different geographical locations can form global clusters to back up your data across sites. If sites go offline clients can immediately switch to an available cluster, making sure data center faults do not cause service interruptions.
When using the Infinispan Operator with Kubernetes environments such as Red Hat OpenShift, cross-site replication capabilities make your data ready for hybrid and multi cloud deployments.
Infinispan also guarantees data consistency when using cross-site replication, even in cases where clients make concurrent writes at different locations that use asynchronous replication. So your data is always there and always accurate, no matter where you’re running.
Learn MoreJuly 28, 2020 Tags: tutorial learning server
Dear Infinispan community, If you are wondering how to start with Infinispan Server from your Java Application, a new Tutorial is available. This tutorial covers the essentials to get started with Infinispan Server and takes around half an hour to complete. In this tuto...
July 27, 2020 Tags: release development
Dear Infinispan community, The first of our development releases of Infinispan 12 is here and it features our upgrade to Hibernate Search 6 which finally allows us to upgrade to Lucene 8.x. We’ve had to change a few things in our query implementation to accommodate ...
July 22, 2020 Tags: anchored keys state transfer
Background For background, the preferred way to scale up the storage capacity of a Infinispan cluster is to use distributed caches. A distributed cache stores each key/value pair on num-owners nodes, and each node can compute the location of a key (aka the key owners) direc...


HTML, PHP, hosting, website, Web
Run out of box PHP contact us script, It does not need modification, it will detect the domain and send email containing the contact message to info@yourdomain. Whatever fields are in your form will be detected and be sent with email.
Lots of contact us scripts are available over the internet. To use any other script, the modification of the PHP file is needed.
This script is very useful to those who do not know PHP and to the beginners of PHP.
Upload the script folder to your www root directory.
<form action="contact2us/send.php" method="POST">
from_email
, from_name
, subject
, message
and captcha
as main fields' names in your form.$captcha = false;
$captcha = true;
To use captcha, include the following in your form:
<img src="contact2us/captcha_code_file.php?rand=<?php echo rand();
?>" id='captchaimg' >

Enter the code above here : <input id="captcha"
name="captcha" type="text">

Put your own $thank_you_url
in the 2nd line of the code.
$REFERER = $_SERVER['HTTP_REFERER'];
if(!preg_match("@^http:\/\/(www\.)?$domain\/@",$REFERER)){
die("This page can't be call directly");
}
if(!$from_email) $from_email = "web_page@$domain";
if (!filter_var($from_email, FILTER_VALIDATE_EMAIL)) {
$Err .= 'Invalid email format
';
$from_email = "web_page@$domain";
}
if ($subject && !preg_match('/^[A-Za-z ]+$/',$subject)){
$subject = "=?UTF-8?B?".base64_encode($subject)."?=";
}
foreach ($_POST as $key => $value)
{
$value = htmlspecialchars($value);
$message_html .= "
$key

$value
";
}
header('Location: '. $thank_you_url);
There are many mailing technique in PHP; PEAR Mail, PHP Mailer and mail function. However we just use mail function as it is old, common and simple.
Remove all illegal characters from an email address:
$from_email = filter_var($from_email, FILTER_SANITIZE_EMAIL);
Check if the variable $email is a valid email address:
if (!filter_var($from_email, FILTER_VALIDATE_EMAIL)) { $Err .= 'Invalid email format
'; $from_email = "web_page@$domain"; }
$pattern = '/^[\w.-]+@[\w.-]+\.[A-Za-z]{2,6}$/';
if(!preg_match($pattern, $from_email)){
$Err .= 'Invalid email format
';
$from_email = "web_page@$domain";
}
Setting the max email could be sent for a single IP per hour.
If you have any suggestion to this section or to improve the script; please write it in the comments to be included in the next version.


Selected address: {{addressModel | json}}
This example uses angular.js typeahead directive, shared on npm. Check source code here: typeahead.demo


Soldier Annatol:
It took a lot of blood, sweat and tears to create this device. But without it, it would be difficult -- if not downright impossible -- for us to secure safe drinking water.
Now it's my duty to maintain the purification device.
Quest


Use it to check your houses, rental properties, and many other things.
Start Now for Free!Check out what you can do with this app!
No longer need to be tied to your properties. Enjoy the freedom!
View property reports with photos provided by the checkers
In-app messaging for better communication between owners and checkers
Schedule routine checks or request an emergency check at any time


iterami
/
Guides.htm
/
EVE Online
/Moa
Fittings:
SCANNING-HIGHSEC-CHEAP
Fittings
Code
Notes
Scanning Highsec Cheap
[Moa, SCANNING-HIGHSEC-CHEAP] Inertial Stabilizers II Inertial Stabilizers II Inertial Stabilizers II Inertial Stabilizers II 50MN Cold-Gas Enduring Microwarpdrive Multispectrum Shield Hardener II Multispectrum Shield Hardener II Large Shield Extender II Large Shield Extender II Expanded Probe Launcher I Salvager II Medium Gravity Capacitor Upgrade I Medium Gravity Capacitor Upgrade I Federation Navy Hobgoblin x3 Combat Scanner Probe I x8


powerSavingMode
Increase Temperature
Decrease Temperature
"Reset Temperature"
TEMPERATURE
thermostat.temperature()
CELCIUS
ENERGY
thermostat.getEnergy()
kW/HOUR


Standards and Testing Agency
Email<EMAIL_ADDRESS>National curriculum assessments helpline 0300 303 3013
For general enquiries about national curriculum tests.
Guidance
Instructions for local authority monitoring visitors, including the monitoring visits form.
Local authorities ( LAs ) have a statutory responsibility to monitor the administration of the key stage 2 ( KS2 ) national curriculum tests. This helps to ensure that the security and confidentiality of the test materials are maintained and that the assessments are administered correctly and consistently.
To carry out a visit correctly, you need to be familiar with this guidance as well as the 2016 test administration guidance for schools.
Your monitoring visits co-ordinator will give you specific information before each visit. Make sure you take:
You must also take photo identification with you to present on arrival at a school. This can be a passport, driving license or official work pass.
Depending on when your visit takes place you will need to observe certain aspects of test administration to make sure the school is following our published guidance correctly. Use the monitoring visits form to record what you see. At the end of the visit you will need to meet with the headteacher, or delegated member of staff, to discuss your findings.
These monitoring visits take place during the week commencing 2 May. You should use these visits to make sure that the KS2 test packs are unopened and stored securely, and that the school has received the correct number of packs.
If the school is also administering the key stage 1 (KS1) tests you should check that the school received the correct number of KS1 tests packs and check that, if not in use, these are stored securely too.
Your monitoring visits co-ordinator will give you details of the number of test packs delivered to the school. Ask the headteacher for annotated copies of their delivery note(s) and details of the number of test packs that were actually delivered.
Check that all of the relevant test packs are sealed and stored securely. This must include KS1 test packs where applicable.
If a school has received damaged test packs for either the KS2 or KS1 tests, advise them, if they have not already done so, to contact immediately the national curriculum assessments helpline . The school may be asked to send us a photograph of the damaged packages.
If you are carrying out a monitoring visit during the week commencing 2 May the majority of KS2 test packs should not have been opened. Exceptions are as follows.
Schools may only open packs of standard test materials before Monday 9 May if they have an approved application for early opening from STA via NCA tools .
Your monitoring visits co-ordinator will give you a report from NCA tools showing whether the school has been granted early opening. Any school that has opened a test pack early must have evidence of approval to do so from STA . You should ask to see evidence of this approval and check that any materials that were opened early are stored securely. If you find test packs have been opened without permission you must record this on the monitoring visits form and flag it with the headteacher at the end of your visit.
The KS1 test materials must be kept secure and treated as confidential from the point they are received in school until the end of May. Appropriate security arrangements must be in place if test papers are being marked away from school or if transporting test materials to another location to take part in internal moderation of marking. Please note that the individual test packs must not be opened until Tuesday 3 May.
Schools selected to administer one of the KS1 tests early in April are required to return all of the test materials for that subject to STA after the tests have been administered and marked. The test materials which were delivered early will be highlighted in grey on the LAs versions of the delivery notes. Monitoring visitors should only expect to see test materials for the remaining two subjects at these schools.
These visits take place between Monday 9 May and Thursday 12 May.
You should arrive at the school at the start of the school day so that you are there before the start of the test and can observe the complete test administration process. This means:
Where applicable you should also see evidence that KS2 test scripts have been sent for marking.
You should also carry out the checks relating to visits before and after the test period, if tests have taken place or are still to be administered.
Check that:
If the school administers a test in more than 1 room, you should monitor the test administration in each room. Take care that your monitoring activity doesn’t disturb pupils as they take the tests.
Check that:
If the school is using access arrangements, check that:
For the English grammar, punctuation and spelling tests you should also check that:
For the mathematics tests you should also check that:
You should observe the whole cohort’s test scripts being packed and stored. The headteacher, or delegated member of staff, should undertake this activity, using the guidance in the Attendance register and test script dispatch instructions .
If the school is using a timetable variation, for a later day, you should check that the rest of the cohort’s test scripts are sealed in transparent inner bags and securely stored in a locked cupboard. If a pupil is taking a test on the scheduled day but at a different time to the rest of the cohort the bag can remain unsealed until all pupils have taken the test. However, the rest of the cohorts scripts must be kept in a locked cupboard until then.
Parcelforce Worldwide will collect test scripts on the following dates.
| DfE number | Test script collection dates (between 9am and 4pm) |
|---|---|
| Schools with a DfE number that ends with an even digit (including 0) | Monday 9 May, afternoon collections only and Wednesday 11 May |
| Schools with a DfE number that ends with an odd digit | Tuesday 10 May and Thursday 12 May |
If the school has sent test scripts for marking:
These visits take place immediately after the test period, from Friday 13 May. You should use these visits to make sure the KS2 test scripts and any unused test papers are stored securely. If the school is still administering KS2 tests, because they have permission to use a timetable variation, you should also carry out the checks relating to visits during the test period.
Unless we have given the school permission to move a test by up to 5 days you should expect to see either:
You should only find unsealed script return bags if the school is still administering a test because we have given permission to use a timetable variation. Check that the rest of the cohort’s KS2 test scripts are sealed in transparent inner bags and securely stored in a locked cupboard. The script return bags should be sealed as soon as possible on the day that the timetable variation test is administered.
Schools will receive a collection on Friday 13 May if they have:
If a pupil takes a test after the final scheduled collection date of Friday 13 May the school should book a separate collection to send all remaining test scripts for marking. All test scripts must be sent for marking before schools break up for the half-term holiday. Make sure that the headteacher, or delegated member of staff understands this.
Please use the 2016 KS2 monitoring visits form - guidance for completing the form ( PDF , 117KB , 2 pages ) . You must complete the form fully 2016 KS2 monitoring visits form ( PDF , 119KB , 2 pages ) for each school you visit. You must answer all the questions in sections A and B. If applicable, you must also answer all of the questions in section C.
Make sure you include your monitoring visits co-ordinator’s name in case we have any enquiries about the visit.
If you enter an ‘X’, ‘N’ or ‘P’ on the form, or if you notice any other irregularity during the visit, you must record details of the issue and any actions taken on the form. This will help us to identify where further investigation is needed by your LA and / or STA .
Before you leave the school you should meet with the headteacher, or delegated member of staff, to discuss your findings from the visit. If you have placed an ‘X’ or ‘N’ in any box on the monitoring visit form, you should advise whether the school should make changes to its test administration procedures for any remaining tests. If you didn’t find anything that concerned you, make this clear.
You and the headteacher, or delegated member of staff, should sign the monitoring visit form. This is to confirm the visit took place and that you have given any feedback about the administration of the key stage 2 tests to the school.
You should leave a copy of the monitoring visit form, and any delivery notes that you’ve annotated, with the headteacher, or delegated member of staff. You must not add any additional detail or make changes to the monitoring visit form after this point.
You should discuss any findings from your visit with your monitoring visits co-ordinator as soon as possible after you have carried out your visit.
If you have placed an ‘X’, ‘N’ or ‘P’ in any box on the monitoring visit form, you should discuss the issue with your monitoring visits co-ordinator immediately.
If you didn’t identify any irregularities during your visit, you must send the completed monitoring visit form to your monitoring visits co-ordinator immediately after the visit. The deadline for returning completed monitoring visit forms to your co-ordinator is Friday 20 May.
If you have questions about carrying out monitoring visits you should speak to your monitoring visits co-ordinator. If they are unable to help, you can contact the national curriculum assessments helpline.
Email<EMAIL_ADDRESS>National curriculum assessments helpline 0300 303 3013
For general enquiries about national curriculum tests.
Published: 13 April 2015
Updated: 11 April 2016


Implicit multiplication
Summary
Using a very simple transformation during the tokenzing phase,
Python’s syntax is extended to recognize that multiplication is implied
in some situations that would normally be identified as SyntaxError
since a multiplication operator *
would be considered
to be missing.
Algebra
Let’s talk about algebra. Consider the following set of equations.
ax = 1
ay = 2
az = 3
x1 = 2ax
x2 = 3(ax + ay)
x3 = ax ay
x4 = (ax + ay)4
x5 = (ax + ay)az
x6 = ax(ay + az)
I am confident that you can calculate the values of the unknowns x1
to
x6
.
Now, suppose that the above would be code written as a Python program.
You would find that the lines for x1
to x5
would give rise
to SyntaxError
, whereas the last one would be a TypeError
.
Python’s syntax could be change to allow the cases above that
result in a SyntaxError
without breaking anyone’s program.
Here is another equation, taken from a class I taught last week.
y = 2A cos(k x + (w_1 + w_2)t/2) cos((w_1 - w_2)t/2)
If I were to write this as part of a Python program, and using the recommended way of writing spaces around operators, I would have to write is as follows:
y = 2 * A * cos(k * x + (w_1 + w_2) * t / 2) * cos((w_1 - w_2) * t / 2)
Which of the two do you find easier to decipher? Personally, it is the first one.
Quoting from a post from Guido van Rossum:
The power of visual processing really becomes apparent when you combine multiple operators. For example, consider the distributive law:
mul(n, add(x, y)) == add(mul(n, x), mul(n, y)) (5)That was painful to write, and I believe that at first you won’t see the pattern (or at least you wouldn’t have immediately seen it if I hadn’t mentioned this was the distributive law). Compare to:
n * (x + y) == n * x + n * y (5a)Notice how this also uses relative operator priorities. Often mathematicians write this even more compact:
n(x+y) == nx + ny (5b)but alas, that currently goes beyond the capacities of Python’s parser. … Now, programming isn’t exactly the same activity as math, but we all know that Readability Counts, and this is where operator overloading in Python comes in. …
What if we could do something half-way between what Python currently allow and what mathematicians would write, so that the equation I mentioned and wrote as:
y = 2A cos(k x + (w_1 + w_2)t/2) cos((w_1 - w_2)t/2)
would be valid Python code?
This can be done with the implicit_multiplication
import hook.
>>> from ideas.examples import implicit_multiplication as mul
>>> hook = mul.add_hook()
>>> from ideas import console
>>> console.start()
Configuration values for the console:
callback_params: {'show_original': False, 'show_transformed': False}
transform_source from ideas.examples.implicit_multiplication
--------------------------------------------------
Ideas Console version 0.0.7a. [Python version: 3.7.3]
~>> 2(3 + 4)
14
~>> a = 3
~>> b = 4
~>> 2a
6
~>> a b
12
implicit_multiplication.py
This module is intended to demonstrate some unusual transformations to allow someone to write equations as they would on paper and have Python interpret them properly.
- ideas.examples.implicit_multiplication.add_hook(**_kwargs)[source]
Creates and automatically adds the import hook in sys.meta_path
- ideas.examples.implicit_multiplication.transform_source(source, **_kwargs)[source]
This adds a multiplication symbol where it would be understood as being implicit by the normal way algebraic equations are written but would be a SyntaxError in Python. Thus we have:
2n -> 2*n n 2 -> n* 2 2(a+b) -> 2*(a+b) (a+b)2 -> (a+b)*2 2 3 -> 2* 3 m n -> m* n (a+b)c -> (a+b)*c
The obvious one (in algebra) being left out is something like
n(...)
which is a function call - and thus valid Python syntax.


fake sendmail for bugzilla/windows glob.com.au/sendmail<EMAIL_ADDRESS>about sendmail.exe is a simple windows console application that emulates sendmail's "-t" option to deliver emails piped via stdin. it is intended to ease running unix code that has /usr/lib/sendmail hardcoded as an email delivery means. it doesn't support deferred delivery, and requires an smtp server to perform the actual delivery of the messages. install (1) download sendmail.zip (2) copy sendmail.exe and sendmail.ini to \usr\lib on the drive where the unix application is installed. eg. if your application is installed in c:\bugzilla, sendmail.exe and sendmail.ini need to be copied to c:\usr\lib\sendmail.exe and c:\usr\lib\sendmail.ini (3) configure smtp server and default domain in sendmail.ini license and source this program is released under the bsd license. the license details and full source (delphi 2007) are included in the zip. version history version 24 - fixes for ssl version 23 - fix timezone in date header version 22 - fixes to error handling version 21 - added TLS support version 20 - fixed race condition in IIS's pickup delivery version 19 - added support for delivery via IIS's pickup directory - optionally reads settings from the registry (in absense of the ini file) version 18 - fix for indy 10 "range check error" version 17 - only process message header - optionally use madexcept for detailed crash dumps version 16 - send hostname and domain with HELO/EHLO - configurable HELO/EHLO hostname - upgraded to indy 10 version 15 - fixes error messages when debug_logfile is not specified version 14 - errors output to STDERR - fixes for delphi 7 compilation - added 'connecting to..' debug logging - reworked error and debug log format version 13 - added fix to work around invalid multiple header instances version 12 - added cc and bcc support version 11 - added pop3 support (for pop before smtp authentication) version 10 - added support for specifying a different smtp port version 9 - added force_sender version 8 - *really* fixes broken smtp auth version 7 - fixes broken smtp auth version 6 - correctly quotes MAIL FROM and RCPT TO addresses in <> version 5 - now sends the message unchanged (rather than getting indy to regenerate it) version 4 - added debug_logfile parameter - improved error messages version 3 - smtp authentication support - clearer error message when missing from or to address - optional error logging - adds date: if missing version 2 - reads default domain from registry (.ini setting overrides) version 1 - initial release


What's new in ZSON v1.1?
ZSON v1.1 was released recently. Changes since v1.0:
- Bugfix: the zson_dict table used to be excluded from backups created via pg_dump utility (see a0d4201e and e176165b). Reported by Pavel Luzanov;
- Bugfix:
make installcheck
used to fail on MacOS (see b3a70915). Reported by Oleg Bartunov; - Grammar corrections in the documentation (see ceb9d5ee and 13cd5a69). Maria Popova;
- And various minor changes;
The following people contributed to this release one way or another (in random order): Peder Rindal Refsnes, Maria Popova, Oleg Bartunov, Maxim Milyutin, Dmitriy Olshevskiy, madisonleavo, Vyacheslav Semushin, Sergey Bronnikov, Marco Craveiro, Madis Lõhmus, Pavel Luzanov.
ZSON is a PostgreSQL extension for transparent JSONB compression. The compression is based on the common dictionary of strings that are frequently used in JSONB documents of the specific database. In some cases ZSON can significantly reduce the database size and improve the overall performance. For more details see this benchmark. ZSON is an open source software distributed under the MIT license.
Comments


Hey. Just a few quick notes to help you get the most out of Song Search:
If you're using Spotify, Song Search can get the details of your currently playing track when you click on
"Get Current Track". The first time you do this you will need to log into Spotify.
This is required so Song Search can retrieve the details of the track you're currently playing.
Once you've done this, you just need to reload this page in your browser for Song Search
to retrieve the currently playing song.
Now you can tap or click any of the buttons to
get more details on the song currently playing.
Song Search also works independently of Spotify: you can just manually enter any Song Title,
Artist, or Album, and the buttons will find information for those that you entered.
If on a mobile device, you can also put a bookmark for this page on your homescreen for accessing
Song Search more easily.


olfactorybulb.model¶
The main class to build and run the network model. The class constructor builds the model using one of the specified parameter classes. If autorun==True, the model will be simulated after building. Otherwise, run(tstop) is used to run the simulation.
MPI/multi-core simulations can be performed using initslice.py found in the repo root. For example, the following command will build and run the network model using the GammaSignature parameter set using 16 cores:
# From repo root, run this shell command (replace 16 with the number of cores you would like to use):
mpiexec -np 16 python initslice.py -paramset GammaSignature -mpi
Simulation results will be stored under [repo]/olfactorybulb/results/GammaSignature. The last folder in the path uses the name of the parameter class.
See the LFP Wavelet Analysis.ipynb notebook for examples of how the results are analyzed.
-
class
olfactorybulb.model.
OlfactoryBulb
(params='ParameterSetBase', autorun=True)[source]¶ Bases:
object
The main class used to build and simulate the olfactory bulb network model.
-
__init__
(params='ParameterSetBase', autorun=True)[source]¶ - Parameters
params – The name of the class defined in olfactorybulb.paramsets that defines the network parameters
autorun – When true, after the network model is built, starts the simulation
-
add_gap_junctions
(in_name, g_gap)[source]¶ Adds gap junctions between tufted dendrites of specified cells
- Parameters
in_name – A part of a cell class name (e.g. ‘Mitral’) used to select a cell to which the GJ is added
g_gap – The conductance of the gap junctions
-
add_inputs
(odor, t, rel_conc)[source]¶ Add odor stimulation to the tufts of the principal cells
- Parameters
odor – The name of the odor
t – Onset time
rel_conc – Relative concentration 0-1
-
create_gap_junction
(seg_1_info, seg_2_info, g_gap)[source]¶ Creates a gap junction between two segments
- Parameters
seg_1_info – Tuple of the name and gid of the first segment
seg_2_info – Tuple of the name and gid of the second segment
g_gap – Gap junction conductance
-
create_gap_junctions_between
(input_segs, g_gap)[source]¶ Creates gap junctions between a list of specified segments. GJs are connected in a chain (e.g. Seg1 <-GJ1-> Seg2 <-GC2-> Seg3)
- Parameters
input_segs – List of segments to connect by gap junctions
g_gap – Gap junction conductance
-
create_lfp_electrode
(x, y, z, sampling_period, method='Line')[source]¶ Uses the LFPsimpy package to add an LFP electrode at the specified x,y,z location
See LFPsimpy package.
- Parameters
x – y, z coordinates in um
sampling_period – How often to compute the LFP signal in ms
method – One of ‘Line’, ‘Point’, or ‘RC’.
- Returns
an LFPsimpy LfpElectrode object
-
get_gaussian_spike_train
(spikes=50, start_time=100, duration=10)[source]¶ Gets a spike train from a gaussian probability distribution whose 99% range starts at the specified time and lasts for the specified duration.
- Parameters
spikes – The number of spikes to generate
start_time – The onset time of the gaussian
duration – The duration of the gaussian
- Returns
A numpy array of spike times in chronological order
-
get_model_inputsegs
()[source]¶ Queries the model database to get the ‘root’ segments of the tufted dendrites of the mitral and tufted cells
- Returns
A dict that maps the cell model’s class name to the name of the root tufted dendrite section
-
get_nseg_count
(root_dict)[source]¶ Recursively counts the number of segments of a cell provided its BlenderNEURON root segment dict
- Parameters
root_dict – The root segment dict of a cell as saved by BlenderNEURON
- Returns
The total number of segments of the cell
-
load_cells
(cell_type)[source]¶ Load the cells of the specified type onto least busy MPI ranks.
‘Busyness’ of a rank is the sum of all cell complexities on that rank, as measured by the number of segments of each cell.
- Parameters
cell_type – One of ‘MC’, ‘GC’, ‘TC’
-
load_glom_cells
()[source]¶ Loads a dict that maps glomeruli ids to cells that are attached to each glomerulus
-
load_synapse_set
(synapse_set)[source]¶ Uses BlenderNEURON to load a previously saved set of synapses between a population of cells
- Parameters
synapse_set – One of ‘GCs__MCs’ or ‘GCs__TCs’ as seen in the olfactorybulb.slices.DorsalColumnSlice folder.
-
record_from_somas
(cell_type)[source]¶ Adds NEURON vector recorders to the somas of the specified cell types
- Parameters
cell_type – One of ‘MC’, ‘GC’, ‘TC’
-
run
(tstop)[source]¶ Runs the NEURON simulation until the specified stop time
- Parameters
tstop – Simulation stop time
-
save_recorded_vectors
()[source]¶ Saves soma voltage traces and odor input spike times to Pickle files for later processing
Saves to the results directory as ‘soma_vs.pkl’ and ‘input_times.pkl’
-
stable_hash
(source, digits=9)[source]¶ Creates a hash code of digits long that is stable across different machines.
- Parameters
source – The string to hash, in this case a section name
digits – The number of digits to keep of the hash
- Returns
The hash code as an integer
-
stim_glom_segments
(time, input_segs, intensity)[source]¶ Adds input synapses onto glomerular tufts at specified start time and intensity
The inhalation part of a sniff cycle is modeled as a gaussian probability that is centered at the midpoint of the inhalation onset and end. The probability is translated into spikes. The spikes then trigger the excitatory synapses placed at the mitral/tufted cell tufts.
Intensity regulates how many spikes to pick from the gaussian.
- Parameters
time – the inhalation onset time in ms
input_segs – a list containing tuples of: a) The name of the segment to stimulate as it appears on the current MPI rank b) segment gid c) segment name as it appears when there is only one rank. If not using MPI a) and c) are same.
intensity – 0-1 representing odor intensity
- Returns
None
-
-
olfactorybulb.model.
random
() → x in the interval [0, 1).¶


My name is Usman Aslam and I'm a tech enthusiast hyperfocused on the latest technologies and who just loves video games.
Well versed in working with Arduino IDE and respective microcontrollers such as UNO, ESP 8266 & ESP 32
Primarily worked in C++, C and Verilog languages
Skilled in content development including blogs, articles and columns
High experience in managing teams and various projects on the leadership standpoint
Feel free to hit me an email or a message on my social media handles.
Contact Me


Pizza App is a Kenyan multinational restaurant chain and international franchise founded in 1958 in Lorem ipsum dolor, sit amet consectetur adipisicing elit. Quia libero, veniam dolorum dignissimos ipsam amet. Dolores, vero. Dolor incidunt earum fugiat, fugit minima sequi quisquam, ex atque asperiores veritatis aspernatur!, Kansas by Dan and Frank Carney. ...
The chain has 18,703 restaurants worldwide as of JULY 30, 2021, making it the world's largest pizza chain in number of locations. It is a subsidiary of Yum!


A Bootstrap style sheet dedicated to Pangnirtung, NU.
Pangnirtung (or Pang, also Pangniqtuuq, in syllabics: ᐸᖕᓂᖅᑑᖅ IPA: [paŋniqtuːq]) is an Inuit hamlet, Qikiqtaaluk Region, in the Canadian territory of Nunavut, located on Baffin Island. As of the 2016 census the population was 1,481, an increase of 3.9% from the 2011 census. The area of the town is 7.77 km2 (3.00 sq mi). Pangnirtung is situated on a coastal plain at the coast of Pangnirtung Fjord, a fjord which eventually merges with Cumberland Sound.
This text is important.
This text indicates success.
This text represents some information.
This text represents a warning.
This text represents danger.
This text is important.
This text indicates success.
This text represents some information.
This text represents a warning.
This text represents danger.
Those who know how to play can easily leap over the adversaries of life. And one who knows how to sing and laugh never brews mischief..
Unknown A snowy fjord
There's too much snow on the Jumbotron.
Far up to the north, above the arctic circle, you will find a small village called Pangnirtung. Simply called Pang by locals, Residents say the real name is Pangniqtuuq, which means "the place of many bull caribou". Pangnirtung is situated on a coastal plain at the coast of Pangnirtung Fjord, a fjord which eventually merges with Cumberland Sound. As of January 2014, the mayor is Mosesee Qappik.
The Inuit and their ancestors have inhabited the area for thousands of years, perhaps as long as 4,000. Their cultures became well-adapted to the climate and environment. Contact with European Canadians has been limited to less than the last century. In 1921, the Hudson's Bay Company established a trading post in Pangnirtung.
The barren-ground caribou is a subspecies of the caribou that is found mainly in the Canadian territories of Nunavut and the Northwest Territories, along with Kitaa, Greenland.The barren-ground caribou, one of several subspecies called tuktu in Inuinnaqtun/Inuktitut, and written as ᓇᐹᕐᑐᕐᑲᓐᖏᑦᑐᒥ ᑐᒃᑐ in Inuktitut syllabics, is a major food source for the Inuit, especially the Caribou Inuit bands living in the Kivalliq Region (Barren Lands) of present-day Nunavut.
The narwhal is a medium-sized toothed whale that possesses a large "tusk" from a protruding canine tooth. It lives year-round in the Arctic waters around Greenland, Canada, and Russia. Found primarily in Canadian Arctic and Greenlandic and Russian waters, the narwhal is a uniquely specialized Arctic predator. In winter, it feeds on benthic prey, mostly flatfish, under dense pack ice.
The iconic polar bear is found in the Arctic Circle and adjacent land masses as far south as Newfoundland. The Inuit have many folk tales featuring the bears including legends in which bears are humans when inside their own houses and put on bear hides when going outside, and stories of how the constellation that is said to resemble a great bear surrounded by dogs came into being. These legends reveal a deep respect for the polar bear.
| Inuit Village | Inuktitut | Province | Region |
|---|---|---|---|
| Pangnirtung | ᐸᖕᓂᖅᑑᖅ | Nunavut | Qikiqtaaluk |
| Ivujivik | ᐃᕗᔨᕕᒃ | Quebec | Nord-du-Québec |
| Kangiqsujuaq | ᑲᖏᖅᓱᔪᐊᖅ | Quebec | Nord-du-Québec |
| Kugaaruk | ᑰᒑᕐᔪᒃ | Nunavut | Kitikmeot |
| Iqaluit | ᐃᖃᓗᐃᑦ | Nunavut | Qikiqtaaluk |
| Igloolik | ᐃᒡᓗᓕᒃ | Nunavut | Qikiqtaaluk |
| Inuit Village | Inuktitut | Province | Region |
|---|---|---|---|
| Pangnirtung | ᐸᖕᓂᖅᑑᖅ | Nunavut | Qikiqtaaluk |
| Ivujivik | ᐃᕗᔨᕕᒃ | Quebec | Nord-du-Québec |
| Kangiqsujuaq | ᑲᖏᖅᓱᔪᐊᖅ | Quebec | Nord-du-Québec |
| Kugaaruk | ᑰᒑᕐᔪᒃ | Nunavut | Kitikmeot |
| Iqaluit | ᐃᖃᓗᐃᑦ | Nunavut | Qikiqtaaluk |
| Igloolik | ᐃᒡᓗᓕᒃ | Nunavut | Qikiqtaaluk |


This game was made using Unity, if you wish to play this game on your desktop, you can click here to access the game downloads


In this project, you'll use generative adversarial networks to generate new images of faces.
You'll be using two datasets in this project:
Since the celebA dataset is complex and you're doing GANs in a project for the first time, we want you to test your neural network on MNIST before CelebA. Running the GANs on MNIST will allow you to see how well your model trains sooner.
If you're using FloydHub, set data_dir
to "/input" and use the FloydHub data ID "R5KrjnANiKVhLWAkpXhNBe".
data_dir = './data'
# FloydHub - Use with data ID "R5KrjnANiKVhLWAkpXhNBe"
#data_dir = '/input'
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import helper
helper.download_extract('mnist', data_dir)
helper.download_extract('celeba', data_dir)
show_n_images = 25
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
%matplotlib inline
import os
from glob import glob
from matplotlib import pyplot
mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'mnist/*.jpg'))[:show_n_images], 28, 28, 'L')
pyplot.imshow(helper.images_square_grid(mnist_images, 'L'), cmap='gray')
The CelebFaces Attributes Dataset (CelebA) dataset contains over 200,000 celebrity images with annotations. Since you're going to be generating faces, you won't need the annotations. You can view the first number of examples by changing show_n_images
.
show_n_images = 25
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'img_align_celeba/*.jpg'))[:show_n_images], 28, 28, 'RGB')
pyplot.imshow(helper.images_square_grid(mnist_images, 'RGB'))
Since the project's main focus is on building the GANs, we'll preprocess the data for you. The values of the MNIST and CelebA dataset will be in the range of -0.5 to 0.5 of 28x28 dimensional images. The CelebA images will be cropped to remove parts of the image that don't include a face, then resized down to 28x28.

You'll build the components necessary to build a GANs by implementing the following functions below:
model_inputs
discriminator
generator
model_loss
model_opt
train
This will check to make sure you have the correct version of TensorFlow and access to a GPU
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
from distutils.version import LooseVersion
import warnings
import tensorflow as tf
# Check TensorFlow Version
assert LooseVersion(tf.__version__) >= LooseVersion('1.0'), 'Please use TensorFlow version 1.0 or newer. You are using {}'.format(tf.__version__)
print('TensorFlow Version: {}'.format(tf.__version__))
# Check for a GPU
if not tf.test.gpu_device_name():
warnings.warn('No GPU found. Please use a GPU to train your neural network.')
else:
print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))
Implement the model_inputs
function to create TF Placeholders for the Neural Network. It should create the following placeholders:
image_width
, image_height
, and image_channels
.z_dim
.Return the placeholders in the following the tuple (tensor of real input images, tensor of z data)
import problem_unittests as tests
def model_inputs(image_width, image_height, image_channels, z_dim):
"""
Create the model inputs
:param image_width: The input image width
:param image_height: The input image height
:param image_channels: The number of image channels
:param z_dim: The dimension of Z
:return: Tuple of (tensor of real input images, tensor of z data, learning rate)
"""
# TODO: Implement Function
inputImages = tf.placeholder(tf.float32, shape = (None, image_width, image_height, image_channels), name = "input_images")
zInput = tf.placeholder(tf.float32, shape = (None, z_dim), name = "z_input")
learningRate = tf.placeholder(tf.float32, name = "learning_rate")
return inputImages, zInput, learningRate
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_model_inputs(model_inputs)
Implement discriminator
to create a discriminator neural network that discriminates on images
. This function should be able to reuse the variables in the neural network. Use tf.variable_scope
with a scope name of "discriminator" to allow the variables to be reused. The function should return a tuple of (tensor output of the discriminator, tensor logits of the discriminator).
def discriminator(images, reuse=False):
"""
Create the discriminator network
:param images: Tensor of input image(s)
:param reuse: Boolean if the weights should be reused
:return: Tuple of (tensor output of the discriminator, tensor logits of the discriminator)
"""
# TODO: Implement Function
alpha = 0.05
with tf.variable_scope("discriminator", reuse = reuse) as disc_scope:
x1 = tf.layers.conv2d(images, 64, 5, strides=2, padding='same')
relu1 = tf.maximum(alpha * x1, x1)
# 14x14x64
x2 = tf.layers.conv2d(relu1, 128, 5, strides=2, padding='same')
bn2 = tf.layers.batch_normalization(x2, training=True)
relu2 = tf.maximum(alpha * bn2, bn2)
# 7x7x128
x3 = tf.layers.conv2d(relu2, 256, 5, strides=2, padding='same')
bn3 = tf.layers.batch_normalization(x3, training=True)
relu3 = tf.maximum(alpha * bn3, bn3)
# 4x4x256
flat = tf.reshape(relu3, (-1, 4*4*256))
# 4096
logits = tf.layers.dense(flat, 1)
out = tf.sigmoid(logits)
return out, logits
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_discriminator(discriminator, tf)
Implement generator
to generate an image using z
. This function should be able to reuse the variables in the neural network. Use tf.variable_scope
with a scope name of "generator" to allow the variables to be reused. The function should return the generated 28 x 28 x out_channel_dim
images.
def generator(z, out_channel_dim, is_train=True):
"""
Create the generator network
:param z: Input z
:param out_channel_dim: The number of channels in the output image
:param is_train: Boolean if generator is being used for training
:return: The tensor output of the generator
"""
# TODO: Implement Function
alpha = 0.05
with tf.variable_scope('generator', reuse = (not is_train)):
# First fully connected layer
x1 = tf.layers.dense(z, 7*7*512)
x1 = tf.reshape(x1, (-1, 7, 7, 512))
x1 = tf.layers.batch_normalization(x1, training = is_train)
x1 = tf.maximum(alpha * x1, x1)
#print(x1.shape)
# 7x7#512
x2 = tf.layers.conv2d_transpose(x1, 256, 5, strides=2, padding='same')
x2 = tf.layers.batch_normalization(x2, training = is_train)
x2 = tf.maximum(alpha * x2, x2)
#print(x2.shape)
# 14x14#256
x3 = tf.layers.conv2d_transpose(x2, 128, 5, strides=2, padding='same')
x3 = tf.layers.batch_normalization(x3, training = is_train)
x3 = tf.maximum(alpha * x3, x3)
#print(x3.shape)
#28x28x64
logits = tf.layers.conv2d_transpose(x3, out_channel_dim, 5, strides=1, padding='same')
out = tf.tanh(logits)
return out
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_generator(generator, tf)
Implement model_loss
to build the GANs for training and calculate the loss. The function should return a tuple of (discriminator loss, generator loss). Use the following functions you implemented:
discriminator(images, reuse=False)
generator(z, out_channel_dim, is_train=True)
def model_loss(input_real, input_z, out_channel_dim):
"""
Get the loss for the discriminator and generator
:param input_real: Images from the real dataset
:param input_z: Z input
:param out_channel_dim: The number of channels in the output image
:return: A tuple of (discriminator loss, generator loss)
"""
# TODO: Implement Function
g_model = generator(input_z, out_channel_dim)
d_model_real, d_logits_real = discriminator(input_real)
d_model_fake, d_logits_fake = discriminator(g_model, reuse=True)
labels = tf.ones_like(d_model_real) * 0.90
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_logits_real,
labels=labels)
)
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_logits_fake,
labels=tf.zeros_like(d_model_fake)))
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_logits_fake,
labels=tf.ones_like(d_model_fake)))
d_loss = d_loss_real + d_loss_fake
return d_loss, g_loss
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_model_loss(model_loss)
Implement model_opt
to create the optimization operations for the GANs. Use tf.trainable_variables
to get all the trainable variables. Filter the variables with names that are in the discriminator and generator scope names. The function should return a tuple of (discriminator training operation, generator training operation).
def model_opt(d_loss, g_loss, learning_rate, beta1):
"""
Get optimization operations
:param d_loss: Discriminator loss Tensor
:param g_loss: Generator loss Tensor
:param learning_rate: Learning Rate Placeholder
:param beta1: The exponential decay rate for the 1st moment in the optimizer
:return: A tuple of (discriminator training operation, generator training operation)
"""
# TODO: Implement Function
t_vars = tf.trainable_variables()
d_vars = [var for var in t_vars if var.name.startswith('discriminator')]
g_vars = [var for var in t_vars if var.name.startswith('generator')]
#Optimize
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
d_train_opt = tf.train.AdamOptimizer(learning_rate, beta1 = beta1).minimize(d_loss, var_list = d_vars)
g_train_opt = tf.train.AdamOptimizer(learning_rate, beta1 = beta1).minimize(g_loss, var_list = g_vars)
return d_train_opt, g_train_opt
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_model_opt(model_opt, tf)
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import numpy as np
def show_generator_output(sess, n_images, input_z, out_channel_dim, image_mode):
"""
Show example output for the generator
:param sess: TensorFlow session
:param n_images: Number of Images to display
:param input_z: Input Z Tensor
:param out_channel_dim: The number of channels in the output image
:param image_mode: The mode to use for images ("RGB" or "L")
"""
cmap = None if image_mode == 'RGB' else 'gray'
z_dim = input_z.get_shape().as_list()[-1]
example_z = np.random.uniform(-1, 1, size=[n_images, z_dim])
samples = sess.run(
generator(input_z, out_channel_dim, False),
feed_dict={input_z: example_z})
images_grid = helper.images_square_grid(samples, image_mode)
pyplot.imshow(images_grid, cmap=cmap)
pyplot.show()
Implement train
to build and train the GANs. Use the following functions you implemented:
model_inputs(image_width, image_height, image_channels, z_dim)
model_loss(input_real, input_z, out_channel_dim)
model_opt(d_loss, g_loss, learning_rate, beta1)
Use the show_generator_output
to show generator
output while you train. Running show_generator_output
for every batch will drastically increase training time and increase the size of the notebook. It's recommended to print the generator
output every 100 batches.
def train(epoch_count, batch_size, z_dim, learning_rate, beta1, get_batches, data_shape, data_image_mode):
"""
Train the GAN
:param epoch_count: Number of epochs
:param batch_size: Batch Size
:param z_dim: Z dimension
:param learning_rate: Learning Rate
:param beta1: The exponential decay rate for the 1st moment in the optimizer
:param get_batches: Function to get batches
:param data_shape: Shape of the data
:param data_image_mode: The image mode to use for images ("RGB" or "L")
"""
# TODO: Build Model
input_real, input_z, lr = model_inputs(data_shape[1], data_shape[2], data_shape[3], z_dim)
d_loss, g_loss = model_loss(input_real, input_z, data_shape[3])
d_opt, g_opt = model_opt(d_loss, g_loss, lr, beta1)
steps = 0
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch_i in range(epoch_count):
for batch_images in get_batches(batch_size):
# TODO: Train Model
steps += 1
batch_images *= 2.0
# Sample random noize
batch_z = np.random.uniform(-1, 1, size = (batch_size, z_dim))
#Run optimizers
_ = sess.run(d_opt, feed_dict = {input_real: batch_images, input_z: batch_z, lr: learning_rate })
_ = sess.run(g_opt, feed_dict = {input_real: batch_images, input_z: batch_z, lr: learning_rate })
if steps % 10 == 0:
# Show loss
train_loss_d = d_loss.eval({input_real: batch_images, input_z: batch_z, lr: learning_rate})
train_loss_g = g_loss.eval({input_z: batch_z})
print("Epoch {}/{}...".format(epoch_i + 1, epochs),
"Discriminator Loss: {:.4f}...".format(train_loss_d),
"Generator Loss: {:.4f}".format(train_loss_g))
if steps % 100 == 0:
show_generator_output(sess, 16, input_z, data_shape[3], data_image_mode)
return
Test your GANs architecture on MNIST. After 2 epochs, the GANs should be able to generate images that look like handwritten digits. Make sure the loss of the generator is lower than the loss of the discriminator or close to 0.
batch_size = 64
z_dim = 100
learning_rate = 0.0001
beta1 = 0.5
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
epochs = 2
mnist_dataset = helper.Dataset('mnist', glob(os.path.join(data_dir, 'mnist/*.jpg')))
with tf.Graph().as_default():
train(epochs, batch_size, z_dim, learning_rate, beta1, mnist_dataset.get_batches,
mnist_dataset.shape, mnist_dataset.image_mode)
Run your GANs on CelebA. It will take around 20 minutes on the average GPU to run one epoch. You can run the whole epoch or stop when it starts to generate realistic faces.
batch_size = 64
z_dim = 128
learning_rate = 0.0002
beta1 = 0.5
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
epochs = 1
celeba_dataset = helper.Dataset('celeba', glob(os.path.join(data_dir, 'img_align_celeba/*.jpg')))
with tf.Graph().as_default():
train(epochs, batch_size, z_dim, learning_rate, beta1, celeba_dataset.get_batches,
celeba_dataset.shape, celeba_dataset.image_mode)
When submitting this project, make sure to run all the cells before saving the notebook. Save the notebook file as "dlnd_face_generation.ipynb" and save it as a HTML file under "File" -> "Download as". Include the "helper.py" and "problem_unittests.py" files in your submission.


# Atom Developer Documentation
Welcome to Atom's Developer Documentation. This guide will get you up and running for creation of a client to interact with Atom. We strongly recommend looking at the accompanying C# client implementation for a detailed example of how client interaction works. Good luck!
*This documentation was last updated: July 29 2016.*
---
## Table of Contents
1. [Introduction](#intro)
2. [Setting Up Your Environment](#setup_env)
3. [Connecting to Atom](#connecting_atom)
4. [Receiving Messages](#recv_msg)
5. [Responding to Messages](#resp_msg)
6. [Watching and Unwatching Nodes](#watch_unwatch)
7. [Example Workflow](#example_workflow)
8. [Listing of All Messages](#all_msg)
---
## Introduction
Atom is based on a similar system to Maya. There are raw data nodes, which represent shapes, such as meshes, camera, lights, and so on, and there are transform nodes, that act as parents to shape nodes.
Atom is developed such that transform nodes can be completely ignored, and each shape node can be individually used. For instance, *Mesh* nodes contain a world matrix that can be used to place its local space vertices into world space. This works fine, but without using the transform nodes, features such as instancing do not exist. In other words, all shape nodes contain a standalone world matrix (or equivalent) intended to be used without the parent transforms. If multiple instances of the shape node exist, the first matrix is taken.
Ideally, shape nodes should be treat as data only, and the transforms should reference the data accordingly. As an example, a transform may contain a mesh shape node. The mesh shape node would contain the geometric data in local space, whereas the transform node would tell the referenced mesh where to be placed in world space.
All nodes are named, and these names are used to update nodes when they change. It is up to you how you identify the nodes based on the given ID from Atom. For example, the name could be used directly, or hashed. What is important is that you can locate existing nodes by a given name.
---
## Setting Up Your Environment
Atom makes extensive use of Google's [Protocol Buffers](https://developers.google.com/protocol-buffers/) library. Specifically, Atom uses version [3.0.0-beta-2](https://github.com/google/protobuf/releases/tag/v3.0.0-beta-2). Your client must use one of the many languages that Protocol Buffers supports.
You must link the Protocol Buffer dependencies into your project. Follow Google's tutorial for your chosen language for this. A number of library binaries are provided by Google, but some may require building.
Once done, add the compiled Protocol Buffers files for your language to your project accordingly. Feel free to rebuild them from the .proto source, but **do not** modify them. Ensure that your project is able to build with the files added before continuing.

---
## Connecting to Atom
Atom uses TCP for communications to ensure data integrity. Connecting to Atom is the same as connecting to any other server. Make a TCP client and connect to with the IP address and port of the host machine running Atom. This can be a local connection on the same computer, too.
---
## Receiving Messages
Messages from Atom are stored in the format of a header followed by a Protocol Buffer message in the form of raw bytes. The header is a packed integer representing the size in bytes of the following Protocol Buffer data.
The first **four bytes** of any given message are the header. These are written using **little endian**. When these bytes are read, they can be unpacked to form a 32-bit signed integer. For example, in C#:
```csharp
// where readBuffer contains the first four bytes
int dataSize = BitConverter.ToInt32(readBuffer, 0);
```
After unpacking the size of the remaining data, read it all into a **separate** buffer. The remaining Protocol Buffer data will always be of type **AtomMessage**, and after all data has been read, can safely be parsed. In C#, it looks something like this:
```csharp
// where readBuffer contains only the Protocol Buffer bytes, without the header
Atom.Proto.AtomMessage msg = Atom.Proto.AtomMessage.Parser.ParseFrom(readBuffer);
```
You are then free to respond to the message as fit. See the [Listing of All Messages](#all_msg) below for more information on how to handle the message data.
---
## Responding to Messages
When responding to Atom messages, your data should be in a single buffer, in the same form as is received: a header followed by data. The header must be a 32-bit signed integer packed into **four bytes** using **little endian** ordering. This integer must be the size in bytes of the data following. The data following is interpreted in Atom as a string of characters. Here is an example of how to do this in C#:
```csharp
// where Data is a variable somewhere, and userDataSize is the size of userData in bytes
void build_message( byte[] userData, Int32 userDataSize ) {
Data = new MemoryStream();
byte[] header = BitConverter.GetBytes(userDataSize);
Data.Write(header, 0, HEADER_SIZE);
Data.Write(userData, 0, userDataSize);
}
```
---
## Watching and Unwatching Nodes
When you connect to Atom, you will be sent a *Scene* message containing a proxy of the current scene in the form of node types and names. It is your job to decide which nodes you would like Atom to send to you.
To register your client to receive node information, use the **watch** command. Its syntax is: **watch node_name;**. For example:
```
watch pCubeShape1;
```
If at any time you want to stop receiving node information, you can use the **unwatch** command. Its syntax is: **unwatch node_name;**. For example:
```
unwatch pCubeShape1;
```
Both of these commands should be sent to the server as described in [Responding to Messages](#resp_msg).
---
## Example Workflow
This section will briefly describe an example workflow based on the accompanying C# client. As seen in the figure below, the interaction with Atom can be broken up into three major parts.
![images/SimpleWorkflow.png](images/SimpleWorkflow.png)
The first stage involves connecting to Atom using a TCP client. The correct port and hostname should be confirmed before attempting to connect. If Atom detects issues with the connection, it may terminate it.
After a connection has been established, Atom will send an *AtomMessage* with the *Scene* set. This is a proxy representation of the scene, with only node types and names being sent. At this stage, your job is to decide which nodes you would like to receive information for. Atom expects you to send the **watch** command for each node you want to register interest in. Providing the command is sent correctly and the given node can be found, Atom will set up a link to automatically propagate changes of the given note to your client. It is worth mentioning that the *Scene* message can be sent for other purposes too, and you are able to likewise respond at any of those stages. See the [Scene](#msg_scene) message for more information.
After you have told Atom which nodes you want to listen to with the **watch** command, you should handle all of the [other related messages](#all_msg) accordingly. If at any point you want to stop receiving information about a node, just use the aforementioned **unwatch** command.
When the connection is terminate either from Atom or from your client, all links will be broken, and the client is free to reconnect.
---
## Listing of All Messages
Every incoming message from Atom will have Protocol Buffer data of type **AtomMessage**. This message acts as a container for all possible messages Atom sends. Each will be discussed below.
* Data Classes
* [Vector2](#msg_vector2)
* [Vector3](#msg_vector3)
* [Color](#msg_color)
* [Matrix](#msg_matrix)
* [Vertex](#msg_vertex)
* Lights
* [LightType](#msg_light_type)
* [Light](#msg_light)
* [LightChanged](#msg_light_changed)
* Meshes
* [Mesh](#msg_mesh)
* [MeshGeometryChanged](#msg_mesh_geometry_changed)
* [MeshPointsChanged](#msg_mesh_points_changed)
* [MeshMaterialChanged](#msg_mesh_material_changed)
* Materials and Textures
* [TextureData](#msg_texture_data)
* [Texture](#msg_texture)
* [TextureChanged](#msg_texture_changed)
* [MaterialType](#msg_material_type)
* [TexturedParameter](#msg_textured_parameter)
* [Material](#msg_material)
* [Lambert](#msg_lambert)
* [Blinn](#msg_blinn)
* [Phong](#msg_phong)
* [PhongE](#msg_phonge)
* [Anisotropic](#msg_anisotropic)
* [MaterialChanged](#msg_material_changed)
* Other Shapes
* [Annotation](#msg_annotation)
* [Camera](#msg_camera)
* [Curve](#msg_curve)
* Other Classes
* [Scene.Reason](#msg_scene_reason)
* [SceneObject](#msg_scene_object)
* [Scene](#msg_scene)
* [Component.ComponentType](#msg_component_type)
* [Component](#msg_component)
* [Transform](#msg_xform)
* [MatrixChanged](#msg_matrix_changed)
* [NameChanged](#msg_name_changed)
* [VisibilityChanged](#msg_visibility_changed)
#### *AtomMessage*
A generic container for all other message types.
Contains every potential message Atom will send. Uses Protocol Buffer's **oneof** feature, so only one will be set at a time. The actual set message can be detected using a switch statement. For instance, in C#:
```csharp
switch( msg.MsgCase ) {
case Atom.Proto.AtomMessage.MsgOneofCase.Camera: {
// handle camera
break;
}
// handle other types
}
```
#### *Vector2* [↑](#all_msg)
Floating point 2D vector.
| Variable | Type | Description |
| --- | --- | --- |
| x | float | X component |
| y | float | Y component |
#### *Vector3* [↑](#all_msg)
Floating point 3D vector.
| Variable | Type | Description |
| --- | --- | --- |
| x | float | X component |
| y | float | Y component |
| z | float | Z component |
#### *Color* [↑](#all_msg)
Floating point RGBA color.
| Variable | Type | Description |
| --- | --- | --- |
| r | float | Red channel |
| g | float | Green channel |
| b | float | Blue channel |
| a | float | Alpha channel |
#### *Matrix* [↑](#all_msg)
Floating point matrix. Almost always 4x4 world matrix.
| Variable | Type | Description |
| --- | --- | --- |
| Rows | uint32 | Number of rows (usually 4) |
| Cols | uint32 | Number of columns (usually 4) |
| M | float[] | Array of floats, with Rows*Cols elements |
#### *Vertex* [↑](#all_msg)
Full-fat vertex structure. Lists contain one element per UV/color set respectively.
| Variable | Type | Description |
| --- | --- | --- |
| Index | int32 | Vertex physical index |
| Position | Vector3 | Vertex position |
| Normal | Vector3 | Vertex normal |
| Texcoord | List | One texcoord per UV set |
| Tangent | List | One tangent per UV set |
| Binormal | List | One binormal per UV set |
| Color | List | One color per color set |
#### *LightType* [↑](#all_msg)
Used in the *Light* message to determine the type of the light source.
| Enumeration | Description |
| --- | --- |
| kLightTypeAmbient | Is an ambient light |
| kLightTypeDirectional | Is a directional light |
| kLightTypeSpot | Is a spot light |
| kLightTypePoint | Is a point light |
#### *Light* [↑](#all_msg)
Represents all supported types of MFn::kLight and derivations. All light types share this one class. The type of light source can be determined with *Type*. *Position* and *Direction* are provided to use a light without a parent *Transform*.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
| Type | LightType | Type of light source |
| Position | Vector3 | World space position (point, spot) |
| Direction | Vector3 | World space direction (directional, spot) |
| Range | float | Light range (point: radius, spot: height) |
| Color | Color | Light color |
| Intensity | float | Light intensity |
| ConeAngle | float | Interior cone angle in degrees (spot) |
| PenumbraAngle | float | Penumbra angle in degrees (spot) |
| Dropoff | float | Light dropoff (spot) |
| Shadows | bool | Whether shadows are enabled or not |
| ShadowResolution | int32 | Shadow map resolution |
| ShadowBias | float | Shadow bias |
| ShadowColor | Color | Shadow color |
| InitialVisibility | bool | Initial visibility |
#### *LightChanged* [↑](#all_msg)
This message is sent when an existing *Light* node changes one of its properties, such as the color changing. The *LightName* states which light, by name, changed. All possible light parameters are included. Only a single parameter will be valid. The set parameter can be determined with the *PropertyCase* enumeration.
| Variable | Type | Description |
| --- | --- | --- |
| LightName | string | Name of the light node that changed |
| PropertyCase | oneof | Enumeration for which property changed |
#### *Mesh* [↑](#all_msg)
These nodes represent nodes of type MFn::kMesh. The data is already prepared into an indexed triangle list. Both *Vertices* and *Indices* can be placed into respective buffers and drawn accordingly. The *MaterialName* can be used to look up an assigned *Material* node. To use the node without a parent *Transform*, the world matrix is also included.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
| Vertices | List | List of vertices |
| Indices | List | List of indices |
| TexcoordSetNames | List | List of UV set names |
| MaterialName | string | Assigned *Material* node name |
| World | Matrix | World matrix |
| InitialVisibility | bool | Initial visibility |
#### *MeshGeometryChanged* [↑](#all_msg)
This message is sent when an existing *Mesh* node's geometry is destructively changed, i.e. the number of vertices or indices is modified. The new *Vertices* and *Indicies* lists should directly replace previous geometry.
| Variable | Type | Description |
| --- | --- | --- |
| MeshName | string | Name of the mesh node that changed |
| Vertices | List | List of new vertices |
| Indices | List | List of new indices |
#### *MeshPointsChanged* [↑](#all_msg)
This message is sent when an existing *Mesh* node's vertices are modified in a non-destructive way, i.e. data, such as position, are changed in place without changing the number or order of vertices. Each modified *Vertex* can be matched with their *Index* parameter. For instance, if only vertex 42 was modified, the single element in *Vertices* would have its *Index* property set to 42.
| Variable | Type | Description |
| --- | --- | --- |
| MeshName | string | Name of the mesh node that changed |
| Vertices | List | List of changed vertices |
#### *MeshMaterialChanged* [↑](#all_msg)
This message is sent when an existing *Mesh* node has its material changed. The new *Material* node can be looked up by the provided *MaterialName* parameter.
| Variable | Type | Description |
| --- | --- | --- |
| MeshName | string | Name of the mesh node that changed |
| MaterialName | string | Name of the new assigned *Material* |
#### *TextureData* [↑](#all_msg)
This message represents texture data to be used by a *Texture* node. If the file is accessible locally, *Filename* can be used to load the file. If the file is not available, the raw *Bytes* of the texture can be used, along with *Extension* to assist with loading the correct filetype.
| Variable | Type | Description |
| --- | --- | --- |
| Filename | string | Filename of the texture |
| Extension | string | File extension of the texture |
| Bytes | bytes | Raw byte array of the texture |
#### *Texture* [↑](#all_msg)
This message represents nodes and derivations of type MFn::kFileTexture. The filename and texture bytes can be used to load the texture with *Data*. The remaining parameters control manipulation of the UVs associated with this texture instance. For example, wrapping, tiling, and so on.
| Variable | Type | Description |
| --- | --- | --- |
| TextureName | string | Name of the node |
| Data | TextureData | Filename and raw bytes |
| TranslateFrame | Vector2 | Position of texture frame |
| RotateFrame | float | Rotation of texture frame |
| MirrorU | bool | Whether to mirror UVs in U |
| MirrorV | bool | Whether to mirror UVs in V |
| WrapU | bool | Whether to wrap UVs in U |
| wrapV | bool | Whether to wrap UVs in V |
| Repeat | Vector2 | UV tiling |
| Offset | Vector2 | UV offset |
| Rotate | float | UV rotation in degrees |
| Noise | Vector2 | Arbitrary noise |
#### *TextureChanged* [↑](#all_msg)
This message is sent when an existing *Texture* node changes one of its properties, such as its associated UV placement information. Even the data itself can change if the texture file was changed. All possible texture parameters are included. Only a single parameter will be valid. The set parameter can be determined with the *PropertyCase* enumeration.
| Variable | Type | Description |
| --- | --- | --- |
| TextureName | string | Name of the *Texture* node that changed |
| PropertyCase | oneof | Enumeration for which property changed |
#### *MaterialType* [↑](#all_msg)
Used in the *Material* message to determine the type of the shading model.
| Enumeration | Description |
| --- | --- |
| kMaterialTypeLambert | Is a *Lambert* shader |
| kMaterialTypePhong | Is a *Phong* shader |
| kMaterialTypePhongE | Is a *PhongE* shader |
| kMaterialTypeBlinn | Is a *Blinn* shader |
| kMaterialTypeAnisotropic | Is an *Anisotropic* shader |
#### *TexturedParameter* [↑](#all_msg)
Most *Material* parameters can be either textured or retrieved by value. This message gives the *Texture* node name associated with the parameter (is an empty string if no such connection exists). In addition, the non-textured value can be accessed as either a float or color. Only one float or color can be set at the same time; not both. The *ParameterCase* enum can help distinguish, although this is often not required, as the used types are documented elsewhere.
| Variable | Type | Description |
| --- | --- | --- |
| Texture | string | Parameter as *Texture* node name |
| AsFloat | float | Parameter as float |
| AsColor | Color | Parameter as Color |
#### *Material* [↑](#all_msg)
This message represents a combination of shading groups (MFn::kShadingEngine) and supported surface shader types. The name is derived from the shading group rather than the shader itself. Only a single shader message will be set, which can be queried with the *DataCase* enumeration or the *Type* enumeration.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
| Type | MaterialType | Type of shader used |
| Lambert | Lambert | *Lambert* shader message |
| Phong | Phong | *Phong* shader message |
| PhongE | PhongE | *PhongE* shader message |
| Blinn | Blinn | *Blinn* shader message |
| Anisotropic | Anisotropic | *Anisotropic* shader message |
#### *Lambert* [↑](#all_msg)
Lambert shading parameters used in *Material* messages.
| Variable | Type | Description |
| --- | --- | --- |
| Color | TexturedParameter | Base color; *AsColor* |
| Transparency | TexturedParameter | Transparent color; *AsColor* |
| AmbientColor | TexturedParameter | Ambient color; *AsColor* |
| Incandescence | TexturedParameter | Incandescent color; *AsColor* |
| BumpMap | string | Name of bump map *Texture* |
| DiffuseAmount | TexturedParameter | Diffuse intensity; *AsFloat* |
| Translucence | TexturedParameter | Translucent amount; *AsFloat* |
| TranslucenceDepth | TexturedParameter | Translucent depth; *AsFloat* |
| TranslucenceFocus | TexturedParameter | Translucent focus; *AsFloat* |
| GlowIntensity | TexturedParameter | Glow intensity; *AsFloat* |
#### *Blinn* [↑](#all_msg)
Blinn shading parameters used in *Material* messages.
| Variable | Type | Description |
| --- | --- | --- |
| All from *Lambert* | n/a | n/a |
| Eccentricity | TexturedParameter | Eccentricity; *AsFloat* |
| SpecularRollOff | TexturedParameter | Specular roll off; *AsFloat* |
| SpecularColor | TexturedParameter | Specular color; *AsColor* |
| Reflectivity | TexturedParameter | Reflectivity amount; *AsFloat* |
| ReflectedColor | TexturedParameter | Reflected color; *AsColor* |
#### *Phong* [↑](#all_msg)
Phong shading parameters used in *Material* messages.
| Variable | Type | Description |
| --- | --- | --- |
| All from *Lambert* | n/a | n/a |
| CosinePower | TexturedParameter | Specular power; *AsFloat* |
| SpecularColor | TexturedParameter | Specular color; *AsColor* |
| Reflectivity | TexturedParameter | Reflectivity amount; *AsFloat* |
| ReflectedColor | TexturedParameter | Reflected color; *AsColor* |
#### *PhongE* [↑](#all_msg)
PhongE shading parameters used in *Material* messages.
| Variable | Type | Description |
| --- | --- | --- |
| All from *Lambert* | n/a | n/a |
| Roughness | TexturedParameter | Surface roughness; *AsFloat* |
| HighlightSize | TexturedParameter | Size of highlight; *AsFloat* |
| Whiteness | TexturedParameter | Whiteness; *AsColor* |
| SpecularColor | TexturedParameter | Specular color; *AsColor* |
| Reflectivity | TexturedParameter | Reflectivity amount; *AsFloat* |
| ReflectedColor | TexturedParameter | Reflected color; *AsColor* |
#### *Anisotropic* [↑](#all_msg)
Anisotropic shading parameters used in *Material* messages.
| Variable | Type | Description |
| --- | --- | --- |
| All from *Lambert* | n/a | n/a |
| Angle | TexturedParameter | Angle; *AsFloat* |
| SpreadX | TexturedParameter | Spread X; *AsFloat* |
| SpreadY | TexturedParameter | Spread Y; *AsFloat* |
| Roughness | TexturedParameter | Surface roughness; *AsFloat* |
| FresnelIndex | TexturedParameter | Fresnel index of refraction; *AsFloat* |
| SpecularColor | TexturedParameter | Specular color; *AsColor* |
| Reflectivity | TexturedParameter | Reflectivity amount; *AsFloat* |
| ReflectedColor | TexturedParameter | Reflected color; *AsColor* |
#### *MaterialChanged* [↑](#all_msg)
This message is sent when an existing *Material* node's parameters change. Every parameter from all shader types are included. The specific parameter that changed can be filtered out with the *PropertyCase* enumeration.
| Variable | Type | Description |
| --- | --- | --- |
| MaterialName | string | Name of the *Material* node that changed |
| PropertyCase | oneof | Enumeration of which property changed |
#### *Annotation* [↑](#all_msg)
Represents nodes of type MFn::kAnnotation. Can be used to add labels to scenes.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
| Text | string | Displayed text |
| World | Matrix | World matrix |
| InitialVisibility | bool | Initial visibility |
#### *Camera* [↑](#all_msg)
Represents MFn::kCamera nodes. Contains camera data required to build view and projection matrices. Useful for synchronizing Maya's camera with a client camera.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
| Position | Vector3 | World space position |
| Target | Vector3 | World space target location |
| Up | Vector3 | World space up direction |
| FieldOfView | float | Field of view in degrees |
| AspectRatio | float | Viewport aspect ratio |
| NearPlane | float | Frustum near plane |
| FarPlane | float | Frustum far plane |
| InitialVisibility | bool | Initial visibility |
#### *Curve* [↑](#all_msg)
Represents all curves of type MFn::kNurbsCurve (including derivations, such as Bézier).
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
| CV | List | List of control vertices of the curve |
| World | Matrix | World matrix |
| InitialVisibility | bool | Initial visibility |
#### *Scene.Reason* [↑](#all_msg)
Used in *Scene* messages to determine the reason for the scene being sent.
| Enumeration | Description |
| --- | --- |
| kRebuildOnConnected | Current scene is sent upon a client connecting |
| kRebuildOnNew | A new scene was created; can be treat as empty |
| kRebuildOnOpen | A new scene was opened; can be treat as a full new scene |
| kAdded | Nodes listed have been added to the scene |
| kRemoved | Nodes listed have been removed from the scene |
#### *SceneObject* [↑](#all_msg)
Represents a single node by name in *Scene* messages.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
#### *Scene* [↑](#all_msg)
A listing of *SceneObject* nodes. Use *TransferReason* to determine the nature of the scene transfer. After connecting to Atom, clients are sent the current scene with lists populated accordingly. When a new scene is created, the lists will be empty and the client can reset their scene. When a new scene is opened, it can be treat as a full scene replacement, and all lists will be populated accordingly. When nodes are added or removed, they are listed correspondingly. The purpose of this message is for clients to get a proxy representation of the Maya scene and then send watch requests for nodes they care about.
| Variable | Type | Description |
| --- | --- | --- |
| TransferReason | Scene.Reason | Reason the scene was transferred |
| Meshes | List | List of mesh SceneObjects |
| Lights | List | List of light SceneObjects |
| Cameras | List | List of camera SceneObjects |
| Materials | List | List of material SceneObjects |
| Textures | List | List of texture SceneObjects |
| Transforms | List | List of transform SceneObjects |
| Annotations | List | List of annotation SceneObjects |
| Curves | List | List of curve SceneObjects |
#### *Component.ComponentType* [↑](#all_msg)
Used in *Component* messages to determine the component type.
| Enumeration | Description |
| --- | --- |
| kMesh | Component represents a mesh node |
| kLight | Component represents a light node |
| kCamera | Component represents a camera node |
| kAnnotation | Component represents an annotation node |
| kCurve | Component represents a curve node |
#### *Component* [↑](#all_msg)
Represents a component (shape node) of a *Transform*. It references the real node by name.
| Variable | Type | Description |
| --- | --- | --- |
| Type | Component.ComponentType | Type of the component |
| Name | string | Name of the component node |
#### *Transform* [↑](#all_msg)
Represents an MFn::kTransform node. Contains a *Component* list, where each element links to a typed shape node (e.g. mesh, camera, light). All components should be treat as references, such that a *Transform* never owns directly, but instead uses the nodes it links to. This allows for instancing. A world matrix is also provided.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node |
| World | Matrix | World matrix |
| Components | List | List of component shape nodes to reference |
| InitialVisibility | bool | Initial visibility |
#### *MatrixChanged* [↑](#all_msg)
This is sent when a node's matrix is changed.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node whose matrix changed |
| Matrix | Matrix | New matrix |
#### *NameChanged* [↑](#all_msg)
This is sent when a node's name is changed. After this message is sent, all messages referring to the node in question will use the *NewName* identifier.
| Variable | Type | Description |
| --- | --- | --- |
| OldName | string | Name of the node whose name changed |
| NewName | string | New name of the node |
#### *VisibilityChanged* [↑](#all_msg)
This is sent when a node's visibility is changed.
| Variable | Type | Description |
| --- | --- | --- |
| Name | string | Name of the node whose visibility changed |
| Visible | bool | New visibility |