Introduction to Lucy

What is Lucy?

Lucy is a powerful, high-level application framework for rapidly building applications that let you explore, analyze, and edit all kinds of geospatial data. Lucy is based on LuciadLightspeed, and integrates the functionality of LuciadLightspeed in a configurable application.

The major Lucy benefit is that it comes with a lot of functionality common to many GIS applications built-in. For example, Lucy allows you to:

  • Load extra data by drag-and-dropping it on the application, or going to File | Open from the menu

  • Select objects on the map, and display the object properties

  • Open a tabular view of your data, in addition to visualizing the data on the map

  • Open a terrain profile view that contains the data from your main map

  • Search through all your data, and fit the map on the results

  • Customize the styling of your data through the UI

  • Add annotations to the map

  • Print the map, or convert it to PDF

  • Save the state of your application in a workspace

  • Work with time-dependent data, and use the UI to control data visualization from a time perspective

Lucy is neither a finished application nor an end-user product. It is a framework that allows you to build your own application by customizing functionality, and by adding it to and removing it from the Lucy framework.

Lucy modular design: the framework in combination with add-ons

Lucy consists of two main parts:

  • The add-ons: an add-on is a piece of code that plugs in a specific piece of functionality such as the ability to create a map view, to perform terrain analysis, and so on.

    It is very easy to:

    • Remove add-ons: because each of the add-ons provide specific functionality to Lucy, you can remove that functionality by removing the add-on.

    • Customize existing add-ons: often you want to keep the functionality offered by an add-on, but tune it slightly to match your specific Lucy application requirement. The majority of the add-ons have a configuration file that allows you to make simple modifications.

      For more complex modifications, you can write custom code using the API offered by the add-on.

    • Adding your own add-ons: by writing your own add-on and plugging it into the framework, you can add your own piece of functionality to Lucy.

  • The Lucy framework: the glue between the different add-ons for presenting them as a single, solid application. Its main responsibilities include providing the communication between the different add-ons, loading all the add-ons when the application starts, and providing the main UI of Lucy.

The Lucy API is built on top of the other LuciadLightspeed API. Lucy add-ons are built on top of the Lucy API but they can also use the rest of the LuciadLightspeed API:

Figure 1. Architecture of the Lucy API

Lucy framework components

The Lucy framework consists of the Lucy front-end and the Lucy back-end.

The Lucy front-end

The Lucy front-end is responsible for:

  • Starting the application

  • Creating a pluggable user interface and passing it to the back-end

  • Loading all add-ons and passing those to the back-end

The Lucy API comes with a default front-end implementation that uses dockable frames:

lucy dockable frontend

It also comes with a number of sample front-ends, including a map-centric version with a dark look-and-feel:

lucy mapcentric frontend

You can also write a complete custom front-end with unlimited flexibility with respect to the user interface, as explained in the Lucy front-end documentation.

The Lucy back-end

The Lucy back-end is the glue between the add-ons. Amongst other things, it is responsible for:

  • The communication between the add-ons

  • Managing the loaded add-ons by adding, removing and retrieving them

  • Managing the available data formats

This is explained in detail in the Lucy back-end documentation.

Lucy configuration files

The config/lucy folder contains many configuration files with .cfg extensions. These are typical Java properties files containing collections of key-value pairs.

Those files allow you to make small modifications to Lucy without writing custom code.

The configuration files are used:

By the front-end

The Lucy front-end has a configuration file lucy.cfg that specifies general Lucy startup and GUI properties. It also points to the file specifying which add-ons need to be loaded. By default, this is the addons.xml file.

Examples of add-ons are the Lucy functionalities added to support specific data formats, such as AIXM files for instance.

By the add-ons

Each of the available add-ons also has its own .cfg configuration file with the configuration specific to that add-on. addons.xml points to the right configuration file for an add-on with the <configFile> tag.