The first paper "The Modular Modeling System (MMS): A Toolbox for Enviormental-Resource Management" describes the system that the USGS created to integrate it various models. The system is a sort of development environment where a complex model is made by linking the input and output of many smaller models. 
 
The second paper "Streamflow Forecasting Using the Modular Modeling System and an Object-User Interface" describes the creation of a watershed model using the MMS system.  
 
Nasa probably want a system similar to the MMS designed and implemented for their various models. Which would be software development and not research at all. 

Posted by: Donald Johnson

The paper describes a method of a determining watersheds by coloring a DEM using a map of divergence of flow directions. The rendering process is not complicated and the only unusually thing being used to determine coloring. The image resulting form this is then manually segmented into basins. task that the coloring makes fairly trivial. The only prospective research is developing an algorithm that automates the last part and comparing it to existing basin delineation programs. This is not a Visualization problem. 

Posted by: Donald Johnson

Posted by: Donald Johnson

The javascript canvas is a 2D display widget avaliable on Firefox, Safari, and Opera. The is are plugins that make the widget avaliable for IE. Placing a canvas in a web page is almost identical to placing a picture the <canvas> element requires 3 attributes: height, width, and id. Placing a canvas results in a blank rectangle of the specified hieght and width. All drawing on the canvas is done with a javascript calls. 
 
The canvas 2D api is quite advanced and has support for the following operations. 
 
Canvas State Methods 
 
* restore - restore canvas to last saved state 
* rotate - rotate the coordinate space 
* save - save the canvas state 
* scale - scale the cordiante space 
* translate - translate the cordinate space 
 
Working With Paths 
 
* arc  
* arcTo 
* bezierCurveTo 
* beginPath 
* clip 
* closePath 
* lineTo 
* moveTo 
* quadraticCurveTo 
* rect 
 
Stroking a Path 
 
* stroke 
* strokeRect 
 
Filling an Area 
 
* clearRect 
* fill 
* fillRect 
 
Creating Gradient and Pattern Styles 
 
* addColorStop 
* createLinearGradient 
* createPattern 
* createRadialGradient 
 
Drawing an Image 
 
* drawImage 
* drawImageFromRect 

Posted by: Donald Johnson

If there are any functions or objects defined in the root class they will be given piority over the index function when resolving urls. For instance if a root object had an function named foo defined in it, the url hostname/foo would be created by the returned result of that function. This is the case even if the index function was capable of accepting the agument foo. If foo was an object instead of a function the url hostname/foo would be resolved by the index method of the foo object. now consider the url hostname/foo/bar. This could be handled by in several ways if a object named foo is defined the page returned will be created by the function or object bar defined in foo. If foo is an function defined in the root object then bar will be a parameter passed to foo. There is no limit to the depth of the tree created in this way. 

Posted by: Donald Johnson

The first level of handling is the index function of the root class. This function in its simplest form, controls what will be returned when just the domain name of the server is requested. When the index function takes only one parameter it will answer only for the domain name, however it may take parameters. If all parameters have default values the index function will still answer for the domain name otherwise the parameters will need to be given values in the url. values may be given by position or by name using the scheme ?paramname=value. The index function can defined to take an unknown number of parameters if defined with def index(self,*args). In this case the function would have to examine the arguments given and generate a page accordingly. 

Posted by: Donald Johnson

Turbogears responds to URL request by traversing an internal function/object tree. The root of this tree is the class root defined in the code module controlers.py. Every turbogears project as its own controlers.py file. URLs are matched to the defined functions and objects of the root file. This terminates when a function is reached. The function matched in this way returns the web page. 

Posted by: Donald Johnson