@import models.user.User @(title: String, user: Option[User] = None)(implicit lang: Lang) @main(title) { @navbar(user)
Thanks for chipping in! You can help us out by using our tool to audit the accessibility of neighborhoods. By accessibility audit, we mean:
Please watch the following video to see a demo of how an accessibility audit works:
Yes! Just follow these steps:
Google Street View provides a rich visual data source to inspect a city without leaving your home. However, the images shown are collected periodically every few years. Hence, they might be out of date. Indeed, some users have reported that problems shown in our interface have recently been resolved. Generally, however, street-level infrastructure does not change very often. We have conducted two studies of our own that compare audit data from our online interfaces to audit data collected via traditional, in-person walk-around audits [1,2]. In both cases, we found high agreement--in other words, the images in Google Street View are a good representation of the state of the physical world. This is consistent with findings from previous studies [3, 4, 5].
Moreover, with the advancement of GSV technology, imagery is likely to become even more accurate than it is already.
On larger screens, the interface looks pretty small by default. You can make it larger
by zooming in using your browser. You can do this on a Mac by holding down
Cmd
and typing +
. On Windows, you would hold Ctrl
and type +
.
The Jump button can be used when you would like to be exploring a different area for any reason; it allows you to start exploring a entirely different neighborhood! The Stuck button can be used when you get stuck! This can happen when the arrows on the Google Street View interface are missing, difficult to click on, or pointing in the wrong direction. The Stuck button will try to move you slightly further along your route. You can use it multiple times in a row if it doesn't move you to the right place on the first attempt.
Sometimes while auditing, you may have noticed that the navigation arrows go missing,
especially when going straight. Worry not, there is a simple solution!
Just click on the "Stuck" button on the left side of the screen! If you still cannot
move forward, keep clicking the Stuck button until you are moved to a better spot.
From time to time, you'd observe Street View images taken at the same location at different time, and the environment in the images may be conflicting--just like the pair of the Street View images shown above. In the older image on the left, there is no curb ramp at the end of the crosswalk, but the problem is fixed in the newer image on the right. If you find a similar case, please label the accessibility features in both images so we can keep track of how the environment has changed over time!
Yes, you're right, labels do disappear after you move in Google Street View but don't worry, we store all of your labels.
So, why does it work like this? Well, the answer is kind of complicated but the short answer is: the Google Street View interface is akin to a 3-dimensional interface, similar to moving about in the real world. When you place a label, we convert the 3D position of the label to a 2D lat/long position. However, once you move to a new location, we cannot accurately recompute the label's position in 3D for that new view. See, we told you it was kind of complicated. :) Rest assured, you can always see your applied labels in the top-down map in the bottom-right hand corner of your screen.
Yes. THere is the list of keyboard shortcuts in the table below. There are also keyboard shortcuts for adding tags on the Explore page; there should be an underlined letter on each tag to indicate the keyboard shortcut.
| Key | What it does | |
|---|---|---|
| Mode Switch | E | Switch to Exploration mode |
| C | Switch to Curb Ramp mode | |
| M | Switch to Missing Curb Ramp mode | |
| O | Switch to Obstacle in Path mode | |
| S | Switch to Surface Problem mode | |
| N | Switch to "No Sidewalk" mode | |
| W | Switch to Crosswalk mode | |
| P | Switch to Pedestrian Signal mode | |
| B | Switch to "Can't see the sidewalk" mode | |
| Severity Rating | 1 2 3 4 5 | Set corresponding rating |
| Enter or Esc | Close label menu | |
| Interface Control | Z | Zoom in |
| Shift + Z | Zoom out | |
| Up | Move Forward | |
| Down | Move Back | |
| Left | Rotate point of view left | |
| Right | Rotate point of view right | |
| H | Show or hide label (only on Validate page) |
Sometimes the Street View window images could not be correctly loaded and you see nothing but a grey window even if you move around. This could happen for various reasons, e.g., you could be in a location where Google Street View images are not available. To fix this, you can reload your page. Note that all of your previous labels will be saved and you can continue your current mission after reloading.
Yes, here are some examples:
You have more questions? Email us (sidewalk@@cs.uw.edu), post a GitHub issue, or follow and talk to us on Twitter (@@projsidewalk)!


Unfortunately, an error occurred when loading the page you requested
{% if message %}
This is the error that occurred:
{{ message }}
{% else %}
We're very sorry about this and are working on a fix!
{% endif %}


cv
General Information
| Full Name | Emmanouil Antonios Platanios |
| Date of Birth | 7th July 1991 |
| Nationality | Greek |
| Languages | Greek (native), English (fluent), and German (beginner) |
Research Areas
- Machine learning and artificial intelligence with a focus on learning collections of functions, neural cognitive architectures, and applications of AI and ML to natural language processing, robotics, computer vision and finance.
Education
-
2013-2020
Carnegie Mellon University – Ph.D. in Machine Learning.
- Awarded the CMU Presidential Fellowship.
- GPA: 4.18 (4.0 scale).
- Advisor: Prof. Tom M. Mitchell.
- I worked on the Never Ending Language Learning (NELL) project.
- My thesis work was on Learning Collections of Functions.
-
I performed research on topics related to self-reflection in machine learning:
- I developed multiple methods for using unlabeled data to estimate the accuracies of several different classifiers performing the same task, that I have presented at Uncertainty in Artificial Intelligence (UAI) in 2014, International Conference in Machine Learning (ICML) in 2016, and at Neural Information Processing Systems (NIPS) in 2017.
- I developed a method for performing low-resource and zero-shot multilingual machine translation.
- I am developing a self-reflection mechanism for machine learning systems and I am applying it in NELL.
- I am working on a new framework for learning where agreement among multiple agents is the objective.
-
2013-15
Carnegie Mellon University – M.S. in Machine Learning.
- GPA: 4.18 (4.0 scale).
- Advisor: Prof. Tom M. Mitchell.
- Thesis: Estimating Accuracy from Unlabeled Data.
- Master's degree requirements completed while working towards obtaining my Ph.D. in machine learning.
-
2009-13
Imperial College London – M.Eng. and ACGI in Electrical and Electronic Engineering.
- Integrated Bachelor's and Master's degree.
- Dean’s List for exceptional academic performance (all four years).
-
Grade: 91.67% (top 1% of class) with 92.37% on the final exams – First-Class Honors Degree.
- Equivalent to 4.0 GPA in the USA academic system.
-
Thesis Title: Human Motion Classification Using Statistical Machine Learning Methods.
- Awarded the Sir Bruce White prize in engineering for the best final year project.
-
Third Year Summer Research Project: "Bayesian Machine Learning Methodologies for Modeling Time Series with High Volatility".
- Volatility modeling and prediction in a multitude of applications with significance both for industry (e.g. finance) and academia.
Work Experience
-
2022-now
Principal Researcher at Microsoft Semantic Machines.
- Manager: Dan Klein, Technical Fellow.
- Leading a team working on a project related to user behavior modeling that cannot yet be shared publicly.
-
2020-2022
Senior Researcher at Microsoft Semantic Machines.
- Manager: Dan Klein, Technical Fellow.
- Designed and shipped a contextual semantic parser that powers the Semantic Machines conversational AI platform.
- Worked on multiple research projects leading to academic publications at the intersection of natural language processing and machine learning.
-
2016-17
Research Analyst Consultant at Cubist Systematic Strategies.
- Worked for the Advanced Methods Groups (AMG) in new machine learning-driven approaches for end-to-end algorithmic trading systems.
- Developed the main pipeline for trading algorithms research and for integrating these algorithms in a new production system.
-
2015
Research Intern at Microsoft Research.
- Manager: Dr. Eric Horvitz, Distinguished Scientist and Managing Director of Microsoft Research.
- Collaborators: Dr. Hoifung Poon and Dr. Ashish Kapoor.
- First 3 months: Developed a probabilistic logic-based approach for accuracy estimation using unlabeled data, as part of the Literome Project.
- Last 3 months: Active learning amidst logical knowledge.
-
2010-13
Co-Founder, President and Chief Technology Officer (CTO) at Holic.
- Developed an intelligent news reader application.
- Developed algorithms utilizing advanced nonparametric Bayesian models for clustering news articles and for user profiling.
-
Received €400,000 funding from the following investors:
- Dr. John Coustas, President & CEO of Danaos Corporation.
- Mr. Leon Yohai, Founder & CEO of ZuluTrade.
-
2008-10
Founder of Project Protasis – Forest Protection.
- Developed a forest fire detection and prevention system.
- Developed both hardware and software (involving use of neural networks for recognizing fire and smoke in photos).
- Installed prototype in “Alsos Syggrou”, a wooded area in Athens, funded by the Greek government.
- Got patent approved in Greece (Patent #:<PHONE_NUMBER>6) and international patent pending approval.
- Interviewed by CNN, as well as several newspapers, magazines and other TV channels, regarding this project.
- Won the 2nd place in the Microsoft Imagine Cup 2009 Greek Finals with this project.
-
2010
Web Designer and Software Developer at Curtainmakers S.A.
-
2009-10
Software Developer at vWorker.com.
-
2007-09
Founder of Project Protasis – Home Automation.
- Developed a smart home automation system that controls all electrical appliances, heating systems and water systems and aims to reduce domestic energy consumption while making the lives of homeowners as comfortable as possible.
- Developed software, employing several machine learning algorithms.
- Was funded by the Greek government and more specifically, by the Organization of School Buildings.
- Interviewed by NBC, as well as several newspapers, magazines and other TV channels, regarding this project.
- Won the Microsoft Imagine Cup 2008 Greek Finals with this project and represented Greece in the Imagine Cup 2008 Worldwide Finals, in Paris, France, competing against teams from universities, at age of only 16 and having worked without a team or a mentor.
-
2007-08
Software Developer and I.T. Professional at Sigma Group Inc.
-
2006
Software Developer and I.T. Professional at Embiria S.A.
Open Source Projects
-
2017-now
TensorFlow Scala.
- Machine learning library and API for the TensorFlow framework developed by Google, that is currently being used by multiple researchers and companies (~900 GitHub stars).
-
2019-20
Swift for TensorFlow.
- I was a contributor tp this project, which is a machine learning library and API for the TensorFlow framework developed by Google, and that enables differentiable programming.
-
2018
Symphony MT.
- Machine translation library written in Scala, that supports various models along the whole translation pipeline (i.e., ranging from data preprocessing and vocabulary generation, to multiple encoder and decoder models).
-
2014-16
Makina.
- Machine learning and optimization library written in Java that includes a scalable implementation of the Probabilistic Soft Logic (PSL) framework.
Honors and Awards
-
2017
- 2nd place in the CMU NeuroHackathon.
-
2016
- CMU Presidential Fellowship.
-
2010-13
- Sir Bruce White prize in engineering for the best M.Eng. thesis at Imperial College London.
- Dean's List at Imperial College London, for exceptional academic performance (all four years).
-
2010
- Nominated for the RAE (UK Royal Academy of Engineering) presentation skills award.
- "Roll of Honor" of the Electrical and Electronic Engineering department of Imperial College London, for the best software design project in the year.
-
2009
- Congratulatory diploma for my work on "Project Protasis – Home Automation" by UNESCO.
- Honorary plaque by the Greek Minister of Education and Religious Affairs for honoring my country internationally.
-
2007-08
- Full scholarship (of about €12,000) by "Geitonas School", for honoring my school internationally.
- Had a computer science laboratory named after me in “Geitonas School”, for honoring my school internationally.
- Awarded €1,000 by the President of the Greek Parliament, for honoring my country internationally.
- Honorary plaque by the Mayor of my city, Vari, in Greece, for honoring my country internationally.
- Represented Greece in the Microsoft Imagine Cup 2008 Worldwide Finals, in Paris, France, with "Project Protasis - Home Automation".
- 1st place in the Microsoft Imagine Cup 2008 Greek Finals with "Project Protasis - Home Automation", competing against teams from universities, at age of only 16 and having worked without a team or a mentor (also won the 2nd place in the Microsoft Imagine Cup 2009 Greek Finals with "Project Protasis - Forest Protection").
-
2007
- Certificate of Excellence for the school year 2006-07 from the Greek Ministry of Education and Religious Affairs.
- 3rd place (bronze medal) in the Greek Mathematics Olympiad, organized by the Hellenic Mathematical Society.
-
2003-07
- 11 scholarships and competitions in the fields of mathematics, sciences and computer science.
Teaching Experience
-
2018
Provided support for an advanced graduate-level course on machine learning at Carnegie Mellon University.
- Class: 10-812 Architectures for Never-Ending Learning.
- Taught by Prof. Tom Mitchell.
- Gave a couple of lectures and helped with the organization of the class.
- Designed and co-led the implementation of the software testbed used to support the course projects.
- Mentored several students working on class projects.
-
2014, 16
Teaching Assistant for a graduate-level machine learning course at Carnegie Mellon University.
- Class: 10-701/15-781 Introduction to Machine Learning.
- Did this for two semesters (taught by Prof. Geoff Gordon and Prof. Aarti Singh in 2014, and Prof. Tom Mitchell in 2016).
- Gave some lectures and some recitation lectures.
- Mentored several groups of students working on class projects.
- Wrote and graded homework assignments and exams.
Services
-
Program Committees
- ACL (2020), ICML (2019), NeurIPS (2018-19), EMNLP (2018-19), PLOS-ONE (2018-19), IEEE-TPAMI (2018), and NIPS-AKBC (2016).
-
Conference Workshops Organized
- 2019: ICML Adaptive & Multi-Task Learning.
- 2019: ICLR Learning with Limited Labeled Data.
- 2017: NIPS Learning with Limited Labeled Data.
-
University Committees
- 2018-19: CMU AI+ Club co-founder and leadership team member.
- 2018-19: Doctoral review committee (DRC) for the CMU Machine Learning Department.
- 2017-18: Speaking skills committee for the CMU Machine Learning Department.
- 2016-18: Education review committee (ERC) for the CMU Machine Learning Department.
- 2014-15: Social committee for the CMU Machine Learning Department.
-
Community Service
- 2009: Volunteer at the Lavrion refugee center, in Athens, Greece.
- 2008: Reforestation of mountainside in Rafina, Greece.
- 2008: Volunteer for the International Baccalaureate Organization (IBO) training workshop.
- 2008: 13th Annual Underwater and Beach Cleanup in Athens, Greece.
- 2008: Helped organize the "Christmas Bazaar" (fund raiser project).
- 2008: Helped organize the "Love Feast" (celebrating family values and fund raising for the victims of forest fires in Greece).
- 2007: Reforestation in Mani, Greece.
- 2007: Volunteer at the "AQUA GALA" event for physically challenged children, for the "Hellenic Society for Disabled Children".
Major Talks
-
2019
Competence-based Curriculum Learning for Neural Machine Translation.
- North American Chapter of the Association for Computational Linguistics (NAACL) conference.
-
2018
TensorFlow Scala.
- Invited talk at Google.
-
2014-18
Estimating Accuracy from Unlabeled Data.
- Neural Information Processing Systems (NIPS) conference.
- International Conference in Machine Learning (ICML) conference.
- Uncertainty in Artificial Intelligence (UAI) conference.
- Invited talk at Google.
- AI Lunch at Stanford University.
- ML Lunch at Carnegie Mellon University.
-
2012
Nonparametric Mixtures of Multi-Output Heteroscedastic Gaussian Processes.
- "Nonparametric Methods in Machine Learning" workshop at NIPS.
-
2009
Project Protasis - Forest Protection.
- Microsoft Hellas Headquarters.
- Ministry of Transportation of the Greek government (the Ministry later funded a pilot program).
-
2008-09
Project Protasis - Home Automation.
- Microsoft Hellas Headquarters.
- Louvre Museum in Paris, France, as part of Imagine Cup.
- UNESCO International Conference on Climate Change and Challenges for the Future Generations.
- Organization of School Buildings of the Greek government (later received funding for a pilot program from the Ministry of Education and Religious Affairs).
- 73rd Thessaloniki International Fair.
- Generation Next 0-18 fair, in Athens.
- 4th International Conference on Information and Communication Technologies in Bio and Earth Sciences (HAICTA 2008), in Athens.
Software Development Skills
- GitHub: https://github.com/eaplatanios (~900 stars from open-source projects).
- Machine Learning Frameworks: TensorFlow, PyTorch.
- High Level Programming Languages: Swift, Scala, Java, C#, C, C++, Python, Pascal, Prolog, MATLAB, Mathematica, JavaScript, ...
- Low Level Programming Languages: Intel 80x86 Assembly, ARM Assembly, AVR Assembly.
- Programming Environments (IDEs): IntelliJ IDEA, Visual Studio, MATLAB, Eclipse, NetBeans, Mathematica, SWI-Prolog IDE, ...
- Database Systems: PostgreSQL, MS SQL Server, MySQL.
Other Interests
- Sports: Tennis, Squash, Winter Skiing, Basketball, Sailing, and Windsurfing.
- Hobbies: Traveling, Philosophy, and Politics (I also really want to learn to play the Guitar).


What is this?
Sorta Secret is a simple web app that helps with blocking bots and web scrapers from reading semi-secret information. A great use case—and the reason this came into existence—is to allow real people to get someone's email address from a webpage without encouraging spammers.
If you're familiar with it, this is similar to what Mailhide did before it was turned offline.
This app is written in Rust, and is an FP Complete demonstration of using Cloudflare Workers, Rust, and Web Assembly to create globally distributed, scalable, low maintenance, and robust applications using a "serverless" architecture.
Want to learn more? Read our Serverless Rust using WASM and Cloudflare blog post.
Source code is available on Github.
Read more on the FP Complete blog. You can also sign up for our Rust and DevOps mailing lists.


|
|
| Matrix4 () |
| | Basic constructor.
|
| |
| | Matrix4 (float m0, float m1, float m2, float m3, float m4, float m5, float m6, float m7, float m8, float m9, float m10, float m11, float m12, float m13, float m14, float m15) |
| | Constructor. More...
|
| |
| | Matrix4 (const float m[]) |
| | Constructor. More...
|
| |
| | Matrix4 (const Matrix3 &mat3) |
| | Constructor. More...
|
| |
| | Matrix4 (float x, float y, float z, float angle) |
| | Constructor from rotation. More...
|
| |
| | Matrix4 (const Vector3< float > &axis, float angle) |
| | Constructor from rotation. More...
|
| |
| void | set (float m0, float m1, float m2, float m3, float m4, float m5, float m6, float m7, float m8, float m9, float m10, float m11, float m12, float m13, float m14, float m15) |
| | Sets the Matrix4 values. More...
|
| |
| void | set (const float m[]) |
| | Sets the Matrix4 values. More...
|
| |
| void | set (float x, float y, float z, float angle) |
| | Sets the Matrix4 values. More...
|
| |
| void | set (const Vector3< float > &axis, float angle) |
| | Sets the Matrix4 values. More...
|
| |
| void | set (const Matrix4 &other) |
| | Sets the Matrix4 values. More...
|
| |
| void | set (const Matrix3 &mat3) |
| | Sets the Matrix4 values. More...
|
| |
|
void | setZero () |
| | Sets all values of the Matrix4 to zero.
|
| |
|
void | setIdentity () |
| | Sets the Matrix4 to identity.
|
| |
| Matrix4 | getRotation () const |
| | Gets rotation as Matrix4. More...
|
| |
| void | setTranslation (float x, float y, float z) |
| | Sets the translation of the Matrix4. More...
|
| |
| void | setTranslation (const Vector3< float > &vector) |
| | Sets the translation of the Matrix4. More...
|
| |
| void | setScale (float x, float y, float z) |
| | Sets the scale of the Matrix4. More...
|
| |
| void | setScale (float factor) |
| | Sets the scale of the Matrix4. More...
|
| |
| void | setScale (const Vector3< float > &vector) |
| | Sets the scale of the Matrix4. More...
|
| |
| void | setRotation (float x, float y, float z, float angle) |
| | Sets the rotation of the Matrix4. More...
|
| |
| void | setRotation (const Vector3< float > &axis, float angle) |
| | Sets the rotation of the Matrix4. More...
|
| |
| void | setRotationX (float angle) |
| | Sets the X rotation of the Matrix4. More...
|
| |
| void | setRotationY (float angle) |
| | Sets the Y rotation of the Matrix4. More...
|
| |
| void | setRotationZ (float angle) |
| | Sets the Z rotation of the Matrix4. More...
|
| |
| void | setReflection (float x, float y, float z, float w) |
| | Sets the reflection of the Matrix4. More...
|
| |
| void | setReflection (const Quaternion &quaternion) |
| | Sets the reflection of the Matrix4. More...
|
| |
| void | setOrthoProjection (const Rectangle< float > &rect) |
| | Creates an ortho-projection from a Rectangle. More...
|
| |
| void | setOrthoProjection (const Rectangle< float > &rect, float nearZ, float farZ) |
| | Creates an ortho-projection from a Rectangle. More...
|
| |
| void | setPerspective (float fov, float aspect, float nearZ, float farZ) |
| | Sets the perspective in a Matrix4. More...
|
| |
| float | determinant () const |
| | Calculates the determinant of the Matrix4. More...
|
| |
| void | translate (float x, float y, float z) |
| | Translates the Matrix4. More...
|
| |
| void | translate (const Vector3< float > &vector) |
| | Translates the Matrix4. More...
|
| |
| void | scale (float x, float y, float z) |
| | Scales the Matrix4. More...
|
| |
| void | scale (float factor) |
| | Scales the Matrix4. More...
|
| |
| void | scale (const Vector3< float > &vector) |
| | Scales the Matrix4. More...
|
| |
| void | rotate (float x, float y, float z, float angle) |
| | Rotates the Matrix4. More...
|
| |
| void | rotate (const Vector3< float > &axis, float angle) |
| | Rotates the Matrix4. More...
|
| |
| void | rotateX (float angle) |
| | Rotates the X of Matrix4. More...
|
| |
| void | rotateY (float angle) |
| | Rotates the Y of Matrix4. More...
|
| |
| void | rotateZ (float angle) |
| | Rotates the Z of Matrix4. More...
|
| |
| void | reflect (float x, float y, float z, float w) |
| | Reflects the Matrix4 around a quaternion. More...
|
| |
| void | reflect (const Quaternion &quaternion) |
| | Reflects the Matrix4 around a quaternion. More...
|
| |
| void | lookAt (const Vector3< float > &eye, const Vector3< float > &target, const Vector3< float > &up) |
| | Changes the Matrix4 to reflect a look-at defined Vector3s defining the look eye's position, the target's position and the up-vector. More...
|
| |
|
void | transpose () |
| | Transposes the Matrix4.
|
| |
| Matrix4 | transposed () const |
| | Creates a transposed Matrix4 from this one. More...
|
| |
| void | inverse () |
| | Inverses the Matrix4. More...
|
| |
| Matrix4 | inversed () const |
| | Creates an inversed Matrix4 from this one. More...
|
| |
|
void | inverseRotation () |
| | Inverses the rotation of the Matrix4.
|
| |
| Matrix4 | inversedRotation () const |
| | Creates a rotation-inversed Matrix4 from this one. More...
|
| |
| Matrix4 | operator* (const Matrix4 &other) const |
| | Multiplies two Matrix4s. More...
|
| |
| Matrix4 | operator* (float factor) const |
| | Multiplies each value of a Matrix4 with a factor. More...
|
| |
| Vector3< float > | operator* (const Vector3< float > &vector) const |
| | Multiplies a Matrix4 with a Vector3. More...
|
| |
| Quaternion | operator* (const Quaternion &quaternion) const |
| | Multiplies a Matrix4 with a Quaternion. More...
|
| |
| Matrix4 | operator+ (const Matrix4 &other) const |
| | Adds two Matrix4s. More...
|
| |
| Matrix4 | operator- (const Matrix4 &other) const |
| | Subtracts two Matrix4s. More...
|
| |
| Matrix4 | operator= (const Matrix4 &other) |
| | Sets this Matrix4 to another one. More...
|
| |
| Matrix4 | operator+= (const Matrix4 &other) |
| | Sums up this Matrix4 with another one. More...
|
| |
| Matrix4 | operator-= (const Matrix4 &other) |
| | Subtracts a Matrix4 from this one. More...
|
| |
| Matrix4 | operator*= (const Matrix4 &other) |
| | Multiplies this Matrix4 with another one. More...
|
| |
| Matrix4 | operator*= (float factor) |
| | Multiplies each value of this Matrix4 with a factor. More...
|
| |
| | operator float * () |
| | Casts this Matrix4 into a raw float array. More...
|
| |
| | operator const float * () const |
| | Casts this Matrix4 into a raw float array. More...
|
| |
| float & | operator[] (int index) |
| | Accesses a value of the Matrix4. More...
|
| |
| const float | operator[] (int index) const |
| | Accesses a value of the Matrix4. More...
|
| |


For the chart below, mouseover has been disabled and click handling is enabled by setting "highlightMouseDown: true". For "fillToZero" area charts that have both negative and positive values as shown below, clicking in either the positive of negative regions will generate the same result.


JETM Springframework integration
Due to the nature of Spring managed applications JETM performance monitoring can easily added without touching application source code at all. This is done using Spring AOP. With it's help it is possible to monitor execution times purely by configuration.
Depending on your runtime environment choose one of the following integration strategies. Please note that these strategies rely on prerequisites and come with constraints listed below.
- Spring 2.x integration - requires XSD based configuration
- Spring 1.x/2.x integration - uses DTD based configuration
- Extensions for Spring managed web applications
Prerequisites and constraints
Springframework 1.x or 2.x?
Even though JETM supports both Springframework 1.x and 2.x the integration itself slightly differs. This is because of the newly introduced configuration namespace support in Springframework 2.x. If you are free to choose your Springframework version we recommend using Springframework 2.x, otherwhise you need use the old 1.x style JETM configuration.
Featurewhise there is no difference between Springframework 2.x and 1.x, however in 2.x the configuration is simplified.
Classpath Setup
JETM depends on Springframework classes and it's dependencies. It is necessary to add the following jars to the application classpath.
- Spring Framework: spring.jar or spring-aop.jar, spring-beans.jar, spring-context.jar, spring-core.jar
- AOP-Alliance API: aopalliance.jar
- CGLIB: cglib-nodep-x.jar
- Commons-Logging: commons-logging.jar
ApplicationContext required
Be aware that your spring configuration must be running within an ApplicationContext. Normally this is the case if you create the Spring runtime using a Web ContextLoaderListener or Web ContextLoaderServlet or any ApplicationContext subclass. If you just use a BeanFactory JETM performance monitoring will not work automatically (Hint: Register BeanPostProcessors - e.g. BeanNameAutoProxyCreator - manually).


Model Classes¶
-
class
modelclasses.
Species
(value, valueType, compartment, hasOnlySubstanceUnits, constant=False, metadata=None)¶ This class represents a species as defined by SBML.
Parameters: - value (float) – Sets either the value of conentration or amount, depending on the concentrationIn value.
- valueType (str) – If valueType is equal to”Concentration”, the amount input is assigned to the concentration member. Otherwise, amount is assigned to the amount member.
- compartment (Compartment) – Sets the compartment member to reference this input.
- hasOnlySubstanceUnits (bool) – Determines if the species concentration or amount is used is rate laws
- constant (bool) – If true, any attempts to modify the amount or concentration member fail.
- metadata (SBMLMetadata) – An object containing information about the model component stored in the SBML file
-
metadata
¶ Additional information about the species contained in the SBML model
Type: SBMLMetadata
-
amount
¶ The total amount of the species that is present. This volume is constant with respect to compartment size, unless the hasOnlySubstanceUnits member equals True and the species is modified by a rule or an event (events are currently not supported). Changes to this member are automatically apply to concentration as well.
Type: float
-
compartment
¶ The compartment that this species is contained within.
Type: Compartment
-
concentration
¶ The concentration of the species. Direct changes to this member are automatically applied to amount as well.
Type: float
-
class
modelclasses.
Compartment
(size, dimensionality, isConstant=False, metadata=None)¶ This class represents a compartment which is one of the model elements in SBML.
Each species is associated with one compartment by referencing the appropriate compartment with its own compartment member.
Parameters: - size (float) – This value represents the size of the shape. Whether this is a volume or an area is determined by the compartments dimensionality. If the compartment is set to be constant, assigning a value to this compartment fails and a warning is raised.
- dimensionality (int or float) – The number of spatial dimensions this compartment exists in. This is not limited to whole numbers.
- isConstant (bool) – If true, the compartment will be set to constant and attempts to change the size attribute will raise warnings.
- metadata (SBMLMetadata) – An object containing information about the model component stored in the SBML file
-
dimensionality
¶ The dimensionality of the compartment
Type: float
-
metadata
¶ Additional information about the compartment contained in the SBML model
Type: SBMLMetadata
-
size
¶ The size of the comparment. This is used by species to calculate their concentrations.
Type: float
-
class
modelclasses.
Parameter
(value, Id, constant=False, units=None, metadata=None)¶ This class represents a parameter as defined by SBML.
Parameters: - value (float) – Sets either the value of the parameter.
- Id (str) – The Id of the parameter
- constant (bool) – If true, any attempts to modify the value member fail.
- metadata (SBMLMetadata) – An object containing information about the model component stored in the SBML file
-
metadata
¶ Additional information about the species contained in the SBML model
Type: SBMLMetadata
-
class
modelclasses.
Model
¶ This class is inhereted by model classes generated .
-
SearchParametersByName
(name, suppress = False)¶
-
SearchCompartmentsByName
(name, suppress = False)¶
-
SearchSpeciesByName
(name, suppress = False)¶
-
SearchReactionsByName
(name, suppress = False)¶
-
SearchFunctionsByName
(name, suppress = False)¶
-
SearchComponentsByName
(componentDict, name, suppress = False)¶ Searches a dictionary of SBML model components for any components that match the name argument. This method raises an exception if the suppress keyword argument is False and a match is not found. The other search methods (eg. SearchParametersByName) serve as wrappers for this method.
-
-
modelclasses.
Piecewise
(expression1, condition1 [, expression2, condition2 [,...]] [, otherwise])¶ This function implements the Piecewise function used in SBML models.
Parameters: - expressionN (float) – A numerical value calculated using the appropriate expression for a portion of the functions range.
- conditionN (bool) – A boolean that is true if the independent variable(s) are within the portion of the domain whose range is defined by the corresponding exrpession.
- otherwise (float) – An optional numerical value that returned if all conditions are false.
Returns: The first expression passed as arguement with a true condition, read left to right. If all conditions are false, otherwise is returned.
Return type: float
Raises: Exception
– Raises a generic exception if no condition is true and otherwise is not specified.Notes
This function is not intended to be used by a user, but is defined to be used by generated Python models. This function is defined in a way that matches how libSBML formats piecewise functions used in SBML models. The inputs to this function are not actually evaluted inside of the function, but are evaluated before being passed to the function. For example, if Piecewise() is called like so:
\[Piecewise(x + 2, x < 3, x + 4, x > 3)\]and if x = 2, then the arguments will be evaluated to
\[Piecewise(4, True, 6, False)\]In this case, if x = 3, an exception will be raised, as all conditons will evaluate to False and otherwise is not provided.


Education Courses
Let’s learn something new
You are looking at Courses, would you prefer to see the Institutions?
Education InstitutionsFilter
-
Production Technologies and Agro-Industrial Transformation
NOVA School of Sciene and Technology
- Master


₹
Expense Tracker
₹
Description
Amount(
+
/
-
)
Add transaction
Income
₹0.00
Expense
₹0.00
Balance
₹0.00
Transaction History


Time Code
rated R 97 minutes Screen Gems starring Jeanne Tripplehorn, Salma Hayek, Stellan Skarsgard, Saffron Burrows, and Kyle MacLachlan written and directed by Mike Figgis
A Review by Frankie Paiva
I believe it's unfair to call Time Code an actual movie. The word experience is a better fit. The Time Code experience involves the screen being split into four different images, each with a different character focus, as they all play at the same time. The sound gets turned up on the one Figgis wants you to watch. One could describe it as watching four different shows on MTV all at once. The story relies heavily on this split screen factor and this is a very visual film with little complicated dialog. It has to be. Even with a slightly complicated plot, this movie would have been even more of a frenzy of annoying pointless images than it was. Essentially, a frenzy of annoying images describes the film well. This film is a foray into the different and the unusual, but carries little meaning. While Figgis has created a groundbreaking filmmaking approach, he seems concentrated on making sure the audience can handle it, rather than keep an interesting storyline going. It has been a long time since a movie has challenged you in such a way as this one does, but I felt it could have been even more challening if trust was put in the audience. Time Code dares to go freeform, and encourages the viewer to look at these characters and their surroundings with lightning fast comprehension before moving onto the next frame. Like any new method to come onto the film scene, it will take time to master, but consider Time Code the beginning of a new era in film.
The movie was shot entirely in one afternoon last November using hand-held cameras. There are no edits. Everything is real time. There is no set plot structure either. While Figgis gave his actors basic character outlines, he decided it would be much more interesting if the film was almost entirely improvisational. This is both an attraction and a detraction. There are times when you sense the actors come up with things right off the top of their heads, and those parts of the film are exciting and fun. Character reactions are a key part of this movie that centers around Red Mullet Productions (both the producers and setting for this film) during auditions for a new movie. In the upper left corner Rose (Wild Wild West recovering Salma Hayek) is going to the audition with Lauren (Jeanne Tripplehorn). Rose and Lauren are lovers, and the latter suspects infidelity. In the upper right, Emma (Saffron Burrows, Figgis's wife) consults her psychiatrist about her husband Alex (Stellan Skarsgard) whom she suspects is cheating on her. Alex is indeed cheating on her, and he occupies the lower right frame. Finally, in the bottom left is an aspiring actress that comes to audition for the lead role at Red Mullet.
After this basic setup, the camera roams free. Characters pop up in two different frames at once, or switch frames entirely. It's interesting to see how this effect gets used.  The screen was being used to show actresses moaning loudly from sexual pleasure during an audition for a group of executives. Another common element that unites the characters is the frequent bothersome earthquakes. Much care must have been taken into the timing to make the illusion of an earthquake appear in all four parts at the same time. These tremors that connect the characters continuously reminded me of the character connecting amphibians from the end of Magnolia. The ensemble cast that includes Steven Weber, Holly Hunter, Julian Sands, Leslie Mann, and Laurie Metcalf, as well as the actors mentioned above, have fun with their roles. It's no surprise though that the movie is inconsistent, but by the hour mark, I found myself comfortably able to grasp all that was going on. Time Code is almost interactive. It allows people to get a different experience of the movie each time they see it. The themes are the same though. Woe, jealousy, and betrayal all occupy different parts of the screen often. Everyone is cheating on everyone, and all the women are lesbians. Late in the film a young female independent filmmaker comes forward with an idea of new age filmmaking. "The end of editing is upon us!" she preaches. "Imagine a movie with four different images all running at the same time." Alex blows this idea off, and cannot control his laughter at the proposal.  She takes the criticism surprisingly well, and replies with a thank you stating he's the only honest person she has ever met in Los Angeles. By the time it reaches the conclusion, the facade of quality and honesty in Time Code is gone. It was then I realized the emptiness that ran through this movie. While Time Code is definitely worth seeing for the very original concept it presents, there's no hiding that little actual material lies under its surface.
B-
Frankie Paiva<EMAIL_ADDRESS>http://www.homestead.com/cinemaparadise/moviereviews.html
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{# Based on django-crispy-forms/crispy_forms/templates/bootstrap4/layout/radioselect.html #} {# Simplified, removed many of the unused checks and attributes no errors for installation type #} {# Expects `accordion_templates` in the context, as a list of one template-name for each field choice #} {# Builds a field with the following structure: #} {# - field div #} {# - label #} {# - div accordion, responsible for opening _one_ of the collapse-items below (bootstrap) #} {# - div card #} {# for each option: #} {# - card header #} {# - radio input and label #} {# - div collapse, show for option initially selected #} {# - card body #} {# - include the template for this choice, specified in `accordion_templates` #} {% load crispy_forms_filters %} {% load crispy_forms_field %} {% load l10n %} {# from crispy field.html, stripped down #}


Ingredients for my recipe:
Poulet basquaise
Tomatoes
Onions
Garlic
Red pepper
Chicken
Bacon bits
Olive oil
White wine


This page is hosted at joshfraser.com
Send message "one" from child to parent
Send message "two" from child to parent


Known Repositories
{{ .repositories }}
Reporting
By ref
Org:
Repo:
Ref:
By sha
Org:
Repo:
Sha:
Listing
All refs
Org:
Repo:
All shas
Org:
Repo:
Generation
All tags
Org:
Repo:
Branch
Org:
Repo:
Branch:
Differences
{{ .differences }}


Library Sphinx Theme¶
Library is a minimal typography-centric theme for the Sphinx documentation system, designed to read like a good book. Features include:
Publisher-selectable typeface stacks.
User-selectable light/sepia/dark reading modes.
Mobile-friendly responsive design.
Source Code | Documentation | PyPI
Design¶
“Library” is inspired by design of the printed page. Black and white, without colors, embellishments, or icons — for a good book the typography itself is the only source of design. “Library” returns to these literary roots by keeping colors, shapes, and frills to a minimum — focusing instead on whitespace and typography to produce legible, daresay enjoyable, documentation. This is a refreshed Sphinx theme for font nerds with a focus on legibility and long-form reading.
Read more in Design Notes.
Typeface Stacks¶
Several hand-tuned font stacks are included to change the feel of your documentation. Each features carefully selected typeface pairings which have been balanced with the theme layout to create a book-like reading experience.
Book — Highly legible type inspired by printed books. The default, and good for general purpose use.
Humanist — Another highly legible type, with a fresh and more casual look.
Academy — An elegant and formal early 20th-century type favored by academic publications and legal documents.
Engineer — A semi-slab-serif type; formal but much cleaner and more modern than “academy”.
Swiss — Sans-serif type providing an austere but clean look.
See options in Customization or typeface details in Design Notes.


A Bit About Me
Hey there! My name is Jose and I'm a Computer Science and Linguistics student with a passion for Web Development, E-Commerce, Quality Assurance, and Project Management.
I'm currently a senior attending University of California, Los Angeles (UCLA) - Go Bruins!
My Interests include, History, Startups, and Manga.
What am I?:
Programmer
Gamer
Space Enthusiast
COVID-19 Dashboard
Due to COVID-19 the World Health Organization has reccomended these steps to ensure everyone stays healthy as listed hereWe hope that everyone remains safe during these times


Results prior to 2010-05 are excluded from the calculated statistics
Breakdown of PDB depositions
Depositions by beamline / year (Top: ISPyB, Bottom: PDB)
Results prior to 2010-05 are excluded from the calculated statistics
Distance Cutoff: (Average difference per unit cell axis: Å) UpdateBreakdown of PDB depositions
Depositions per year


This is a case study of using χ² in an EDA context. See http://www.itl.nist.gov/div898/handbook/prc/section4/prc45.htm
Here's the background information from this example:
A total of 309 wafer defects were recorded and the defects were classified as being one of four types, A, B, C, or D. At the same time each wafer was identified according to the production shift in which it was manufactured, 1, 2, or 3.
We have a table of defects by shift and type. Each row is a different shift, each column is a different type.
defects = [ [15, 21, 45, 13], [26, 31, 34, 5], [33, 17, 49, 20], ]
We can imagine this is the result of summarizing raw data. The raw data migth look like this:
shift,defect,serial 1,None,12345 1,None,12346 1,A,12347 1,B,12348 etc. for thousands of wafers
The summary table is the result of something like a collections.Counter() using shift,defect as the key.
Or perhaps the results come from a SQL query like this:
SELECT SHIFT, DEFECT, COUNT(*) FROM some tables ... GROUP BY SHIFT, DEFECT HAVING DEFECT NOT NULL;
Before starting the analysis, we'll need to import some libraries
from chi_sq import cdf from fractions import Fraction
We need to see if the effects are random or not. If the effects are random variation, our hypothesis is that there's nothing to see here. This is the statistician's "null hypothesis:" nothing interesting is happening.
To evaluate the null hypothesis, we compare the observed defect data against some reasonable expectations for the defect data.
What we'll do is determine a hypothetical allocation of the same total number of defects that has a similar distribution based on shift and type.
The total number of defects is ∑s∑tds, t = 309.
total = sum(map(sum, defects))
We need to compute expected defects by shift and type. The null hypothesis asserts that all effects are random, so the efects should be evenly spread across shift and type.
The shift totals are defined as {∑tdst∣0 ≤ s < 3}.
shift_total = [sum(defects[s][t] for t in range(4)) for s in range(3)]
The total number of defects by shift are [94, 96, 119].
We can also calculate the totals like this, but that doesn't generalize well to for computing sum across types.
list(map(sum, defects))
Here are the probabilities of a defect based on actual counts of defects by shift.
P_shift = [Fraction(s,total) for s in shift_total]
We get this as a value [Fraction(94, 309), Fraction(32, 103), Fraction(119, 309)].
We've materialized two list objects here. Since we'll be producing some intermediate output, the materialized collections are helpful. If we did not intend to produce intermediate output, we could use lazy generator functions to reduce the amount of memory required.
Computing the type totals isn't quite so simple as computing the shift totals because we're slicing the matrix on an axis that doesn't work trivially with the sum() function.
Here are the type totals: {∑sdst∣0 ≤ t < 4}.
type_total = [sum(shift[t] for shift in defects) for t in range(4)]
The values are [74, 69, 128, 38].
Here are the probabilities of a defect based on actual counts of defects by type.
P_type = [Fraction(t,total) for t in type_total]
The values are [Fraction(74, 309), Fraction(23, 103), Fraction(128, 309), Fraction(38, 309)].
The overall defect probabilities are Pij = Pss × Ptt for each shift and type. This reflects the null hypothesis that neither shift nor type of defect has any bearing on the values: they're all just random.
We can multiplie the probability by the total number of defects to compute how many defects belong to each combination of shift and type.
expected = [ [float(ps*pt)*total for pt in P_type] for ps in P_shift ]
We can format these results like this to make something understandable:
r2 = lambda x:round(x,2)
Here's a list-of-ist summary. .. parsed-literal:
list(list(map(r2, row)) for row in expected)
This structure shows following expected values for defect counts
[ [22.51, 20.99, 38.94, 11.56], [22.99, 21.44, 39.77, 11.81], [28.5, 26.57, 49.29, 14.63] ]
Each cell is based on a contribution of shift and type to the overall number of defects.
Note the imporant difference from the expectation that the number of defects would be (309)/(12) = 25.75 in all cases. We're not asserting that shift and type of defect have no effect. We're asserting that the effects are independent of each other.
For example, the different shifts may have different numbers of workers. It might be perfectly reasonable for one shift to produce more wafers and therefore more defects. Using actual shift totals to compute the probabilities reflects the idea that the observed counts will vary.
We can display the observed and expected in a single table. This involves a bit of restructuring the data to show defects and expected values side-by-side.
print("obs exp "*4) for s in range(3): pairs = ' '.join( f"{defects[s][t]:3d} {expected[s][t]:5.2f}" for t in range(4)) print(f"{pairs} {shift_total[s]:3d}") footer = ' '.join(f"{type_total[t]:3d}" for t in range(4)) print(f"{footer} {total:3d}")
For each of the three shifts, we produced a row of data. Each row was pairs of observed and expected organized by defect type.
The output looks like this:
obs exp obs exp obs exp obs exp 15 22.51 21 20.99 45 38.94 13 11.56 94 26 22.99 31 21.44 34 39.77 5 11.81 96 33 28.50 17 26.57 49 49.29 20 14.63 119 74 69 128 38 309
This shows the observed defects and the expected defects. It shows the shift totals and the defect type totals, also.
In many practical applications, producing a text report like this isn't really optimal. It's often nicer to write a CSV file that can be reformatted for display. Using tools like Pandas xlsx writer can provide more useful output.
Here's the CSV version of the output. It requires a function to properly flatten and interleave defects and expected values.
def flatten(defects, expected=None): for t in range(4): yield defects[t] if expected: yield expected[t] else: yield None
This is similar in philosophy to the itertools.zip_longest() function. It interleaves values from defects and an optional second iterable. It can also be used to emit headers and footers; these situations don't have both iterables.
import csv with open("contigency.csv", "w", newline="") as output: wtr=csv.writer(output) wtr.writerow(["shift"]+list(flatten(("A","B","C","D")))+["total"]) wtr.writerow(["","obs","exp","obs","exp","obs","exp","obs","exp"]) for s in range(3): row= [s]+list(flatten(defects[s],expected[s]))+[shift_total[s]] wtr.writerow(row) row= ["total"]+list(flatten(type_total))+[total] wtr.writerow(row)
We've opened a writer and put out two lines of titles as a heading. The list(flatten(("A","B","C","D"))) produces eight values by interleaving the four defect types and an equal number of None values.
The body includes the interleaved defect counts and expected counts. Each row has a shift number as a header and a shift total as a summary.
The total line uses list(flatten(type_total)) to interleave the defect type totals with None values to create a footer line.
Based on the totals, the third shift is expected to be more productive than the first two. Similarly, defect type "C" is expected to show up considerably more often than defect type "D".
The question is "do the cell details reflect the overall summaries?"
The final χ² value involves ∑s∑t((Est − dst)2)/(Est)
We have three broad design patterns for workting with parallel nested structures:
The second approach is how we produced the contingency table, above.
We'll look at the third approach, also.
Both will benefit from a handy lambda that allows us to compute the squared difference value between expected, e, and observed, o.
diff = lambda e,o: (e-o)**2/e
We can use this lambda with all combinations of indices like this.
chi2 = sum( diff(expected[s][t], defects[s][t]) for s in range(3) for t in range(4) )
We can also apply this lambda to two flattened sequences like this:
chi2 = sum( map(diff, (e for shift in expected for e in shift), (o for shift in defects for o in shift), ) )
Either version gets us a χ² value, chi2, of 19.18. There are six degrees of freedom in this model: 3-1=2 shifts times 4-1=3 types.
print(f"χ² = {chi2:.2f}, P = {cdf(chi2, 6):.5f}")
The output looks like this:
χ² = 19.18, P = 0.00387
The probability of this data being random is very low. There's something going on here that deserves further investigation. In formal terms, we must reject the null hypothesis.
Generally, each step has been defined by functional programming design patterns. We've accumulated totals, transformed them to probabilities, and then transformed the probabilities into expected values. We computed the χ² and compared this with the χ² cumulative distribution function to measure the randomness of the data.
Each stage has been done with generator expressions and higher-order functions.
In order to produce a printed report or CSV output file, we had to step back from purely functional programming. In these two cases, we used Python imperative programming techniques to structure the output in the intended format.


|
MISA++ OME
1.0.0
Adds support for OME TIFF files
|
#include <misa_ome_tiff_description_builder.h>
Builder that allows easy creation of OME XML Metadata from scratch.
|
default |
|
explicit |
| std::shared_ptr<misaxx::misa_description_storage> misaxx::ome::misa_ome_tiff_description_builder::as_storage | ( | ) |
Returns the final TIFF description as storage
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::change_series | ( | size_t | series | ) |
All consecutive edit operations run on the provided series. Will create series if necessary
| series |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::channels | ( | size_t | size, |
| size_t | num_channels = 1 |
||
| ) |
Sets the number of planes in the channel axis This is not the number of channels each pixel has
| size |
| ::ome::files::CoreMetadata& misaxx::ome::misa_ome_tiff_description_builder::core_metadata | ( | ) |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::depth | ( | size_t | size | ) |
Sets the number of planes in the Z (depth) axis
| size |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::duration | ( | size_t | size | ) |
Sets the number of planes in the time axis
| size |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::height | ( | size_t | size | ) |
Sets the height of the planes
| size |
|
inline |
Modifies the description with a custom function
| Function |
| t_function | Function that takes a std::vector<std::shared_ptr<::ome::files::CoreMetadata>> |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::of | ( | size_t | channels, |
| const ::ome::xml::model::enums::PixelType & | t_pixel_type | ||
| ) |
Sets the number of channels and the pixel type
| channels | |
| t_pixel_type |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::of_opencv | ( | int | opencv_type | ) |
Sets the number of channels and the pixel type from an OpenCV type
| opencv_type |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::of_opencv | ( | const cv::Mat & | t_mat | ) |
Initializes width, height, channels and pixel type from OpenCV
| t_mat |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::of_size | ( | size_t | w, |
| size_t | h | ||
| ) |
Sets the width and height
| w | |
| h |
| misaxx::ome::misa_ome_tiff_description_builder::operator misa_ome_tiff_description | ( | ) |
Returns the final TIFF description
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::pixel_channel_type | ( | const ::ome::xml::model::enums::PixelType & | t_pixel_type | ) |
Sets the type each channel in a plane has
| t_pixel_type |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::pixel_channels | ( | std::vector< size_t > | channels | ) |
Sets the number of channels each pixels has
| channels |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::pixel_channels | ( | size_t | channels | ) |
Sets the number of channels each pixels has Requires an already set number of planes in channel axis
| channels |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::width | ( | size_t | size | ) |
Sets the width of the planes
| size |
| misa_ome_tiff_description_builder& misaxx::ome::misa_ome_tiff_description_builder::with_filename | ( | std::string | filename | ) |
Sets the filename
| filename |


| I l@ve RuBoard |
Next, we've created a VB application with a multiple document interface. You can do this by hand and add the forms and modules you need, or use VB's Application Wizard and strip out the stuff you don't need. We've defined a public variable called BookServer and three public methods in the form, InitCOMServer, CloseCOMServer, and TestCOMServer, and hooked them up so that InitCOM-Server is called when the form loads:
Public BookServer As Object Private Sub MDIForm_Load() InitCOMServer frmJournal.Show End Sub Private Sub MDIForm_Unload(Cancel As Integer) CloseCOMServer End Sub Sub InitCOMServer() 'called when the program starts On Error GoTo InitCOMServer_error Set BookServer = CreateObject("Doubletalk.BookServer") Exit Sub InitCOMServer_error: Dim msg As String msg = "There was an error trying to initialize the BookServer." + _ "Please check that it is properly registered and try the Python " + _ "test functions first. The program will now abort." MsgBox msg End End Sub Sub CloseCOMServer() Set BookServer = Nothing End Sub Sub TestCOMServer() 'just to check it is alive Dim hopefully_four As Integer hopefully_four = BookServer.Double(2) MsgBox "2 x 2 = " & hopefully_four & ", so your server is alive" End Sub Private Sub mnuToolsTestServer_Click() 'this helps establish if the COM server is alive 'using a minimal diagnostic function in the modMain module TestCOMServer End Sub
That the COM server isn't registered is a common error, so you need to handle this error and close the program immediately if it occurs.
It's not necessary to explicitly unload the BookServer; it's freed automatically when the VB program closes down. However, it's good programming practice to free variables explicitly to show that you know when it's happening, and it provides the right hook in case you want to do some extra processing at this point (such as committing changes to a file or database).
We've also added a menu item on the Tools menu to call our test function. Hit Run, and the application should start up. If you get as far as the main screen, it should have a live Python COM server inside it. To prove it, click on Tools Test Server, and you should see Figure 7.1.
Now we've got this running, we can start to expand the capabilities of the COM server and add the code to call it on the VB side. We've added a number of public methods, declaring them in the _public_methods_ attribute as we implement them.
Adding the following methods to your COMBookSet allows you to load a data file, see how many transactions the BookSet contains, and then build a view that displays a Journal, a listing of all the transactions in date order:
# more methods for COMBookSet - must be named in _public_methods_ def load(self, filename): self.__BookSet.load(str(filename)) def count(self): # return number of transactions return len(self.__BookSet) def getTransactionString(self, index): return self.__BookSet[index].asString()
In load, you perform a str(filename) operation to convert the Unicode filename from COM into an ordinary Python string. Then pass the request to the delegate Python BookSet instance. Most methods follow this pattern, doing any necessary transformations of arguments on the way in and out and passing the real work onto the delegate.
Now you need to open files. This is the VB code for the File Open menu option (generated by one of VB's Wizards and so is somewhat verbose):
Private Sub mnuFileOpen_Click() Dim sFile As String With dlgCommonDialog .DialogTitle = "Open" .CancelError = False 'ToDo: set the flags and attributes of the common dialog control .Filter = "Doubletalk Journal Files (*.dtj)|*.dtj" .ShowOpen If Len(.FileName) = 0 Then Exit Sub End If sFile = .FileName End With BookServer.Load sFile 'display something helpful in the Journal caption frmJournal.Caption = sFile & ", " & BookServer.count & " Transactions" End Sub
The only line of interest here is in BookServer.Load sFile, where Python is asked to do the work. Then, clicking on File Open lets you open a BookSet stored on disk. The Doubletalk package includes one file created by the demodata1.py script with a thousand transactions; it takes about one second to load on a Pentium 120. The various other loading and saving methods in your COMBookSet class can be hooked up to menu items in a similar manner.
Next, build a Journal view, an MDI child window to display a list of transactions in date order. This has a list box filling its client area and some code to resize it smoothly. It also has a method called UpdateView as follows:
Public Sub UpdateView() 'make a list with a string describing each transaction Dim count, i As Integer Dim trantext As String Dim tran As Object Screen.MousePointer = vbHourglass lstJournal.Clear For i = 0 To frmMain.BookServer.count - 1 trantext = frmMain.BookServer.getOneLineDescription(i) lstJournal.AddItem trantext Next i Screen.MousePointer = vbDefault Caption = "Journal view - " & lstJournal.ListCount & " transactions" End Sub
The implementation of this UpdateView method is simple: first ask the Book-Server for the number of transactions, then for the text representation of each one in turn. These are added to the list one at a time. When run, you see a view like Figure 7.2.
We'll define a range of views in the next few pages, all with an UpdateView public method. You can then ask them all to redraw themselves whenever the data changes. Later on we will see some other techniques that remove the need to do the looping in VB; the Python COM framework can return a list of strings or allow VB to iterate over the BookSet directly.
At this point, it's worth it to pause and reflect. We have built the engine of an application in Python, but delivered it inside an industry-standard, 100% Windows user interface of the kind users expect.
You'll want to add and edit individual transactions. This leads to more fundamental design considerations. You need to expose Transaction class as a COM server. You also need to think about how to create these transactions and manage their lifecycles and about the right choice of patterns. One option is to make a COMTransaction class the same way we did for COMBookset.
The overall goal is to make sure that code that works with transactions in VB is as similar as possible to the corresponding code in Python. The VB code to create and add a new transaction looks like this:
Dim newtran As Object Set newtran = CreateObject("Doubletalk.Transaction") newtran.setDateString "31/12/99" newtran.setComment "Python on Windows Royalty Cheque" newtran.addLine "MyCo.Assets.NCA.CurAss.Cash", 5000 newtran.addLastLine "MyCo.Capital.PL.Income.Writing" BookServer.Add newtran
There is another choice, however. Adding a factory method to BookServer gives a new transaction (outside of the BookSet but otherwise fully formed). In this case there is no need to register the class at all; it's never created directly from the registry. Microsoft Office uses this model a lot. Most of the Excel objects are obtained from the application object's factory methods and are not directly creatable. If you go this way, your VB code to add a transaction looks like this:
Dim newtran As Object Set newtran = BookServer.CreateTransaction newtran.setDateString "31/3/2000" newtran.setComment "Even more royalties" newtran.addLine "MyCo.Assets.NCA.CurAss.Cash", 5000 newtran.addLastLine "MyCo.Capital.PL.Income.Writing" BookServer.Add newtran
The benefit is that the COMTransaction class can be much smaller.
We've added a class called COMTransaction to comservers.py that delegates to a pure Python transaction. This provides all the methods needed to edit and create transactions in your client code. Here's an example:
class COMTransaction: # we don't need all the _reg_ stuff, as we provide our own # API for creating these and don't use the registry. _public_methods_ = [ 'asString', 'getDateString', 'setDateString', 'setCOMDate', 'getCOMDate', 'getComment', 'setComment', 'getLineCount', 'getAccount', 'getAmount', 'addLine', 'addLastLine', 'getOneLineDescription' ] def __init__(self, tran=None): if tran is None: self._tran = doubletalk.transac.Transaction() else: self._tran = tran def asString(self): return self._tran.asString() def getDateString(self): return self._tran.getDateString() def setDateString(self, aDateString): self._tran.setDateString(str(aDateString)) def setCOMDate(self, comdate): self._tran.date = (comdate - 25569.0) * 86400.0 def getCOMDate(self): return (self._tran.date / 86400.0) + 25569.0 def getComment(self): return self._tran.comment def setComment(self, aComment): self._tran.comment = str(aComment) def getOneLineDescription(self): return '%-15s %s %10.2f' % ( self._tran.getDateString(), self._tran.comment, self._tran.magnitude() ) def getLineCount(self): return len(self._tran.lines) def getAccount(self, index): return self._tran.lines[index][0] def getAmount(self, index): return self._tran.lines[index][1] def addLine(self, account, amount): self._tran.addLine(str(account), amount) def addLastLine(self, account): self._tran.addLastLine(str(account))
This example has a number of interesting features:
Like COMBookSet, this has an instance variable called self._tran pointing to a pure Python transaction instance. You can pass in an existing transaction on initialization to wrap it up, or it creates one if none is provided.
There's no need to register it at all, since you will create instances from a factory method provided in COMBookSet. The only special attribute needed is the list of public methods.
Since Python dates use a different representation than Microsoft, we have provided setCOMDate and getCOMDate methods to handle the conversion. Python's date system is that of Unix, counting seconds since 1/1/1970; COM uses the Excel format of days since 31-Dec-1899. We also offer setDateString and getDateString methods to sidestep the need for a conversion routine.
Rather than expose comment as a simple attribute, we have implemented setComment and getComment methods. These let you convert the Unicode string. As a general principle, we are not directly exposing any attributes (although the Python COM framework does allow it).
We provided some extra methods to get the number of lines and to retrieve a specific account name or amount using an index. These let you write a VB loop to get all the lines. Alternative ways of exposing the detail rows would be to return arrays (which are covered later in this chapter) and enumerators (which appear in Chapter 12).
Now we need to look at how to get hold of these and store them in our BookServer. At this point you need to do a little more conversion and understand a little more about COM. In the previous VB example to create and add a transaction, there were actually three different Transaction objects involved. The raw one used by VB is an IDispatch object. IDispatch is a standard COM interface that lets you attempt to call any method or property and finds out later whether they work; the Python COM framework creates these around Python objects. Hiding within this is an instance of our COMTransaction class, written in Python. And because you are using a delegation mechanism, you have your own pure Python Transaction class as an attribute of the COMTransaction. When you create new transactions to use with COM or try to add ones to the BookSet, you have a little more conversion to do.
This method in COMBookSet creates a new transaction for Visual Basic to use:
def createTransaction(self): comTran = COMTransaction() idTran = win32com.server.util.wrap(comTran) return idTran
Before handing this out to a client language such as VB, call the wrap utility. This creates a PyIDispatch wrapper around the Python object, which is what VB actually works with. More information on wrapping Python objects for COM can be found in Chapter 12.
When you want to add a new transaction to the BookSet, you need to unwrap it to get at the Python object inside:
def add(self, idTran): comTran = win32com.server.util.unwrap(idTran) pyTran = comTran._tran self.__BookSet.add(pyTran)
Throughout this code we have prefixed the PyIDispatch object with id, the Python COM classes in comservers.py with com, and the pure Python classes in bookset.py and transac.py with py.
If you design your application purely to work with COM and not for general Python use, you can take another tack and store the PyIDispatch objects in the list.
Now we are ready to add and edit transactions. The natural thing to do is to allow a double-click on a transaction to lead to a special dialog for editing. This should perform the necessary validation to ensure that the transaction balances before the dialog is closed, and, if there is a change, it should update all of the current views. We've built a pair of dialogs in VB: one to edit transactions and the other (called from it) to edit individual line items. Figure 7.3 shows the transaction dialog.
The code to edit the transaction is exposed as a method of the form as follows:
Public Function Edit(index As Integer) As Boolean 'returns true is the transaction was successfully edited Dim i As Integer Dim linecount As Integer Set tran = frmMain.BookServer.getTransaction(index) 'display the transaction details lblTranIndex.Caption = Str(index) txtDate.text = FormatDateTime(tran.getCOMDate) txtComment.text = tran.getComment linecount = tran.getLineCount grdItems.rows = linecount + 1 For i = 0 To linecount - 1 grdItems.TextMatrix(i + 1, 0) = tran.GetAccount(i) grdItems.TextMatrix(i + 1, 1) = tran.getAmount(i) Next i Set tran = Nothing UpdateFormState 'display and allow editing Me.Show vbModal If FormExit = vbOK Then Set tran = frmMain.BookServer.CreateTransaction tran.setComment txtComment.text If IsDate(txtDate.text) Then tran.setCOMDate CDbl(CDate(txtDate.text)) For i = 1 To grdItems.rows - 1 tran.AddLine grdItems.TextMatrix(i, 0), _ CDbl(grdItems.TextMatrix(i, 1)) Next i frmMain.BookServer.Edit index, tran Set tran = Nothing Edit = True Else Edit = False End If End Function
This example is one of many ways to organize the code. Fetch a transaction from the BookSet and display its attributes in the user interface before discarding it. Then display the dialog modally : the user must finish using the dialog before the Edit method continues. During this period, quite a bit of validation code is running; the OK button is enabled only if the transaction is valid and in balance. If OK is clicked, the transaction is valid. Now create a new COMTransaction to hold the data, copy the data from the user interface into it, and tell the BookSet to accept this as a replacement for the its existing data in that position. An alternative might be to work with the same transaction throughout.
The dialog also exposes a method to add a new transaction; this displays an empty dialog, but behaves identically after displaying the form.
To summarize, you can now add and edit transactions from Visual Basic. The techniques used would be the same for any kind of nested or master-detail object. The VB code to do this looks extremely natural and straightforward, pretty much the same as the Python code for creating transactions. On the server side, you need to distinguish between the PyIDispatch objects COM is using and Python's internal representations, but this needs to be done only once per class.
So far we've seen examples of passing numbers, strings, and Python objects back and forth between Python and VB. Now we'll develop some more kinds of views and look at passing around arrays of data at a time. This is a real time saver and can simplify the preceding code in several places.
Many financial reports take the form of a 2D grid or spreadsheet. What's needed is a generic solution for getting a Python list of lists into such a grid. In the last chapter we showed a number of BookSet methods for getting a list of accounts, the details of an account and so on. For example, getAccountDetails returns a list of tuples of (transaction number, date, comment, amount, runningTotal). This is effectively a matrix with five columns but an unknown number of rows. You need to expose this the usual way in COMBookSet, but then access the entire matrix from VB. The Python COM framework automatically converts lists (or lists of lists, or lists of tuples) into arrays that can be accessed in VB.
We've created a new form, frmAccountView, which can be given the name of an account as a string. This has a Microsoft FlexGrid control called grdTable. Here's the UpdateView method that fetches and displays the data:
Public Sub UpdateView() Dim table As Variant Dim rows As Integer, cols As Integer Dim row As Integer, col As Integer table = frmMain.BookServer.getAccountDetails(AccountName) rows = UBound(table, 1) - LBound(table, 1) + 1 cols = UBound(table, 2) - LBound(table, 2) + 1 'should be 5 grdTable.rows = rows + 1 'leave room for titles For row = 0 To rows - 1 For col = 0 To cols - 1 grdTable.TextMatrix(row + 1, col) = table(row, col) Next col Next row End Sub
Figure 7.4 displays the new view in action.
Although we've hardcoded a view, it would be easy to write a completely generic form to display any data and push the management of views back into Python itself. We'll look at this in Chapter 8.
It would be convenient to look at a graphical view of an account, so let's create one. This allows you to illustrate another level of integration between Python and VB: callbacks. Within the framework you've just created, the VB COM client has been accessing the properties and methods of the Python COM server. But it doesn't have to be that way; the Python code can access the properties and methods of any VB object, whether built-in or user-defined.
You need to pass a VB form to Python, which then draws directly on it. You could also instead write another view that grabs the same array of data as the last one and uses VB graphics code to do the drawing. That is a better design, since it keeps a strict separation between the engine and interface; once you add drawing code on the Python side, you presume that a VB form with a certain API is provided. But this example is fun and highly instructive.
Let's start by creating a new form in our application called frmAccountChart, similar to the other views so far. Add a public method to the COMBookSet server called drawAccountChart, which expects a VB form as an argument. We'll start with a simple test: our drawing routine sets the caption of the form with a timestamp. On the VB side, the UpdateView method for frmAccountChart asks Python to do the work:
'Method of frmAccountChart Public Sub UpdateView() 'ask Python to scribble on me frmMain.BookServer.drawAccountChart Me End Sub
The form passes itself (using the keyword Me, which is VB's equivalent of self) to the BookServer. On the Python side, here is a method that does something visible to the form:
def drawAccountChart(self, vbForm): # Make a Dispatch wrapper around the VB Form object so we can call # any of its methods. idForm = win32com.client.Dispatch(vbForm) # access a property of the VB form idForm.Caption = "Python Drew this chart at " + time.ctime(time.time())
The first line is critical. The actual object passed to Python in the variable vbForm is a raw IDispatch object, which is difficult to use directly. However, by creating a dynamic Dispatch wrapper around it, you can access any of its methods and properties as a normal COM object. Figure 7.5 shows the proof.
The meaning of this wrapping is discussed in greater detail in Chapter 12. For now, just remember to do it for any Visual Basic objects you want to manipulate.
Python can access the public methods and properties of any VB object, not just user-interface widgets such as forms and list boxes, but also classes you define yourself.
Now let's extend what we just did and let Python do some real work. VB provides a picture control that allows drawing. However, some of the drawing methods use an esoteric syntax with hyphens, seen nowhere else in VB, and which no other language could reasonably be expected to call. You should therefore provide your own easy-to-use graphics API in VB at the form level. Add a single picture control called picChart to frmAccountChart, along with code to fill the entire form when the form is resized. Then add a few methods to the Visual Basic form to make it easier to do the graphics. Python can then call these methods. Here is the minimal graphics API defined for frmAccountChart:
'Visual Basic code to provide a minimal graphics API Public Sub DrawLine(x1 As Integer, y1 As Integer, x2 As Integer, _ y2 As Integer, color As Long) picChart.FillStyle = vbTransparent picChart.Line (x1, y1)-(x2, y2), color ' see what we mean about the funny syntax? End Sub Public Sub DrawBox(x1 As Integer, y1 As Integer, x2 As Integer, _ y2 As Integer, lineColor As Long, _ isSolid As Boolean, fillColor As Long) If isSolid Then picChart.FillStyle = vbSolid Else picChart.FillStyle = vbTransparent End If picChart.fillColor = fillColor picChart.Line (x1, y1)-(x2, y2), lineColor, B End Sub Public Sub DrawText(x As Integer, y As Integer, size As Integer, _ text As String) picChart.CurrentX = x picChart.CurrentY = y picChart.FontSize = size picChart.Print text End Sub Public Function GetClientArea() As Variant 'return a two-element variant array GetClientArea = Array(picChart.Width, picChart.Height) End Function
This code gives one method to clear the chart, and three methods to draw lines, boxes (filled or otherwise), and place text with a choice of font size. There's also a method that says which account the form is tracking and another method to return the dimensions of the form, so you can figure out how to scale the chart.
The drawAccountChart method in our Python COM server now needs to do three things: first, it queries the form to find out which account to draw; then it queries it to determine its size; finally it uses the graphics methods to do some drawing.
We won't repeat all the chart code but here are a few lines:
def drawAccountChart(self, vbForm): # Make a Dispatch wrapper around the vb Form object so we can call # any of its methods. print 'Drawing chart...'
Note the print statement. In normal use this won't go anywhere. However, the Python COM framework provides a debugging mode for COM servers and a tool for collecting these traces. It took a few tries to get all of the scaling right, and we used numerous print statements to examine the data.
At this point, we need to briefly explain how to debug a COM server. The theory behind this is covered in Chapter 12. It's easy to use: just run the COM server script (comservers.py in our case) with the argument —debug: note the double hyphen. The output of any print statements in the server code can then be seen in the Trace Collector window on the PythonWin Tools menu.
Now it's time to work with the form passed in from Visual Basic:
idForm = win32com.client.Dispatch(vbForm)
As before, you wrap the VB object using Dispatch:
# call a method we defined on the VB form # arrays are converted automatically to Python tuples we can access (width, height) = idForm.GetClientArea() account = idForm.GetAccount()
The previous line is interesting for two reasons. First, you called a public method of the VB form you defined. This works in exactly the same way as calling methods of built-in VB objects. Second, you received back an array. Earlier we saw that a Python list or tuple can be passed to VB, where it's interpreted as a variant array. The GetClientArea() method of our VB form returned a two-element variant array, which is received as a straightforward tuple. You can pass arrays easily in both directions. (Bear in mind that if VB returns an array containing strings, they are Unicode strings that must be tidied with the str function).
# access a built-in property of the VB form idForm.Caption = "Account " + account ############################################################# # now for the chart drawing - calling our own VB methods... ############################################################# idForm.ClearChart() #clear the form # if the area is too small to do anything with, exit if width < 1440: return if height < 1440: return #work out the inner drawing rectangle plotrect = (720,720, width-720, height - 720) # draw a blue bounding rectangle idForm.DrawBox(plotrect[0], plotrect[1], plotrect[2], plotrect[3], 0xFF0000, 0xFFFFFF)
We've omitted the rest of the charting code, but as you can see in Figure 7.6, it works rather nicely.
| I l@ve RuBoard |


{% extends 'mtp_common/user_admin/list.html' %} {% load i18n %} {% block page_title %}{% trans 'Sorry, something went wrong' %} – {{ block.super }}{% endblock %} {% block admin_content %}
{% trans 'Your account is not correctly set up to manage other users.' %}
{% trans 'Please contact us to request your account to be changed' %}


THAT THING YOU DO! A film review by A. S. Lenahan Copyright 1996 A. S. Lenahan
/1996/MPAA:"PG"
rating: 7.94 (of 10)
THAT THING YOU DO! is the latest Tom Hanks film (meaning that it will more than likely be box-office gold). Past that, it is a good, but not great, musical comedy. It is entertaining, fun, a crowd-pleaser, but also unoriginal and ultimately unmemorable. The largest stumbling block is the weak story, but the music, acting, and sets/costumes make THAT THING YOU DO! an enjoyable evening at the movies. However, I doubt any of that matters... this film will do well because of the involvement of Tom Hanks as writer, director, contributing songwriter, and actor. The plot is simple and eternally familiar. Set in 1964, a talented group of young musicians form a band, win a talent competition, and (what else?) rocket to instant stardom. A movie based on this formula comes out every two years or so, so if you miss this one, dont fret (although youll also miss Tom Hanks! Horrors!). The script is so reminiscent of so many other films, one wonders if screenwriter Hanks might have used some kind of fill-in-the-blanks screenplay template... sort of a Hollywood "Mad Libs". The band is named the Oneders (later the Wonders), the four lads play a catchy tune called "That Thing You Do", and the song is recorded as a record. Along the way, we learn all the expected lessons: music producers are sleazy, all glory is fleeting, the film industry is shallow, etc. Surprisingly, the film spares us the moral about eating all our vegetables, but not by much. All the characters are based on others from some other film or television show. The Wonders are the Beatles (the movie itself even hints at this). Theres a typical over-emotional girlfriend (played by Liv Tyler). The role Hanks wrote for himself is surprisingly unglamourous: hes a sleazy music producer, loosely based other similar shady charactersfrom other films. Theres even a philosophical Jazz musician, surely familiar to anyone who remembers Bleeding Gums Murphy from "The Simpsons". Actually, the plot is not a bad one, but certainly not original or fresh by any means. The acting is quite good, despite the small number of big names in the cast. All four of the Wonders have individual personality, and are all very likable. When I saw TTYD! in a theatre, the audience applauded after every big musical number, a good sign for a film obviously intended as a crowd-pleaser. Hanks gives a fine performance despite his stiff, unemotional character. Tyler is suitably whiny as well, but her character doesnt really become important until the end, although a better script could have changed that. On a trivial note, vigilant viewers may be able to spot the guy from the "Aaron Burr" milk commercial as a fan. Collectively, the acting adds a lot to the enjoyability of this movie. The most important aspect of TTYD! is the music. The title tune sounds as though it were pulled from some mid-sixties vinyl record. Its a catchy, memorable tune, so the audience might find it running over and over in their head even after the credits roll. The rest of the soundtrack is a mixed bag; the pop music might take you back, but the stilted, plastic jazz will leave any fan cold. Oddly enough, some of the music credit goes to Hanks (Im surprised he didnt try to be the gaffer or key grip as well...). TTYD! is a music film, so the expectations are high, but the movie never disappoints. Where the true charm of TTYD! lies is in the great nostalgic sets and costumes. Although the flashiest sets are the television studios and hotels later in the film, my favourite was the electronics store where it opens. The authenticity of that set alone enhanced the movie experience, at least for me. The glistening pastel appliances, the props, advertisement displays, even the overall washed-out look--if that scene doesnt take you back to the mid-sixties, nothing will. The costumes are equally well-crafted, although perhaps less spectacular. The visual look of TTYD! has a certain realness rarely seen in other period piece films. Obviously, TTYD! is not for those who demand a brilliant plot, but it remains a fun and engaging movie. Its intended as a fun film, and accomplishes just that. If only the plot offered *something* new. Anything...
Ratings on a 1.00-10.00 scale. 1.00=terrible; 5.00=average;10.00=great. A.S. Lenahan -- Camp Hill, PA USA 09/30/96 10:17 PM<EMAIL_ADDRESS>website:http://www.geocities.com/SoHo/4195
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews