Class p.a.e.Envelope(
dict
):
Part of
pymine
.
api
.
envelope
View In Hierarchy
wrapper-class atop 'dict' to provide a few extra methods
Method
__init__
Undocumented
def __init__(self, request, **kwargs):
Undocumented
API Documentation
for pymine, generated by
pydoctor
at 2010-04-07 23:15:24.


{{alert.msg}}
Title is required.
Event type is required.
Organizer is required.
Event venue is required.
Event address is required.
Start date is required.
Clear Date


(Originally published on the OUBS Blog)

Establish and prioritise the organisations’ purposes and objectives

Understand the relationship between and the power of stakeholders

Set up negotiation and conflict mechanisms to reconcile stakeholder differences

purpose and objectives which constrain organisational structures and control

It is very important to understand the true purpose of an organisation as it highly influences its actions and therefor the competitive landscape.

The books ads a few things to what strategy is about, being the need to balance stakeholder relationships, producing above average returns, politics and power as well as culture and meaning.

The purpose of an organisation reflects it’s "raison d’etre" [sorry, missing all the accents here for those who speak / write french ;)] and might be written down in a vision statement. This is normally not something that is measurable. Objectives are the things that are more specific than a vision and also more short term and measurable. Policies then are something like decision rusles for recurring contingencies, bringing a little bit consistency to strategy.

Public mission statements (or purpose statements) of big companies will reveal their pupose (and long-term objectives) to shareholders. They should help to give a sense of direction.

Purpose Statements will normally take into account social responsibility, depending on the extent they matter to key stakeholders and the importance of that stakeholder group.

The mission needs to match strategy, purpose, values and behaviour standards to really have a good effect. Personal and organisational vlaues need to match. They are unique to each organisation.

Eccles and Nohria (1992) suggest that an organisations language has a direct effect on both it’s strategic actions and it’s identity. It can therefor said to be a tool to develop a strategy and identity.

Managing the purposes and objectives

It is impossible to determine the purpose and objective without understanding the various stakeholder positions. A stakeholder analysis might be called a "contributor and claimant" analysis. Etzioni (1971) categorised the reasons for participation in a company as follows: - coercion (you have to) - mutual benefition exchange - identification with the values, norms and beliefs of the company

As simplification, one can concentrate on economic goals for sahreholders and other stakeholders with a monetary insterest. The problem here is that you need to agree on what kind of profitability you mean for you company: - accounting returns - cash returns - economic profit and rents (where rents are returns above general market profit)

In the stockmarket, shareholder values or EPV (Economic Value Added) does not directly link to the share price either: - the amoutn of shares traded each da are only a % of the total - discounts will be attached to the stock for multiple reasons - market imperfections

This only works if you have shareholders. In a public or charitable organisation everything is a lot more about a fulfilment of purpose while taking into account the potential wishes of important stakeholders (donors want to know that they did good and you need to tell them that they did and what they did)

In the end, an adequate return to the resource provider is what you need. You can do a cost-benefit analysis or look at efficiency and effectiveness. Opportunity Costs in relation to alternatives should be taken into account though.

The course book states that managers are agents to the owners. Their purpose might be: - Baumol (1966): prestige from high market share - Marris (1964): Power and reward by growing assets - Williamsen (1974): status and empire building via salary and perks - Galbraith (1967): growth, independence, challange

I would like to differ. The purpose of individuals is individual. Should be clear via the word alone. Some might really fit into the above scheme though.

What needs to be done though, is the alignement of managerial and ownership interests. This could be done through monitoring, incentive, sanctions, auditing and encouraging takeovers [that last one is a tough one but interesting point ;)]

Personal Rant: They give Berkshire Hathaway as an example but my personal opinion is that what makes Berkshire Hathaway so special is expertise and honesty. Monitoring, Auditing and encouraging takeovers are none existent. Incentives and sanctions are there but then again, the man that calls the shots has something like 30 Billion USDs in personal wealth. It’s not like it would really really hurt if the stock drops 50%. Based on 50% of his net worth being in BH, he would then have about 22 Billion USD. Great company though and especially great man/investor that Warren Buffet is. — End Personal Rant

Stakeholders are more and more getting important in relation to shareholders. In a knowledge society, that carriers of knowledge become more important than the carriers of capital, as capital becomes more replaceable than knowledge. Takeovers are not easy and customer relationships are of prime importance for lasting success.

Companies are "non-zero-sum" games though, meaning that collaboration increases the value for all. By attending to all stakeholder needs management can make a bigger cake (Baden-Full).

Contract theory can be used to look at stakeholder collaboration. Kay (1993) found three different "contracts": - spot contracts: short, standard terms ala "I sell, you buy and that is that." There is no long-term commitment. - classical contracts: brings certainty for longer commitments; in case of switching costs, the parties want to make sure that there is no termination of the relationship; investments need to be secured. - relational contracts: long-term; less formal; expectations go beyond legal contract; trust; dependence

Which contract is best comes down to: - classical contracts are needed to make things binding while relational contracts are more about co-operation. Relational contracts also need flexibility and free flow of information. You acknowledge that you are both important for each other.

Returns on resources and to stakeholders should also look at market imperfections. In a perfect market, resources lead to a normal rate of return for veryone. Imperfections can, if exploited, lead to above average returns as some organisations will have a distinct or unique advantage. Bad performance will lead to shareholders moving elsewhere. Competition will be there for scarce resources.

Morgan (1986) identified 12 sources of stakeholder power: - Formal authority - Control over scarce resources - Organisational structures and procedures - Control of decision process - Control of knowledge and information - Boundary management - Ability to manage uncertainty - Control of technology - Alliances and informal networks - Countervailing power - Symbolism and management of meaning - Gender power


Chapter 2: Hello notebook¶
A Jupyter notebook is a browser application where you can write, run, remix and republish code.
It is free software you can install and run like any other open-source library. It is used by scientists, scholars, investors and corporations to create and share their research.
It is also used by journalists to develop stories and show their work. Examples include:
“The Tennis Racket” by BuzzFeed and the BBC
“Machine bias” by ProPublica
More than 30 different notebooks published by the Los Angeles Times
Install JupyterLab¶
Now we will return pipenv and use it to JupyterLab, the web-based interactive development environment for Jupyter notebooks, code and data.
pipenv install jupyterlab
Create your first notebook¶
Now we can use pipenv’s run command to start JupyterLab from your terminal.
pipenv run jupyter lab
That will open up a new tab in your default web browser that looks something like this:
Click the “Python 3” button in the middle panel and create a new Python 3 notebook.
Write Python in the notebook¶
Now you are all setup and ready to start writing Python code.
Do not stress. There is nothing too fancy about it. You can start by just doing a little simple math.
Type the following into the first box, then hit the play button in the toolbar above the notebook (or hit SHIFT+ENTER on your keyboard).
2+2
There. You have just written your first Python code. You have entered two integers and added them together using the plus sign operator.
Not so bad, right?
Note
If you get an error after you run a cell, look carefully at your code and see that it exactly matches what’s been written in the example. Don’t worry.
 They’re usually caused by small typos that can be quickly corrected.
This to-and-fro of writing Python code in a notebook cell and then running it with the play button is the rhythm of working in a notebook. Over time you will gradually stack cells to organize an analysis that runs from top to bottom.
The cells can contain variables, functions and other Python tools.
A simple example would be storing your number in a variable in one cell …
number = 2
… then adding it to another number in the next.
number + 3
Run those two cells in succession and the notebook should output the number five. Change the number value to 3 and run both cells again and it should output six.
Note
If you’ve never written Python before, we recommend An Informal Introduction to Python and subsequent sections of python.org’s tutorial.
Once you’ve got the hang of making the notebook run, you’re ready to introduce pandas, the powerful Python analysis library that can do a whole lot more than add a few numbers together.


