GeoTools is a free, open source Java geospatial toolkit for working with both vector and raster data. GeoTools is associated with the GeoAPI project that creates a vendor-neutral set of geospatial, Java interfaces derived from OGC specifications.

GeoTools is a general purpose geospatial library with a large feature set including:

• Create and Analyze graphs and networks
• Powerful “schema assisted” parsing technology using XML Schema to bind to GML content.
• Interact with OGC web services with both Web Map Server and Web Feature Server support
• JDBC plug-ins for DB2, H2, PostGIS, MySQL, SpatialLite, SQL Server

GeoTools implements Open Geospatial Consortium (OGC) specifications as they are developed including:

• Support for OGC Grid Coverage implementation
• Symbology using OGC Styled Layer Descriptor (SLD) specification
• Attribute and spatial filters using OGC Filter Encoding specification
• Supports Java Topology Suite (JTS), an implementation of OGC Simple Features Specification – that covers 2D constructs like Point, Line and Polygon. JTS allows 3D shapes (by having a third point) to be represented, but not used for calculations.
• Coordinate reference system and transformation support (for providing meaning to the Geometry or shapes of JTS)
• GeoTools plans to support OpenGIS ISO Geometry Interfaces for 3D and curves.

GeoTools includes two Renderers:

• LiteRenderer – a stateless, low memory renderer, particularly useful in server-side environments
• J2D – a stateful renderer with optimizations for update rate and good for interactive client-side displays

GeoTools supports additional formats through the use of Open plug-in system. The formats supported by an application can be controlled by including ONLY the required plug-ins. The plug-ins are available for raster formats – geotiff, gtopo30, world plus image files using common image formats such as JPEG, TIFF, GIF and PNG, imagemosaic, imagepyramid, JP2K. Plug-ins for the ImageIO-EXT project allows GeoTools to read additional raster formats from GDAL.

