{"id":46705,"date":"2015-10-12T10:00:18","date_gmt":"2015-10-12T07:00:18","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=46705"},"modified":"2015-10-11T13:10:54","modified_gmt":"2015-10-11T10:10:54","slug":"openmap-tutorial-part-1","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2015\/10\/openmap-tutorial-part-1.html","title":{"rendered":"OpenMap Tutorial – Part 1"},"content":{"rendered":"

Introduction<\/h2>\n

This series of tutorials will show you how to build Java applications using the OpenMap<\/a> GIS Java Swing library.<\/p>\n

OpenMap’s Developer guide<\/a> is a very useful document that describes OpenMap’s architecture but it doesn’t explain how to start and build up an application step-by-step. The examples that come together with the source code are useful but not enough.<\/p>\n

OpenMap is written in Swing. As of this writing the latest version is 5.1.12. You can download both source code and executable jars from GitHub<\/a>. Once you copy\/unzip\/clone it to a directory, you can execute it by either running the relevant script for your platform (openmap.bat<\/code> or openmap<\/code>) or by double clicking on lib\/openmap.jar<\/code>. You should see a full GIS application like the one in Figure 1. We will try to build a similar application by the end of this series. The OpenMap source code also contains some examples of how to use OpenMap. In this tutorial we shall be based on com.bbn.openmap.app.example.SimpleMap<\/code>. In the second tutorial we will be using code from com.bbn.openmap.app.example.SimpleMap2<\/code>. Later tutorials will be based on other examples.<\/p>\n

In this series of tutorials we shall use the latest NetBeans<\/a> IDE 8.1 to create our applications.<\/p>\n

Tutorial 1 \u2013 Build a basic map application<\/h2>\n

Create a JFrame application<\/h3>\n

In this first tutorial we shall build a basic JFrame <\/code>application that contains a map (see Figure 2). Open NetBeans and create a new Java application by following these steps:<\/p>\n

    \n
  1. Open menu File \u2192 New Project<\/strong> and select Category<\/em>: Java <\/strong>and Project<\/em>: Java Application <\/strong>(Figure 3). Click Next<\/strong>.<\/li>\n
  2. In the next step, provide a name and a location. Make sure you use a dedicated folder for the libraries and that you don’t select a main class (Figure 4). Click on Finish<\/strong>.<\/li>\n
  3. Once your new project has been created, create a new package named openmap <\/code>by right-clicking on Source Packages<\/em> and selecting New \u2192 Java Package<\/strong> from the popup menu.<\/li>\n
  4. Right-click on Libraries<\/strong> folder and select the action Add JAR\/Folder<\/strong> from the popup menu. Navigate to the lib <\/code>folder of your OpenMap<\/em> installation and select openmap.jar<\/code>. You can use a relative path or better copy it to your Libraries<\/em> folder (Figure 5). Click on Open<\/strong> to close the dialog box!
    \n 
    \n
    \"Figure<\/a>
    Figure 1: The OpenMap GIS application window<\/figcaption><\/figure><\/li>\n
  5. You also need to copy the map files. The most common format is .shp<\/code> (ESRI Shape). Create a new folder hierarchy resources\/map<\/code> by selecting the Files<\/em> window in NetBeans, right-clicking on OpenMap1<\/code> project and selecting New \u2192 Folder<\/strong> from the popup menu. Enter the name resources <\/code>and click on OK<\/strong>. Right-click on the resources <\/code>folder and repeat the procedure to create the map folder inside it. Copy share\/data\/shape<\/code> folder from your OpenMap<\/em> installation to the map<\/code> folder<\/li>\n
  6. Create a new JFrame <\/code>form by right-clicking on the openmap <\/code>package and selecting New \u2192 JFrame Form<\/strong> from the popup menu. Give it a name, e.g. MapFrame<\/strong> and click on Finish<\/strong>.
    \n 
    \n
    \"A<\/a>
    A Basic OpenMap Swing application<\/figcaption><\/figure><\/li>\n
  7. Click on Source<\/strong> button to see the generated code (see Listing 1).<\/li>\n
  8. Add the line super(\"Simple Map\"); <\/code> in the constructor to set the window title.<\/li>\n
  9. The constructor initialises the JFrame<\/code>. Nothing is added to it so far. Since it is a GUI application, it needs to run in the EDT thread, and this is what NetBeans has written in the main()<\/code> method for us.<\/li>\n
  10. Click back on Design<\/strong> button to see the empty form.<\/li>\n<\/ol>\n

    We can add OpenMap<\/em> JavaBeans to the Palette. To do that:<\/p>\n

      \n
    1. Right-click on the palette and select Palette Manager<\/strong>.<\/li>\n
    2. Click on New Category<\/strong> and enter OpenMap <\/em>as the category name. Click Click on Add from JAR <\/strong>button, navigate to the openmap.jar<\/code>,<\/strong> select the Show All JavaBeans<\/strong> radio button and select all available components. Click Next.<\/strong><\/li>\n
    3. Select the OpenMap<\/em> palette category and click on Finish<\/strong>. A new palette category has been added to the Palette.
      \n 
      \n
      \"3:<\/a>
      3: Create a new Java application<\/figcaption><\/figure><\/li>\n<\/ol>\n

      Add the map<\/h3>\n
        \n
      1. Locate the MapBean <\/code>and drag it to the MapFrame<\/code>.<\/li>\n
      2. In the Navigator<\/em> window of NetBeans, right-click mapBean1<\/code>, select Change Variable Name<\/strong> and set it to mapBean<\/code>.<\/li>\n
      3. In the Navigator<\/em> window, right-click on JFrame <\/code>and change its layout to BorderLayout<\/code><\/li>\n
      4. The resulting code is shown in Listing 2.
        \n 
        \n
        \"FFigure<\/a>
        FFigure 4: Provide a Project name and location<\/figcaption><\/figure><\/li>\n<\/ol>\n

         
        \n

        \"Figure<\/a>
        Figure 5: Add openmap.jar to your Libraries folder<\/figcaption><\/figure><\/p>\n

        The com.bbn.openmap.MapBean <\/code>component is the main map window component in the OpenMap<\/em> toolkit. The MapBean <\/code>derives from the java.awt.Container<\/code> class. Because it is a Swing component, it can be added to a Java window hierarchy like any other user interface component.<\/p>\n

        To create the map in the MapBean<\/code>, Layers (com.bbn.openmap.Layer)<\/code> are added to the MapBean<\/code>. Layers derive from java.awt.Component<\/code> and they are the only components that can be added to a MapBean. Because Layers <\/code>are Components <\/code>contained within a MapBean <\/code>container, the rendering of Layers <\/code>onto the map is controlled by the Java component rendering mechanism. This mechanism controls how layered components are painted on top of each other. To make sure that each component gets painted into the window in the proper order, the Component <\/code>class includes a method that allows it to tell the rendering mechanism that it would like to be painted. This feature allows Layers <\/code>to work independently from each other, and lets the MapBean <\/code>avoid knowing what is happening on the Layers.<\/p>\n

        Listing 1: Basic Swing application<\/strong><\/em><\/p>\n

        public class MapFrame extends javax.swing.JFrame {\r\n\r\n   \/** Creates new form MapFrame *\/\r\n   public MapFrame() {\r\n      super(\"Simple Map\");\r\n      initComponents();\r\n   }\r\n\r\n  @SuppressWarnings(\"unchecked\")\r\n   \/\/ <editor-fold defaultstate=\"collapsed\" desc=\"Generated Code\">                          \r\n   private void initComponents() {\r\n     \/\/ Content suppressed\r\n   }  \r\n\r\n   \/**\r\n    * @param args the command line arguments\r\n    *\/\r\n   public static void main(String args[]) {\r\n      \r\n      \/* Create and display the form *\/\r\n      java.awt.EventQueue.invokeLater(new Runnable() {\r\n         @Override\r\n         public void run() {\r\n            new MapFrame().setVisible(true);\r\n         }\r\n      });\r\n   }\r\n}\r\n<\/pre>\n
        Listing 2: Add a MapBean<\/strong><\/em>
         
        <\/div> <\/div><\/p>\n
          @SuppressWarnings(\"unchecked\")\r\n   \/\/ <editor-fold defaultstate=\"collapsed\" desc=\"Generated Code\">                          \r\n   private void initComponents() {\r\n     mapBean = new com.bbn.openmap.MapBean();\r\n setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);\r\n      getContentPane().add(mapBean, java.awt.BorderLayout.CENTER);\r\n\r\n      pack();\r\n   }  \r\n<\/pre>\n
        Listing 3: Add a ShapeLayer to the MapBean<\/strong><\/em><\/p>\n
        \/**\r\n  * Create a ShapeLayer to show world political boundaries. Set the properties of the layer. This assumes that\r\n  * the datafiles {@code dcwpo-browse.shp} and {@code dcwpo-browse.ssx} are in a path specified in the CLASSPATH variable.\r\n  * These files are distributed with OpenMap and reside in the toplevel \"share\" subdirectory.\r\n  *\/\r\nprivate void initMap() {\r\n      Properties shapeLayerProps = new Properties();\r\n      shapeLayerProps.put(\"prettyName\", \"Political Solid\");\r\n      shapeLayerProps.put(\"lineColor\", \"000000\");\r\n      shapeLayerProps.put(\"fillColor\", \"BDDE83\");\r\n      shapeLayerProps.put(\"shapeFile\", \"resources\/map\/shape\/dcwpo-browse.shp\");\r\n      shapeLayerProps.put(\"spatialIndex\", \"resources\/map\/shape\/dcwpo-browse.ssx\");\r\n\r\n      ShapeLayer shapeLayer = new ShapeLayer();\r\n      shapeLayer.setProperties(shapeLayerProps);\r\n\r\n      \/\/ Add the political layer to the map\r\n      mapBean.add(shapeLayer);\r\n}\r\n\r\n<\/pre>\n
        Layers in an OpenMap application can use data from many sources:<\/p>\n