{{ _("OCDS Extension Explorer") }}
{{ _('Disclose more data about your contracting processes, using extensions to the Open Contracting Data Standard.', lang=lang) }}
{{ _("For data publishers") }}
{{ _("OCDS defines a core set of fields and codes for describing contracting processes. You can use extensions to describe additional fields outside the core set.") }}
{{ _("Read the publisher guidance") }}{{ _("For data users") }}
{{ _("OCDS data can include fields and codes from the OCDS schema and from extensions. To understand extended data, you need to identify which extensions are used and read the extensions' documentation.") }}
{{ _("Read the user guidance") }}


| libxml2 Reference Manual |
|---|
xmlwriter - text writing API for XML
text writing API for XML
Author(s): Alfred Mickautsch<EMAIL_ADDRESS>#define xmlTextWriterWriteDocType; #define xmlTextWriterWriteProcessingInstruction; typedef struct _xmlTextWriter xmlTextWriter; typedef xmlTextWriter * xmlTextWriterPtr; void xmlFreeTextWriter (xmlTextWriterPtr writer); xmlTextWriterPtr xmlNewTextWriter (xmlOutputBufferPtr out); xmlTextWriterPtr xmlNewTextWriterDoc (xmlDocPtr * doc,
int compression); xmlTextWriterPtr xmlNewTextWriterFilename (const char * uri,
int compression); xmlTextWriterPtr xmlNewTextWriterMemory (xmlBufferPtr buf,
int compression); xmlTextWriterPtr xmlNewTextWriterPushParser (xmlParserCtxtPtr ctxt,
int compression); xmlTextWriterPtr xmlNewTextWriterTree (xmlDocPtr doc,
xmlNodePtr node,
int compression); int xmlTextWriterEndAttribute (xmlTextWriterPtr writer); int xmlTextWriterEndCDATA (xmlTextWriterPtr writer); int xmlTextWriterEndComment (xmlTextWriterPtr writer); int xmlTextWriterEndDTD (xmlTextWriterPtr writer); int xmlTextWriterEndDTDAttlist (xmlTextWriterPtr writer); int xmlTextWriterEndDTDElement (xmlTextWriterPtr writer); int xmlTextWriterEndDTDEntity (xmlTextWriterPtr writer); int xmlTextWriterEndDocument (xmlTextWriterPtr writer); int xmlTextWriterEndElement (xmlTextWriterPtr writer); int xmlTextWriterEndPI (xmlTextWriterPtr writer); int xmlTextWriterFlush (xmlTextWriterPtr writer); int xmlTextWriterFullEndElement (xmlTextWriterPtr writer); int xmlTextWriterSetIndent (xmlTextWriterPtr writer,
int indent); int xmlTextWriterSetIndentString (xmlTextWriterPtr writer,
const xmlChar * str); int xmlTextWriterSetQuoteChar (xmlTextWriterPtr writer,
xmlChar quotechar); int xmlTextWriterStartAttribute (xmlTextWriterPtr writer,
const xmlChar * name); int xmlTextWriterStartAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI); int xmlTextWriterStartCDATA (xmlTextWriterPtr writer); int xmlTextWriterStartComment (xmlTextWriterPtr writer); int xmlTextWriterStartDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid); int xmlTextWriterStartDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name); int xmlTextWriterStartDTDElement (xmlTextWriterPtr writer,
const xmlChar * name); int xmlTextWriterStartDTDEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name); int xmlTextWriterStartDocument (xmlTextWriterPtr writer,
const char * version,
const char * encoding,
const char * standalone); int xmlTextWriterStartElement (xmlTextWriterPtr writer,
const xmlChar * name); int xmlTextWriterStartElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI); int xmlTextWriterStartPI (xmlTextWriterPtr writer,
const xmlChar * target); int xmlTextWriterWriteAttribute (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content); int xmlTextWriterWriteAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const xmlChar * content); int xmlTextWriterWriteBase64 (xmlTextWriterPtr writer,
const char * data,
int start,
int len); int xmlTextWriterWriteBinHex (xmlTextWriterPtr writer,
const char * data,
int start,
int len); int xmlTextWriterWriteCDATA (xmlTextWriterPtr writer,
const xmlChar * content); int xmlTextWriterWriteComment (xmlTextWriterPtr writer,
const xmlChar * content); int xmlTextWriterWriteDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * subset); int xmlTextWriterWriteDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content); int xmlTextWriterWriteDTDElement (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content); int xmlTextWriterWriteDTDEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid,
const xmlChar * content); int xmlTextWriterWriteDTDExternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid); int xmlTextWriterWriteDTDExternalEntityContents (xmlTextWriterPtr writer,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid); int xmlTextWriterWriteDTDInternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * content); int xmlTextWriterWriteDTDNotation (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid); int xmlTextWriterWriteElement (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content); int xmlTextWriterWriteElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const xmlChar * content); int xmlTextWriterWriteFormatAttribute (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...); int xmlTextWriterWriteFormatAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
... ...); int xmlTextWriterWriteFormatCDATA (xmlTextWriterPtr writer,
const char * format,
... ...); int xmlTextWriterWriteFormatComment (xmlTextWriterPtr writer,
const char * format,
... ...); int xmlTextWriterWriteFormatDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const char * format,
... ...); int xmlTextWriterWriteFormatDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...); int xmlTextWriterWriteFormatDTDElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...); int xmlTextWriterWriteFormatDTDInternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char * format,
... ...); int xmlTextWriterWriteFormatElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...); int xmlTextWriterWriteFormatElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
... ...); int xmlTextWriterWriteFormatPI (xmlTextWriterPtr writer,
const xmlChar * target,
const char * format,
... ...); int xmlTextWriterWriteFormatRaw (xmlTextWriterPtr writer,
const char * format,
... ...); int xmlTextWriterWriteFormatString (xmlTextWriterPtr writer,
const char * format,
... ...); int xmlTextWriterWritePI (xmlTextWriterPtr writer,
const xmlChar * target,
const xmlChar * content); int xmlTextWriterWriteRaw (xmlTextWriterPtr writer,
const xmlChar * content); int xmlTextWriterWriteRawLen (xmlTextWriterPtr writer,
const xmlChar * content,
int len); int xmlTextWriterWriteString (xmlTextWriterPtr writer,
const xmlChar * content); int xmlTextWriterWriteVFormatAttribute (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatCDATA (xmlTextWriterPtr writer,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatComment (xmlTextWriterPtr writer,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatDTDElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatDTDInternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatPI (xmlTextWriterPtr writer,
const xmlChar * target,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatRaw (xmlTextWriterPtr writer,
const char * format,
va_list argptr); int xmlTextWriterWriteVFormatString (xmlTextWriterPtr writer,
const char * format,
va_list argptr);
#define xmlTextWriterWriteDocType;
this macro maps to xmlTextWriterWriteDTD
#define xmlTextWriterWriteProcessingInstruction;
This macro maps to xmlTextWriterWritePI
struct _xmlTextWriter { The content of this structure is not made public by the API. } xmlTextWriter;
xmlTextWriter * xmlTextWriterPtr;
void xmlFreeTextWriter (xmlTextWriterPtr writer)
Deallocate all the resources associated to the writer
| writer: | the xmlTextWriterPtr |
xmlTextWriterPtr xmlNewTextWriter (xmlOutputBufferPtr out)
Create a new xmlNewTextWriter structure using an xmlOutputBufferPtr NOTE: the @out parameter will be deallocated when the writer is closed (if the call succeed.)
| out: | an xmlOutputBufferPtr |
| Returns: | the new xmlTextWriterPtr or NULL in case of error |
xmlTextWriterPtr xmlNewTextWriterDoc (xmlDocPtr * doc,
int compression)
Create a new xmlNewTextWriter structure with @*doc as output
| doc: | address of a xmlDocPtr to hold the new XML document tree |
| compression: | compress the output? |
| Returns: | the new xmlTextWriterPtr or NULL in case of error |
xmlTextWriterPtr xmlNewTextWriterFilename (const char * uri,
int compression)
Create a new xmlNewTextWriter structure with @uri as output
| uri: | the URI of the resource for the output |
| compression: | compress the output? |
| Returns: | the new xmlTextWriterPtr or NULL in case of error |
xmlTextWriterPtr xmlNewTextWriterMemory (xmlBufferPtr buf,
int compression)
Create a new xmlNewTextWriter structure with @buf as output TODO: handle compression
| buf: | xmlBufferPtr |
| compression: | compress the output? |
| Returns: | the new xmlTextWriterPtr or NULL in case of error |
xmlTextWriterPtr xmlNewTextWriterPushParser (xmlParserCtxtPtr ctxt,
int compression)
Create a new xmlNewTextWriter structure with @ctxt as output NOTE: the @ctxt context will be freed with the resulting writer (if the call succeeds). TODO: handle compression
| ctxt: | xmlParserCtxtPtr to hold the new XML document tree |
| compression: | compress the output? |
| Returns: | the new xmlTextWriterPtr or NULL in case of error |
xmlTextWriterPtr xmlNewTextWriterTree (xmlDocPtr doc,
xmlNodePtr node,
int compression)
Create a new xmlNewTextWriter structure with @doc as output starting at @node
| doc: | xmlDocPtr |
| node: | xmlNodePtr or NULL for doc->children |
| compression: | compress the output? |
| Returns: | the new xmlTextWriterPtr or NULL in case of error |
int xmlTextWriterEndAttribute (xmlTextWriterPtr writer)
End the current xml element.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndCDATA (xmlTextWriterPtr writer)
End an xml CDATA section.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndComment (xmlTextWriterPtr writer)
End the current xml comment.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndDTD (xmlTextWriterPtr writer)
End an xml DTD.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndDTDAttlist (xmlTextWriterPtr writer)
End an xml DTD attribute list.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndDTDElement (xmlTextWriterPtr writer)
End an xml DTD element.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndDTDEntity (xmlTextWriterPtr writer)
End an xml DTD entity.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndDocument (xmlTextWriterPtr writer)
End an xml document. All open elements are closed, and the content is flushed to the output.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written or -1 in case of error |
int xmlTextWriterEndElement (xmlTextWriterPtr writer)
End the current xml element.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterEndPI (xmlTextWriterPtr writer)
End the current xml PI.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterFlush (xmlTextWriterPtr writer)
Flush the output buffer.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterFullEndElement (xmlTextWriterPtr writer)
End the current xml element. Writes an end tag even if the element is empty
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterSetIndent (xmlTextWriterPtr writer,
int indent)
Set indentation output. indent = 0 do not indentation. indent > 0 do indentation.
| writer: | the xmlTextWriterPtr |
| indent: | do indentation? |
| Returns: | -1 on error or 0 otherwise. |
int xmlTextWriterSetIndentString (xmlTextWriterPtr writer,
const xmlChar * str)
Set string indentation.
| writer: | the xmlTextWriterPtr |
| str: | the xmlChar string |
| Returns: | -1 on error or 0 otherwise. |
int xmlTextWriterSetQuoteChar (xmlTextWriterPtr writer,
xmlChar quotechar)
Set the character used for quoting attributes.
| writer: | the xmlTextWriterPtr |
| quotechar: | the quote character |
| Returns: | -1 on error or 0 otherwise. |
int xmlTextWriterStartAttribute (xmlTextWriterPtr writer,
const xmlChar * name)
Start an xml attribute.
| writer: | the xmlTextWriterPtr |
| name: | element name |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI)
Start an xml attribute with namespace support.
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix or NULL |
| name: | element local name |
| namespaceURI: | namespace URI or NULL |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartCDATA (xmlTextWriterPtr writer)
Start an xml CDATA section.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartComment (xmlTextWriterPtr writer)
Start an xml comment.
| writer: | the xmlTextWriterPtr |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid)
Start an xml DTD.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name)
Start an xml DTD ATTLIST.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD ATTLIST |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartDTDElement (xmlTextWriterPtr writer,
const xmlChar * name)
Start an xml DTD element.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD element |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartDTDEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name)
Start an xml DTD ATTLIST.
| writer: | the xmlTextWriterPtr |
| pe: | TRUE if this is a parameter entity, FALSE if not |
| name: | the name of the DTD ATTLIST |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartDocument (xmlTextWriterPtr writer,
const char * version,
const char * encoding,
const char * standalone)
Start a new xml document
| writer: | the xmlTextWriterPtr |
| version: | the xml version ("1.0") or NULL for default ("1.0") |
| encoding: | the encoding or NULL for default |
| standalone: | "yes" or "no" or NULL for default |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartElement (xmlTextWriterPtr writer,
const xmlChar * name)
Start an xml element.
| writer: | the xmlTextWriterPtr |
| name: | element name |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI)
Start an xml element with namespace support.
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix or NULL |
| name: | element local name |
| namespaceURI: | namespace URI or NULL |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterStartPI (xmlTextWriterPtr writer,
const xmlChar * target)
Start an xml PI.
| writer: | the xmlTextWriterPtr |
| target: | PI target |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteAttribute (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content)
Write an xml attribute.
| writer: | the xmlTextWriterPtr |
| name: | attribute name |
| content: | attribute content |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const xmlChar * content)
Write an xml attribute.
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix |
| name: | attribute local name |
| namespaceURI: | namespace URI |
| content: | attribute content |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteBase64 (xmlTextWriterPtr writer,
const char * data,
int start,
int len)
Write an base64 encoded xml text.
| writer: | the xmlTextWriterPtr |
| data: | binary data |
| start: | the position within the data of the first byte to encode |
| len: | the number of bytes to encode |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteBinHex (xmlTextWriterPtr writer,
const char * data,
int start,
int len)
Write a BinHex encoded xml text.
| writer: | the xmlTextWriterPtr |
| data: | binary data |
| start: | the position within the data of the first byte to encode |
| len: | the number of bytes to encode |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteCDATA (xmlTextWriterPtr writer,
const xmlChar * content)
Write an xml CDATA.
| writer: | the xmlTextWriterPtr |
| content: | CDATA content |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteComment (xmlTextWriterPtr writer,
const xmlChar * content)
Write an xml comment.
| writer: | the xmlTextWriterPtr |
| content: | comment string |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * subset)
Write a DTD.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| subset: | string content of the DTD |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content)
Write a DTD ATTLIST.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD ATTLIST |
| content: | content of the ATTLIST |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTDElement (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content)
Write a DTD element.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD element |
| content: | content of the element |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTDEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid,
const xmlChar * content)
Write a DTD entity.
| writer: | the xmlTextWriterPtr |
| pe: | TRUE if this is a parameter entity, FALSE if not |
| name: | the name of the DTD entity |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| ndataid: | the xml notation name. |
| content: | content of the entity |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTDExternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid)
Write a DTD external entity. The entity must have been started with xmlTextWriterStartDTDEntity
| writer: | the xmlTextWriterPtr |
| pe: | TRUE if this is a parameter entity, FALSE if not |
| name: | the name of the DTD entity |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| ndataid: | the xml notation name. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTDExternalEntityContents (xmlTextWriterPtr writer,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid)
Write the contents of a DTD external entity.
| writer: | the xmlTextWriterPtr |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| ndataid: | the xml notation name. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTDInternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * content)
Write a DTD internal entity.
| writer: | the xmlTextWriterPtr |
| pe: | TRUE if this is a parameter entity, FALSE if not |
| name: | the name of the DTD entity |
| content: | content of the entity |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteDTDNotation (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid)
Write a DTD entity.
| writer: | the xmlTextWriterPtr |
| name: | the name of the xml notation |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteElement (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * content)
Write an xml element.
| writer: | the xmlTextWriterPtr |
| name: | element name |
| content: | element content |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const xmlChar * content)
Write an xml element with namespace support.
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix |
| name: | element local name |
| namespaceURI: | namespace URI |
| content: | element content |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatAttribute (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...)
Write a formatted xml attribute.
| writer: | the xmlTextWriterPtr |
| name: | attribute name |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
... ...)
Write a formatted xml attribute.with namespace support
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix |
| name: | attribute local name |
| namespaceURI: | namespace URI |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatCDATA (xmlTextWriterPtr writer,
const char * format,
... ...)
Write a formatted xml CDATA.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatComment (xmlTextWriterPtr writer,
const char * format,
... ...)
Write an xml comment.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const char * format,
... ...)
Write a DTD with a formatted markup declarations part.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...)
Write a formatted DTD ATTLIST.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD ATTLIST |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatDTDElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...)
Write a formatted DTD element.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD element |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatDTDInternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char * format,
... ...)
Write a formatted DTD internal entity.
| writer: | the xmlTextWriterPtr |
| pe: | TRUE if this is a parameter entity, FALSE if not |
| name: | the name of the DTD entity |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
... ...)
Write a formatted xml element.
| writer: | the xmlTextWriterPtr |
| name: | element name |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
... ...)
Write a formatted xml element with namespace support.
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix |
| name: | element local name |
| namespaceURI: | namespace URI |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatPI (xmlTextWriterPtr writer,
const xmlChar * target,
const char * format,
... ...)
Write a formatted PI.
| writer: | the xmlTextWriterPtr |
| target: | PI target |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatRaw (xmlTextWriterPtr writer,
const char * format,
... ...)
Write a formatted raw xml text.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteFormatString (xmlTextWriterPtr writer,
const char * format,
... ...)
Write a formatted xml text.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| ...: | extra parameters for the format |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWritePI (xmlTextWriterPtr writer,
const xmlChar * target,
const xmlChar * content)
Write an xml PI.
| writer: | the xmlTextWriterPtr |
| target: | PI target |
| content: | PI content |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteRaw (xmlTextWriterPtr writer,
const xmlChar * content)
Write a raw xml text.
| writer: | the xmlTextWriterPtr |
| content: | text string |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteRawLen (xmlTextWriterPtr writer,
const xmlChar * content,
int len)
Write an xml text. TODO: what about entities and special chars??
| writer: | the xmlTextWriterPtr |
| content: | text string |
| len: | length of the text string |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteString (xmlTextWriterPtr writer,
const xmlChar * content)
Write an xml text.
| writer: | the xmlTextWriterPtr |
| content: | text string |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatAttribute (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr)
Write a formatted xml attribute.
| writer: | the xmlTextWriterPtr |
| name: | attribute name |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatAttributeNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
va_list argptr)
Write a formatted xml attribute.with namespace support
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix |
| name: | attribute local name |
| namespaceURI: | namespace URI |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatCDATA (xmlTextWriterPtr writer,
const char * format,
va_list argptr)
Write a formatted xml CDATA.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatComment (xmlTextWriterPtr writer,
const char * format,
va_list argptr)
Write an xml comment.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatDTD (xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const char * format,
va_list argptr)
Write a DTD with a formatted markup declarations part.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD |
| pubid: | the public identifier, which is an alternative to the system identifier |
| sysid: | the system identifier, which is the URI of the DTD |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatDTDAttlist (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr)
Write a formatted DTD ATTLIST.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD ATTLIST |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatDTDElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr)
Write a formatted DTD element.
| writer: | the xmlTextWriterPtr |
| name: | the name of the DTD element |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatDTDInternalEntity (xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char * format,
va_list argptr)
Write a formatted DTD internal entity.
| writer: | the xmlTextWriterPtr |
| pe: | TRUE if this is a parameter entity, FALSE if not |
| name: | the name of the DTD entity |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatElement (xmlTextWriterPtr writer,
const xmlChar * name,
const char * format,
va_list argptr)
Write a formatted xml element.
| writer: | the xmlTextWriterPtr |
| name: | element name |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatElementNS (xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char * format,
va_list argptr)
Write a formatted xml element with namespace support.
| writer: | the xmlTextWriterPtr |
| prefix: | namespace prefix |
| name: | element local name |
| namespaceURI: | namespace URI |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatPI (xmlTextWriterPtr writer,
const xmlChar * target,
const char * format,
va_list argptr)
Write a formatted xml PI.
| writer: | the xmlTextWriterPtr |
| target: | PI target |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatRaw (xmlTextWriterPtr writer,
const char * format,
va_list argptr)
Write a formatted raw xml text.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |
int xmlTextWriterWriteVFormatString (xmlTextWriterPtr writer,
const char * format,
va_list argptr)
Write a formatted xml text.
| writer: | the xmlTextWriterPtr |
| format: | format string (see printf) |
| argptr: | pointer to the first member of the variable argument list. |
| Returns: | the bytes written (may be 0 because of buffering) or -1 in case of error |