The GeoTools library forms a software “stack” with each jar building on the previous one (ref. http://docs.geotools.org/latest/userguide/welcome/geotools.html). GeoTools provides API (application programming interfaces) both for representing the data structures as well as to access public classes to execute a function. Only the jars needed for an application can be included. For referencing, gt-opengis, gt-referencing and gt-metadata are required. Similarly to use Data, you need gt-api, gt-data, gt-main, jts, gt-opengis, gt-referencing, gt-opengis, gt-metadata.

GeoTools code is distributed under the GNU Lesser General Public License (LGPL) and can be used for commercial applications. If the GeoTools library itself is modified, then you have to publish the source code to those changes to the users of your application (or optionally submit it back to GeoTools).

GeoTools uses a modular architecture with high extensibility allowing additional functionality to be easily incorporated. Modules with a gold star rating indicating their quality (3 or more stars means great) is listed in http://docs.codehaus.org/display/GEOTOOLS/Module+Matrix.

GeoTools can be used to access GIS data in many file formats and spatial databases, filter and analyze data in terms of spatial and non-spatial attributes, compose and display maps with complex styling and work with an extensive range of map projections.

Geographic Information Systems (GIS) are expected to become more and more useful in IT (as a picture is worth thousand words) and GeoTools is a good way to start exploring it and applying it in reallife applications – as it supports a large number of formats and more standardized (though some of the APIs are not – though the public access API are expected to remain stable).

Ubuntu 11.04, code named “Natty Narwhal, released recently, has got a new look and feel for Ubuntu and has taken a major step in the right direction attracting both the desktop and netbook users. The Linux Kernel 2.6.38 which includes a patch that boosts the performance of the kernel across desktops is part of Natty and users upgrading to Ubuntu 11.04 can also expect great performance improvements.

Unquestionably, the new Unity Interface is the most appreciated by the users and it is said that for new users, the features are so intuitive making it easy to adapt. Ubuntu 11.04 ships with Compiz that offers settings such as Backlight always on, launcher animations, urgent animations, and special window transparency options. Those users who had considered Unity slow and buggy and as a major drawback of Ubuntu now agree that it is on par with other major desktop experience.

The new launcher that sits on the left-hand side of your screen is to make getting to the favourite tools and applications quick and easy. The new Unity interface supports drag and drop, providing easier file management.

The new dashboard, that appears when you click on the Ubuntu logo on the top-left corner, makes it simpler to access shortcuts and search for applications and programs. Now you get fast and easy access to email, music, pictures and others.

The Workspaces, enables by clicking the Workspaces icon in the launcher, simplify managing multiple windows (keeping track of open windows). By using Workspaces, you can make all your active spaces to pop up and easily move different windows.

But since the new interface has quite a few significant changes, earlier users can avoid it and continue using the earlier Classic Interface instead. It is also pointed out that the new interface is quite welcome and worth getting used to. More details on Unity at.

The new Unity Interface is based on Compiz that relies heavily on OpenGL and it creates a problem working with low-end graphic cards (which impacts Ubuntu’s know ability of running on most PCs including the ones with outdated configurations). Unity 2D project, https://launchpad.net/unity-2d, aims to provide a Unity environment on hardware platforms that don’t support Unity’s Open GL requirements.

Banshee 2.0 (instead of Rhythmbox) is the default music player in Ubuntu 11.04. As pointed out in http://banshee.fm/download/archives/2.0.0/, it has taken six months of 36 developers and can be considered quite successful in both the aspects of bug fixes and new features. Banshee 2.0 provides Artist/Album Browser Track Actions, ‘Play After’ Queue options, video support, audiobooks support etc. There are some doubts raised about the stability of Banshee compared to Rhythmbox (mainly based on experience of earlier versions) but most point out that the new features make Banchee match up with the competing products like iTunes and Windows Media Player.

LibreOffice, the forked office suite with the same features as OpenOffice, is the default office suite in Ubuntu 11.04. LibreOffice team effort in cleaning up the code, and provide a more frequent update and bug fixes (compared to OpenOffice, especially after the taking over of Sun by Oracle) is quite appreciated by one and all.

Ubuntu One, that provides 2GB of space for keeping one’s files on the cloud allowing users to access their contacts, notes, or bookmarks from any computer with an internet connection is now got a better user interface and well integrated with Ubuntu.

Ubuntu, that is available for free (really), can be downloaded to a CD and run without having to install it in the machine. With it becoming quite easy to use, it is expected most users who try would ultimately install it.  Ubuntu installation using Ubiquity now includes options to Install side by side (dual boot), Upgrade, or Replace an existing Ubuntu Installation. The lack of viruses and worms – compared to other major desktop OSes – is another factor expected to boost Ubuntu usage.

Ubuntu 11.04 seems to be really on the way to make “Linux Desktop Mainstream” as originally discussed in http://itknowledgeexchange.techtarget.com/enterprise-IT-tech-trends/ubuntu-linux-desktop-becoming-mainstream/.

Mashups are expected to be used by the business users directly (and not require programming skill) and the tag language EMML makes it easy to learn and use. Using the simple statements and commands of EMML, quite a few useful mashups can be created.

As usage of Mashup accelerates, the tendency to create more powerful and complex mashups would follow. In this blog, I have tried to give the crux of some of these advanced techniques.

Web clipping for direct use of HTML

Using the web clipping (or Screen scraping) technique, you can get the entire HTML from any URL as a service response. The EMML Reference Runtime Engine converts the HTML retrieved by the <directinvoke> statement is to XHTML in the http://www.w3.org/1999/xhtml namespace. You can filter, combine or transform with XHTML to create your own output.

Example of <directInvoke> resulting in web clipping:

The itemlink list in the XML result is as follows:

Normalizing Data for Effective Joins, Grouping or Filtering

Mashups – as the name suggests – is expected to get results from different services (not designed to work with each other). Though similar data is obtained from these services invoked, they would not be in identical forms. For effective usage of joins, grouping or filtering these results from different services, normalization of data to a single representation becomes essential. Creating a custom XPath function is the best method to normalize data.

The following example shows joining mortgage rates from two web sites – one refers to the APR and the second uses custom terms:

Create the custom XPath function – to normalize the custom terminology – as a Java class myFinanceFunction that extends org.oma.emml.client.EMMLUserFunction.

Compile this class, adding web-apps-home/emml/WEB-INF/lib/emml.jar to the classpath. Deploy the compiled class to web-apps-home/emml/WEB-INF/classes for the EMML Engine that host the mashups using this function.

Add a namespace for the class as an xmlns attribute to the <mashup> tag that uses this function.

Use the custom function in the XPath expressions in the <join> statement (or where data needs to be normalized).

Removing Duplicates With Filtering

To remove duplicates in a mashup, simply merge, join or group results. Sort the combined results (If needed) based on the key field that determines uniqueness to ensure that duplicates are contiguous. Use <filter> with a filtering expression that compares the key value of either the preceding or following ‘item’ to determine if this ‘item’ is unique. The filter expression can use the axis feature in XPath to compare preceding or following items.

Following is a simple <filter> statement:

<filter inputvariable=”$a” outputvariable=”$a” filterexpr=”/rss/channel/item[contains(title,'Java')" />]

In addition to the default XPath axis – the child axis, you can refer to previous nodes (preceding / preceding-sibling), following nodes (following / following-sibling), the parent node, ancestor nodes, descendant nodes and others. You can also use wildcards like following::* or following::node() to identify all following nodes of any name.

The following example checks the title of each item (after merging results from two RSS services) to remove duplicates:

I shall cover some more techniques in the second part of this blog. The Advanced Mashup Techniques are detailed in http://www.openmashup.org/omadocs/v1.0/emml/advMashupIntro.html.

Open Mashup Alliance (OMA) is a consortium aimed at successful use of Enterprise Mashup technologies and adoption of an open language – Enterprise Mashup Markup Language (EMML) – that promotes Enterprise Mashup interoperability and portability. EMML is an XML language to describe the processing flow for a mashup. The OMA provides the EMML schema and also a reference runtime implementation that processes mashup scripts written in EMML.

The EMML package can be downloaded from http://www.openmashup.org/download. Before installing the EMML package, install the JDK (1.5 or above) and Tomcat 5.5 or another compatible application server. EMML samples can be downloaded from http://www.openmashup.org/download.

You can create a mashup script using any XML editor. Adding the EMML schema, emml-install/EMMLSpec.xsd, to the XML editor – enables the editor to provide syntax assistance and validation. A Mashup script – an XML file that uses EMML – is created to define:

• the services and operations to be used by the mashup and
• the actions to apply to service responses to construct the results of the mashup.

Following is a simple mashup script that invokes a service (most viewed stories) and filters the output (business).

 Two categories of elements are added to mashups:

• Declarations for variables, parameters, data sources, namespaces, macros or metadata.
• Statements that perform actions – to invoke services, control flow, act on the results or use custom statements defined in macros – for the mashup.

Variables and Parameters

Variables and parameters must be declared (explicitly or implicitly) before they are used in any other EMML statement. Variables and parameters have a name, a datatype, data (a value), a scope (global or local) and optionally a default value. Variables can be created implicitly by assigning a name to the outputvariable attribute for any statement.

• <input> is an optional element to declare parameters that can be used as input to mashup, operation or macro.
• <output> is the parameter that holds the result returned from a mashup, operation or macro.
• <variables> is a list of variables to use for input, output or to hold any intermediate data or document content in the flow of mashup processing.

Accessing a database

To invoke SQL queries or statements, <datasource> with connection information for the database must be declared.  Each <datasource> declaration must have a URL that defines the JDBC connection and database login information (or) a JNDI name for connections to the database. Connection information can also be set dynamically as follows:

Note that, to use a <datasource>, you must add the JAR files containing JDBC drivers for your data source to the EMML Reference Runtime Engine classpath and add configuration for these drivers.

Use <sql>to issue individual SQL queries to a data source – for example:

Use <sqlUpdate> to execute any other SQL statement against a data source – for example:

<sql> and <sqlUpdate> can also be used to invoke stored procedures. SQL transactions can be managed using <sqlBeginTransaction>, <sqlCommit> and <sqlRollback>. EMML currently does not support distributed transactions.

Accessing a Web Service

Using <directinvoke>, you can invoke a publically accessible web service or website. In case of service invocation error, the EMML Reference Runtime Engine returns error information in two built-in variables: faultcode and faultmessage.

Transforming Intermediate Results

The mashup statements that can be used to select specific results, sort results, or otherwise transform the data in variables include:

• <assign> – to assign values or copy part of all of a variable
• <filter> – to filter a variable
• <group> – to group data in a variable and optionally filter or sort
• <sort> – to sort a variable
• <annotate> – to add nodes and data to a variable
• <xslt> – to transform data using XSLT stylesheets

Additionally, XPath functions can be used to transform data, change datatypes, perform calculations or determine boolean conditions.

Using the <script> statement, user-defined code can be executed within mashup processing. JavaScript and JRuby 1.0 are the scripting languages currently supported.

Combining Service Results

Results of two or more component services can be combined using:

1. <merge> – to merge service results that have homogenous, document-type structures (similar to database union operation)

2. <join> – to define how the data from disparate variables should be joined. Variable data should have repetitive structures that are related based on some criteria – say, the foreign keys that define the relation. It is comparable to inner joins for databases.

3. XQuery – to obtain outer joins in mashups.

Constructing the Mashup Result, Input or Intermediate Variables

The following statements can be used to define the structure of the result that is returned from a mashup, or to construct complex input parameters or any complex intermediate variable:

• <constructor> to construct a well-formed document.
• <appendresult> to add one or more well-formed items to a variable.
• <select> (within <mashup>, <operation> or <macro>)
• <select> within a <join> command to select specific items within a set of repeating items. See <join>.
• <group> constructs repeating structures from sorted and optionally filtered node sets.

Literal XML can also be used to construct the contents of variables or input parameters.

Controlling Mashup Processing Flow

The mashup commands to control the processing flow for a mashup operation includes:

• <if> for conditional processing
• <for> for looping based on simple counts
• <foreach> for looping through a set of nodes. This can be simple iterative loops or loops can be processed concurrently.
• <while> for looping as long as a condition is true
• <break> to forceably stop looping statements
• Concurrent Mashup Processing Flows using <parallel>.
• SQL Transactions using <sqlBeginTransaction>, <sqlCommit> and <sqlRollback>.

Using <emml-meta> and <user-meta>, metadata can be declared to allow setting of processing flags or pass other information to applications that will use a mashup, use a macro or handle mashup results.

EMML, like any other tag language, is quite simple to use and can be used by business users to create mashups quickly. EMML also supports various statements and commands that can be used to create complex Mashups depending on the needs of the user.