Introduction
Welcome to Gmem’s Plugin Tracker APIs documentation! First off, thanks for having some interest in the project - I hope with your help we can make it better.
The API does most of the heavy lifting. The actual Java plugin needs to do very little work. A handful of bytes (okay maybe a bit more than that) is actually sent to the server.
Getting Started
This is a sample of a Java POST method. If you know of a better method contact me.
String urlParameters = "port=" + _PORT + "&api_key=12345ABC123ABCDE_abc&online=true";
byte[] postData = urlParameters.getBytes(StandardCharsets.UTF_8);
int postDataLength = postData.length;
String request = "http://mc.gabrielsimmer.com/mcpluginstats/api/info.php";
URL url = new URL(request);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setDoOutput(true);
conn.setInstanceFollowRedirects(false);
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Length", Integer.toString(postDataLength));
conn.setUseCaches(false);
try (DataOutputStream wr = new DataOutputStream(conn.getOutputStream())) {
wr.write(postData);
}catch(Exception e){
// Error
}
You can use the following to get the port the server is bound to:
int _PORT = Bukkit.getPort();
First, you need an API key for your plugin. Go to your dashboard and click the New
link. It will require you to name your plugin, then it will give you a key in the format of
12345ABC123ABCDE_abc
.
Next, copy and modify the code in the sidebar with your own API key and variables.
The server will return JSON data with either true
or false
. Whether or not your plugin handles this is up to you.
Result JSON
The API will return JSON like this:
{"sucsess":true,"id":1}
The API will return a small segment of JSON code. Whether or not you want your plugin to handle this is up to you.
sucsess
is a bool value of whether or not the POST was sucsessful.id
is the ID of the result. See errors if you get something other than1
.
Errors
An error will look something like this
{"sucsess":false,"id":404}
The API uses the following error codes:
| Error Code | Meaning |
|---|---|
| 300 | Database error — Something went wrong with the APIs database |
| 403 | Port not an int – The port sent to the server is not an integer |
| 404 | No data sent — No data was POSTed to the server |
| 405 | Online? — Online variable is not boolean or invalid |
| 406 | No API key — No valid API key recieved |


I'm a second year Ph.D. student in computer science at the University of Colorado Boulder. My advisors are Professors Rafael Frongillo and Joshua Grochow.
Before coming here, I completed an M.S. in applied math at UMass Amherst. My undergraduate degree is also from UMass, where I majored in pure math with a minor in philosophy.
Research Interests:
Algorithmic Economics, Complex Adaptive Systems, Local-to-global theory, and Distributed Multi-agent Systems
Contact: gabriel.andrade@colorado.edu


fretboard-api
home
CAGED
Octaves
Transposition
Tunings
Octaves shapes
Simple definition:
var s = new api.Shape("0X2");
Predefined octave shapes:
fretboardApi.SHAPES.OCTAVES


Input Image 1
Input Image 2
Apply
Blur
Gaussian Blur
Sharpen
Unsharpen
Raise
Motion Blur
Laplacian
Invert Colors
Black'n'White
Sepia
Sobel Edge Detection
Fisrt Image Weight
Second Image Weight


Christian Critic's Movie Parables - http://www.christiancritic.com
SNOW FALLING ON CEDARS * * out of * * * * stars ========================
DIRECTED BY: Scott Hicks STARRING: Ethan Hawkes, Youki Kudoh, James Cromwell, Rick Yune, Sam Shepard, Max Von Sydow WRITTEN BY: Ron Bass, Scott Hicks RATED: PG-13 for disturbing images, sensuality, and brief strong language SCRIPTURE REFERENCES: 1 John 3:13, John 17:14, John 15:18-19
Befitting of its picturesque name, SNOW FALLING ON CEDARS sure is pretty to watch. But it doesn't take long to realize that the film moves with the same plodding pace as a man trying to trudge uphill along an unplowed street following a blizzard. Exquisitely beautiful but excruciatingly slow sums up Scott Hicks' (SHINE) latest endeavor.
The film takes a look at stateside Japanese-American relations during the time of the Second World War. Set in the scenic Pacific Northwest, SNOW FALLING ON CEDARS centers around a murder trial where American-born Kazuo Miyamoto (Rick Yune in his film debut) is accused of murdering his boyhood friend, an American fisherman.
Covering the trial is Ishmael Chambers (Ethan Hawke, GATTICA), a young newspaperman for the small community on San Piedro Island. As we see in a series of flashbacks, Ishmael has a number of conflicting emotions at work. Most importantly, the defendant's wife, Hatsue (Youki Kudoh, MYSTERY TRAIN) was Ishmael's secret childhood sweetheart in a severed relationship which was never reconciled. At least, not as far as Ishmael was concerned.
Secondly, there's the memory of his father (Sam Shepard, SAFE PASSAGE), also a newspaperman who had the conviction to take an unpopular stand against the injustice being carried out via the internment of Japanese-American citizens during the 1940's. This earned Ishmael's father the respect of the Japanese community and has given Ishmael some mighty big shoes to fill. The tension, what little there is, comes from our wondering whether Ishmael will even try.
Based upon the award winning novel by David Guterson, the screenplay (Ron Bass, ENTRAPMENT and Scott Hicks, SHINE) takes a non-lineal approach to telling its story, jumping from decade to decade, from prewar to postwar to finally, in the war. While this can often be an effective device, here it serves to distance us from the characters instead of drawing us into them. Instead of revealing more about the characters' lives, each flashback merely adds another layer onto them, like a fresh snow will add a pristine blanket to a rural landscape.
Mr. Hawke underplays his character and his conflicting emotions almost to the point that we will be excused for thinking that he didn't have any. Whether mooning or pining away for his "forbidden love" of Hatsue, most of his anguish is internalized and unexpressed.
Ms. Kudoh is just as enigmatic, leaving Hatsue's emotional life to be displayed by the actress who played the character as a young girl. In fact, we gain more insight into Ishmael and Hatsue from the fine work done by young Reeve Carney and Ann Suzuki who play the same characters as children than we do from their adult counterparts.
Max Von Sydow (WHAT DREAMS MAY COME) as Kazuo's defense attorney, provides support in what is a relatively minor role as does Sam Shepard as the principled newspaperman and father to Ishmael.
Taking a stand by publicly denouncing the government's mistreatment of the Japanese-American community who lived on San Piedro Island was not without a price. Ishmael's father was scorned, his paper lost subscribers, and his family was threatened with physical harm. That type of reaction is one which we conceivably may experience in our own lives whenever we choose to stand upon the truth of God's Word. God's Word prepares those who choose to follows Its teachings by letting us know what to expect from those with opposing views:
"Marvel not, my brethren, if the world hate you." 1 John 3:13 [KJV]
"I have given them thy word; and the world hath hated them, because they are not of the world, even as I am not of the world." John 17:14 [KJV]
Taking a stand because it is the right thing to do is oftentimes hard because we know that it may make us unpopular for a time. What we should remember is that it also makes us well-pleasing in God's sight. And ultimately, it is for Him we live.
Michael Elliott January 2000 http://www.christiancritic.com
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


Page maintained by Ke-Sen Huang.
If you have additions or changes, send an e-mail.
Information here is provided with the permission of the ACM.
Note that when possible I link to the page containing the link to the actual PDF or PS of the preprint.
I prefer this as it gives some context to the paper and avoids possible copyright problems with direct linking.
Thus you may need to search on the page to find the actual document.
ACM Digital Library: ACM Transactions on Graphics (TOG) Volume 28 , Issue 3 (August 2009) Proceedings of ACM SIGGRAPH 2009
the ACM Digital Library (DOI) Link for the paper
the link of author version paper
the link of project page
Changelog
- Gaussian KD-Trees for Fast High-Dimensional Filtering
-
Andrew Adams
(Stanford University),
Natasha Gelfand
(Nokia Research Center),
Jennifer Dolson,
Marc Levoy
(Stanford University)
- Edge-Avoiding Wavelets and thier Applications
-
Raanan Fattal
(The Hebrew University of Jerusalem)
- Multi-operator Media Retargeting
-
Michael Rubinstein
(Tel-Aviv University),
Ariel Shamir
(The Interdisciplinary Center),
Shai Avidan
(Adobe Systems Inc.)
- PatchMatch: A Randomized Correspondence Algorithm for Structural Image Editing
-
Connelly Barnes
(Princeton University),
Eli Shechtman
(Adobe Systems Inc.),
Adam Finkelstein
(Princeton University),
Dan Goldman
(Adobe Systems Inc.)
- 2D Piecewise Algebraic Splines for Implicit Modeling
-
Qingde Li
(University of Hull),
Jie Tian
(Chinese Academy of Sciences)
- A BSP-based algorithm for dimensionally nonhomogeneous planar implicit curves with topological guarantees
-
Abel J. P. Gomes,
Jose F. M. Morgado,
Edgar S. Pereira
(Universidade da Beira Interior, Covilha, Portugal)
- Interpolatory Point Set Surfaces -- Convexity and Hermite Data
-
Marc Alexa
(Technische Universitat Berlin),
Anders Adamson (Sinora)
- A Variational Approach for Automatic Generation of Panoramic Maps
-
Patrick Degener,
Reinhard Klein
(Universitat Bonn)
- Light Warping for Enhanced Surface Depiction
-
Romain Vergne,
Romain Pacanowski,
Pascal Barla,
Xavier Granier,
Christophe Schlick
(INRIA Bordeaux)
- Toward Evaluating Lighting Design Interface Paradigms for Novice Users
-
William Kerr,
Fabio Pellacini
(Dartmouth College),
- Modeling Human Color Perception under Extended Luminance Levels
-
Min H. Kim,
Tim Weyrich,
Jan Kautz
(University College London)
- How Well Do Line Drawings Depict Shape?
-
Forrester Cole
(Princeton University,
Kevin Sanik,
Doug DeCarlo
(Rutgers University),
Adam Finkelstein,
Thomas Funkhouser,
Szymon Rusinkiewicz
(Princeton University
Manish Singh
(Rutgers University)
- Kernel Nystrom Method for Light Transport
-
Jiaping Wang
(Microsoft Research Asia),
Yue Dong
(Microsoft Research Asia and Tsinghua University).
Xin Tong,
Zhouchen Lin
(Microsoft Research Asia),
Baining Guo
(Microsoft Research Asia and Tsinghua University)
- An Empirical BSSRDF Model
-
Craig Donner
(Columbia University),
Jason Lawrence
(University of Virginia),
Ravi Ramamoorthi
(University of California at Berkeley),
Toshiya Hachisuka
Henrik Wann Jensen
(University of California, San Diego),
Shree Nayar
(Columbia University)
- SubEdit: A Representation for Editing Measured Heterogenous Subsurface Scattering
-
Ying Song,
Xin Tong
(Microsoft Research Asia),
Fabio Pellacini
(Dartmouth College),
Pieter Peers
(Institute for Creative Technologies, University of Southern California)
- Fabricating Microgeometry for Custom Surface Reflectance
-
Tim Weyrich
(University College London),
Pieter Peers
(Institute for Creative Technologies, University of Southern California),
Wojciech Matusik
(Adobe Systems, Inc.),
Szymon Rusinkiewicz
(Princeton University and Adobe Systems, Inc.)
- iWIRES: An Analyze-and-Edit Approach to Shape Manipulation
-
Ran Gal
(Tel-Aviv University),
Olga Sorkine
(New York University),
Niloy Mitra
(Indian Institute of Technology),
Daniel Cohen-Or
(Tel-Aviv University)
- Variational Harmonic Maps for Space Deformation
-
Mirela Ben-Chen,
Ofir Weber,
Craig Gotsman
(Technion-Israel Institute of Technology)
- Joint-aware Manipulation of Deformable Models
-
Weiwei Xu
(Microsoft Research Asia),
Jun Wang
(University of Science and Technology of China),
KangKang Yin
(Microsoft Research Asia),
Kun Zhou
(Zhejiang University),
Michiel van de Panne
(University of British Columbia),
Falai Chen
(University of Science and Technology of China),
Baining Guo
(Microsoft Research Asia)
- Semantic Deformation Transfer
-
Ilya Baran,
Daniel Vlasic
(Massachusetts Institute of Technology),
Eitan Grinspun
(Columbia University),
Jovan Popović
(Massachusetts Institute of Technology and Adobe Systems, Inc.)
- Harmonic Fluids
-
Changxi Zheng,
Doug James
(Cornell University)
- Energy-Preserving Integrators for Fluid Animation
-
Patrick Mullen
Keenan Crane,
Dmitry Pavlov
(California Institute of Technology),
Yiying Tong
(Michigan State University),
Mathieu Desbrun
(California Institute of Technology)
- Modular Bases for Fluid Dynamics
-
Martin Wicke
(Stanford University),
Matthew Stanton,
Adrien Treuille
(Carnegie Mellon University)
- Predictive-Corrective Incompressible SPH
-
Barbara Solenthaler,
Renato Pajarola
(University of Zurich)
- Directable, High-Resolution Simulation of FIre on the GPU
-
Christopher Horvath, Willi Geiger
(Industrial Light & Magic)
- Moving Gradients: A Path-Based Method for Plausible Image Interpolation
-
Dhruv Mahajan,
Fu-Chung Huang
(Columbia University),
Wojciech Matusik
(Adobe Systems, Inc.),
Ravi Ramamoorthi
(University of California at Berkeley),
Peter N. Belhumeur
(Columbia University)
- Optimizing Content-Preserving Projections for Wide-Angle Images
-
Robert Carroll,
Maneesh Agrawala
(University of California, Berkeley),
Aseem Agarwala
(Adobe Systems, Inc.)
- Content-Preserving Warps for 3D Video Stabilization
-
Feng Liu,
Michael Gleicher
(University of Wisconsin),
Hailin Jin,
Aseem Agarwala
(Adobe Systems, Inc.)
- Photogrammetric Texture Mapping using Casual Images
-
Yochay Tzur,
Ayellet Tal
(Technion-Israel Institute of Technology)
- Generalizing Motion Edits With Gaussian Processes
-
Leslie Ikemoto
(Animate Me),
Okan Arikan
(University of Texas, Austin),
David Forsyth
(University of Illinois at Urbana-Champaign),
- Optimization-Based Interactive Motion Synthesis
-
Sumit Jain,
Yuting Ye,
C. Karen Liu
(Georgia Institute of Technology)
- Lie Group Integrators for Animation and Control of Vehicles
-
Marin Kobilarov,
Keenan Crane,
Mathieu Desbrun
(California Institute of Technology)
- NURBS with Extraordinary Points: High-degree, Non-uniform, Rational Subdivision Schemes
-
Tom Cashman,
Ursula Augsdörfer,
Neil Dodgson,
Malcolm Sabin
(University of Cambridge)
- Direct Trimming of NURBS Surfaces on the GPU
-
Andre Schollmeyer,
Bernd Froehlich
(Bauhaus-Universitat Weimar)
- Bi-3 C2 Polar Subdivision
-
Ashish Myles,
Jorg Peters
(University of Florida)
- Symmetric Tiling of Closed Surfaces: Visualization of Regular Maps
-
Jarke J. van Wijk
(Technische Universiteit Eindhoven)
- Enrichment Textures for Detailed Cutting of Shells
-
Peter Kaufmann
Sebastian Martin,
(ETH Zurich),
Mario Botsch
(Bielefeld University),
Eitan Grinspun
(Columbia University),
Markus Gross
(ETH Zurich)
- Numerical Coarsening of Inhomogeneous Elastic Materials
-
Lily Kharevych,
Patrick Mullen,
Houman Owhadi,
Mathieu Desbrun
(California Institute of Technology)
- Preserving Topology and Elasticity for Embedded Deformable Models
-
Matthieu Nesme
(McGill University, Grenoble Universites, INRIA and LJK-CNRS),
Paul G. Kry
(McGill University),
Lenka Jeřábková
(INRIA and LJK-CNRS),
François Faure
(Grenoble Universites, INRIA and LJK-CNRS)
- Deformable Object Animation Using Reduced Optimal Control
-
Jernej Barbic,
Marco da Silva
(Massachusetts Institute of Technology),
Jovan Popovic
(Massachusetts Institute of Technology and Adobe Systems, Inc.)
- Procedural Noise using Sparse Gabor Convolution
-
Ares Lagae
(Katholieke Universiteit Leuven),
Sylvain Lefebvre
(REVES / INRIA Sophia-Antipolis),
George Drettakis
(REVES / INRIA Sophia-Antipolis),
Philip Dutré
(Katholieke Universiteit Leuven)
- Eye-Catching Crowds: Saliency-Based Selective Variation
-
Rachel McDonnell,
Micheal Larkin
(Trinity College Dublin),
Benjamin Hernandez,
Isaac Rudomin
(Instituto Tecnologico y de Estudios Superiores de Monterrey),
Carol O'Sullivan
(Trinity College Dublin)
- Example-based Hair Geometry Synthesis
-
Lvdi Wang
(Tsinghua University),
Yizhou Yu
(University of Illinois at Urbana-Champaign),
Kun Zhou
(Zhejiang University),
Baining Guo
(Microsoft Research Asia)
- Visio-lization: Generating Novel Facial Images
-
U. Mohammed, S. J. D. Prince,
Jan Kautz
(University College London)
- Self-Organizing Tree Models for Image Synthesis
-
Wojtek Palubicki,
Kipp Horel,
Steven Longay,
Adam Runions,
Brendan Lane
(University of Calgary),
Radomir Mech
(Adobe Systems Inc.),
Przemyslaw Prusinkiewicz
(University of Calgary)
- Fourier Depth-of-Field
-
Cyril Soler ,
Kartic Subr
(INRIA Rhone-Alpes),
Fredo Durand
(Massachusetts Institute of Technology),
Nicolas Holzschuch,
Francois Sillion
(INRIA Rhone-Alpes)
- Compressive Light Transport Sensing
-
Pieter Peers
(Institute for Creative Technologies, University of Southern California),
Dhruv Mahajan,
(Columbia University)
Bruce Lamond,
Abhjeet Ghosh
(Institute for Creative Technologies, University of Southern California),
Wojciech Matusik
(Adobe Systems, Inc.),
Ravi Ramamoorthi
(University of California at Berkeley),
Paul Debevec
(Institute for Creative Technologies, University of Southern California)
- Display Supersampling
-
Niranjan Damera-Venkata,
Nelson L. Chang
(HP Labs)
- GRAMPS: A Programming Model for Graphics Pipelines
-
Jeremy Sugerman,
Kayvon Fatahalian,
Solomon Boulos
(Stanford University),
Kurt Akeley
(Microsoft Research),
(Pat Hanrahan)
(Stanford University),
- Dextrous Manipulation from a Grasping Pose
-
C. Karen Liu
(Georgia Institute of Technology)
- Optimal Gait and Form for Animal Locomotion
-
Kevin Wampler,
Zoran Popović
(University of Washington)
- Performance-Based Control Interface for Character Animation
-
Satoru Ishigaki,
Timothy White
(Georgia Institute of Technology),
Victor Zordan
(University of California, Riverside),
C. Karen Liu
(Georgia Institute of Technology)
- Detail-Preserving Continuum Simulation of Straight Hair
-
Aleka McAdams
(University of California, Los Angeles),
Andrew Selle,
Kelly Ward
(Walt Disney Animation Studios),
Eftychios Sifakis,
Joseph Teran
(University of California, Los Angeles),
- Affine Double and Triple Product Wavelet Integrals for Rendering
-
Bo Sun
(Columbia University),
Ravi Ramamoorthi
(University of California at Berkeley)
- Participating-Media Illumination Using Light-Propagation Maps
-
Raanan Fattal
(The Hebrew University of Jerusalem)
- A Tool to Create Illuminant and Reflectance Spectra for Light-Driven Graphics and Visualization
-
Steven Bergner
Mark S. Drew
Torsten Moller
(Simon Fraser University)
- Automatic Pre-Tessellation Culling
-
Jon Hasselgren,
Jacob Munkberg,
Tomas Akenine-Moller
(Lund University and Intel Corporation)
- Real-Time Hand-Tracking with a Color Glove
-
Robert Y. Wang
(Massachusetts Institute of Technology),
Jovan Popović
(Massachusetts Institute of Technology and Adobe Systems, Inc.)
- Achieving Eye Contact in a One-to-Many 3D Video Teleconferencing System
-
Andrew Jones,
Magnus Lang,
Graham Fyffe,
Xeuming Yu,
Jay Busch
(Institute for Creative Technologies, University of Southern California),
Ian McDowall
(Fakespace Labs),
Mark Bolas
(University of Southern California Institute for Creative Technologies & School of Cinematic Arts),
Paul Debevec
(Institute for Creative Technologies, University of Southern California)
- The UnMousePad - An Interpolating Multi-Touch Force-Sensing Input Pad
-
Ilya Rosenberg,
Ken Perlin
(New York University Media Research Lab)
- Generating Photo Manipulation Tutorials by Demonstration
-
Floraine Grabler,
Maneesh Agrawala
(University of California at Berkeley),
Wilmot Li
Mira Dontcheva
(Adobe Systems, Inc.),
Takeo Igarashi
(The University of Tokyo)
- Coordinates for Instant Image Cloning
-
Zeev Farbman
(The Hebrew University ),
Gil Hoffer
(Tel-Aviv University),
Yaron Lipman
(Princeton University),
Daniel Cohen-Or
(Tel-Aviv University),
Dani Lischinski
(The Hebrew University )
- SkyFinder: Attribute-based Sky Image Search
-
Litian Tao,
Lu Yuan
(Hong Kong University of Science & Technology),
Jian Sun
(Microsoft Research Asia)
- Paint Selection
-
Jiangyu Liu,
Jian Sun
(Microsoft Research Asia),
Heung-Yeung Shum
(Microsoft Research)
- Video SnapCut: Robust Video Object Cutout Using Localized Classifiers
-
Xue Bai
(University of Minnesota),
Jue Wang,
David Simons
(Adobe Systems, Inc.),
Guillermo Saprio
(University of Minnesota)
- Efficient Reconstruction of Nonrigid Shape and Motion From Real-Time 3D Scanner Data
-
Michael Wand
(Max-Planck-Institut fur Informatik),
Bart Adams
(Stanford University and Katholieke Universiteit Leuven),
Maksim Ovsjanikov
(Stanford University),
Alexander Berner,
Martin Bokeloh,
Philipp Jenke
(Universitat Tubingen, WSI/GRIS),
Leonidas Guibas
(Stanford University),
Hans-Peter Seidel
(Max-Planck-Institut fur Informatik),
Andreas Schilling
(Universitat Tubingen, WSI/GRIS)
- An Edge-Based, Computationally Efficient Formulation of Saint Venant-Kirchhoff Tetrahedral Finite Elements
-
Ryo Kikuuwe,
Hiroaki Tabuchi,
Motoji Yamamoto
(Kyushu University)
- Fitting Solid Meshes to Animated Surfaces Using Linear Elasticity
-
Jaeil Choi
(Georgia Institute of Technology),
Andrzej Szymczak
(Colorado School of Mines)
- Data-Driven Curvature for Real-Time Line Drawing of Dynamic Scenes
-
Evangelos Kalogerakis,
Derek Nowrouzezahrai,
Patricio Simari,
James McCrae,
Aaron Hertzmann,
Karan Singh
(University of Toronto)
- Curve Skeleton Extraction from Incomplete Point Cloud
-
Andrea Tagliasacchi,
Hao Zhang
(Simon Fraser University),
Daniel Cohen-Or
(Tel-Aviv University)
- Mobius Voting for Surface Correspondence
-
Yaron Lipman,
Thomas Funkhouser
(Princeton University)
- A Benchmark for 3D Mesh Segmentation
-
Xiaobai Chen,
Aleksey Golovinskiy,
Thomas Funkhouser
(Princeton University)
- Interactive Hausdorff distance computation for general polygonal models
-
Min Tang, Minkyoung Lee,
Young J. Kim
(Ewha Womans University)
- Interleaving Delaunay Refinement and Optimization for Practical Isotropic Tetrahedron Mesh Generation
-
Jane Tournois
(INRIA Sophia-Antipolis),
Camille Wormser
(ETH Zurich),
Pierre Alliez
(INRIA Sophia-Antipolis),
Mathieu Desbrun
(California Institute of Technology)
- Deforming Meshes that Split and Merge
-
Chris Wojtan
(Georgia Institute of Technology),
Nils Thuerey,
Markus Gross
(ETH Zurich),
Greg Turk
(Georgia Institute of Technology)
- Mixed-Integer Quadrangulation
-
David Bommes,
Henrik Zimmer,
Leif Kobbelt
(RWTH Aachen)
- Cyclic Plain-Weaving on Polygonal Mesh Surfaces with Graph Rotation Systems
-
Ergun Akleman,
Jianer Chen,
Qing Xing
(Texas A&M University),
Jonathan Gross
(Columbia University)
- Synchronized Multi-Character Motion Editing
-
Manmyung Kim,
Kyung Lyul Hyun,
Jongmin Kim,
Jehee Lee
(Seoul National University)
- Momentum Control for Balance
-
Adriano Macchietto,
Victor Zordan,
Christian R. Shelton
(University of California, Riverside)
- Contact-aware Nonlinear Control of Dynamic Characters
-
Uldarico Muico,
Yongjoon Lee
(University of Washington),
Jovan Popović
(Massachusetts Institute of Technology and Adobe Systems, Inc.)
Zoran Popović
(University of Washington)
- Linear Bellman Combination for Control of Character Animation
-
Marco da Silva,
Fredo Durand
(Massachusetts Institute of Technology),
Jovan Popovic
(Massachusetts Institute of Technology and Adobe Systems, Inc.)
- A Visibility Algorithm for Converting 3D Meshes Into Editable 2D Vector Graphics
-
Elmar Eisemann
(Universitat des Saarlandes, Max Planck Institut Informatik),
Sylvain Paris
(Adobe Systems, Inc.),
Fredo Durand
(Massachusetts Institute of Technology)
- Local Layering
-
James McCann,
Nancy Pollard
(Carnegie Mellon University)
- Automatic and Topology-Preserving Gradient Mesh Generation for Image Vectorization
-
Yu-Kun Lai
Shi-Min Hu
(Tsinghua University),
Ralph R. Martin
(Cardiff University)
- Capacity-constrained Point Distributions: A Variant of Lloyd's Method
-
Michael Balzer,
Thomas Schlömer,
Oliver Deussen
(University of Konstanz, Germany )
- Asynchronous Contact Mechanics
-
David Harmon,
Etienne Vouga,
Breannan Smith
(Columbia University),
Rasmus Tamstorf
(Walt Disney Animation Studios),
Eitan Grinspun
(Columbia University)
- Interactive Simulation of Surgical Needle Insertion and Steering
-
Nuttapong Chentanez
(University of California, Berkeley),
Ron Alterovitz
(University of North Carolina at Chapel Hill),
Daniel Ritchie,
Lita Cho,
Kris K. Hauser,
Ken Goldberg,
Jonathan R. Shewchuk,
James F. O'Brien
(University of California, Berkeley)
- Capture and Modeling of Non-Linear Heterogeneous Soft Tissue
-
Bernd Bickel
(ETH Zurich),
Moritz Baecher
(ETH Zurich),
Miguel A. Otaduy
(URJC Madrid),
Wojciech Matusik
(Adobe Systems, Inc.),
Hanspeter Pfister
(Harvard University),
Markus Gross
(ETH Zurich)
- Physically Guided Liquid Surface Modeling from Videos
-
Huamin Wang
(Georgia Institute of Technology),
Miao Liao,
Qing Zhang,
Ruigang Yang,
(University of Kentucky)
Greg Turk
(Georgia Institute of Technology)
- An Efficient GPU-based Approach for Interactive Global Illumination
-
Rui Wang
(Zhejiang University),
Rui Wang
(University of Massachusetts),
Kun Zhou,
Minghao Pan,
Hu-Jun Bao
(Zhejiang University)
- Single Scattering in Refractive Media with Triangle Mesh Boundaries
-
Bruce Walter,
Shuang Zhao
(Cornell University),
Nicolas Holzschuch
(INRIA Rhone-Alpes),
Kavita Bala
(Cornell University)
- Frequency Analysis and Sheared Reconstruction for Rendering Motion Blur
-
Kevin Egan,
Yu-Ting Tseng
(Columbia University),
Nicolas Holzschuch,
(INRIA Rhone-Alpes),
Fredo Durand
(Massachusetts Institute of Technology),
Ravi Ramamoorthi
(University of California at Berkeley),
- Adaptive Global Visibility Sampling
-
Jiri Bittner
(Czech Technical University in Prague),
Oliver Mattausch
(Vienna University of Technology),
Peter Wonka
(Arisona State University),
Vlastimil Havran
(Czech Technical University in Prague),
Michael Wimmer
(Vienna University of Technology)
- Invertible Motion Blur in Video
-
Amit Agrawal
(Mitsubishi Electric Research Labs (MERL)),
Yi Xu
(Purdue University),
Ramesh Raskar
(Massachusetts Institute of Technology)
- Dark Flash Photography
-
Dilip Krishnan,
Rob Fergus
(New York University)
- 4D Frequency Analysis of Computational Cameras for Depth of Field Extension
-
Anat Levin,
Sam Hasinoff,
Paul Green,
Fredo Durand,
William T. Freeman
(Massachusetts Institute of Technology)
- Bokode: Imperceptible Visual Tags for Camera-based Interaction from a Distance
-
Ankit Mohan,
Grace Woo
(Massachusetts Institute of Technology),
Shinsaku Hiura
(Osaka University),
Quinn Smithwick,
Ramesh Raskar
(Massachusetts Institute of Technology)
kesen.huang@gmail.com


GWK Farms brings a fresh perspective to eating and living. GWK is South Africa’s farming community established in the Northern Cape where the splendid Vaal and Orange rivers meet. All our products are made from high quality, fresh ingredients sourced from our local family of farms. To honour our roots we have named all of our products after these expert local family of farms. Ethically sourced, wholesome goodness in every bite means that our products not only taste good, they also do good.
The GWK Farms pasta range includes spaghetti, macaroni, penne, screws and elbows.
GWK Farms range of flours provide a great place to start when setting out to bake your favourite cakes and breads.
GWK Farm's product range is deliciously versatile.
Find your nearest Nature’s Farms stockist on the map below


follow us on twitter, Facebook and Instagram. We give special offers on our facebook page and you can see what we are up to on our instagram account.


Hello......... it's an example of Plain Text. HTML5 enables to create more interactive websites. The purpose of HTML5 is primarily to make it easier for web developers


#ftl output_format="HTML" auto_esc=true> <#import "layout/default.html" as layout><EMAIL_ADDRESS>Dear ${notificationTarget.name},
The assessment period for the competition ${competitionNumber}: ${competitionName} is now complete and your application has moved to the next stage.
You can review the project in the project setup section of the Innovation Funding Service, while we continue to review your application. We will contact you if we have any queries or require more information.
Your knowledge transfer adviser (KTA) will provide application feedback after the funding decision has been made.
<EMAIL_ADDRESS>href="${dashboardUrl}" text="Sign in" />Yours sincerely
<EMAIL_ADDRESS>/> @layout.default>


Returns the contents of a cell as they would appear in the formula bar. The contents are given as text, for example, "=2*PI()/360". If the formula contains references, they are returned as R1C1-style references, such as "=RC[1]*(1+R1C1)". Use GET.FORMULA to get a formula from a cell in order to edit its arguments. Use GET.CELL(6) to get a formula in either A1 or R1C1 format, depending on the workspace setting.
Syntax
GET.FORMULA(reference)
Reference is a cell or range of cells on a sheet or macro sheet.
If a range of cells is selected, GET.FORMULA returns the contents of the upper-left cell in reference.
Reference can be an external reference.
Reference can be the object identifier of a picture created by the camera tool.
Reference can also be a reference to a chart series in the form "Sn" where n is the number of the series. When a chart series is specified, GET.FORMULA returns the series formula using R1C1-style references.
Tip If you want to get the formula in the active cell, use the ACTIVE.CELL function as the reference argument.
Examples
If cell A3 on the active sheet contains the number 523, then:
GET.FORMULA(!$A$3) equals "523"
If cell C2 on the active sheet contains the formula =B2*(1+$A$1), then:
GET.FORMULA(!$C$2) equals "=RC[-1]*(1+R1C1)"
The following macro formula returns the contents of the active cell on the active sheet:
GET.FORMULA(ACTIVE.CELL())
Related Functions
GET.CELL Returns information about the specified cell
GET.DEF Returns a name matching a definition
GET.NAME Returns the definition of a name
GET.NOTE Returns characters from a comment
Return to index


Cooking time
less than 10 mins
Serves
Serves 1
For the salmon, place the breadcrumbs, herbs, garlic and salt and freshly ground black pepper into a bowl and mix together.
Dip the salmon into the beaten egg and then dip into the breadcrumb mixture.
Heat the oil in a frying pan over a high heat and fry the salmon on both sides for 2-3 minutes or until golden brown and cooked through.
For the sautéed potatoes, in a separate frying pan, heat the olive oil over a medium heat. Add the garlic, rosemary and potato slices and sauté for five minutes until golden.
To serve, place the sautéed potatoes onto a serving plate and place the salmon on top.


{{person.movie_credits.cast.length}}
Movies known for
Gender: Female
Gender: Male
Birthday: {{person.birthday | date : 'mediumDate'}}
Place of birth:
{{person.place_of_birth}}
{{person.name | uppercase}}
{{person.popularity | percentage : 4}}
Also known as: {{person.also_known_as[0]}}
{{person.biography}}
CAST