OpenJUMP

Notes on TaskFrames

The Sunburned Surveyor — Thu, 03 Jul 2008 00:02:17 Z

I’m creating this wiki page as a place holder for some notes on TaskFrame objects. A TaskFrame is a JInternalFrame that is used to display the LayerNamePanel and LayerViewPanel to the user within the WorkbenchFrame.

For the time being this page just has some notes on the methods used to add and close TaskFrames. I hope to add more material as I become more familiar with the TaskFrame class and how it interacts with the rest of the OpenJUMP Core.

The Sunburned Surveyor

WorkbenchFrame.closeTaskFrame

Private method warns the user if there are layers with the task that have unmodified features. It also asks the user if they want to close other JInternalFrames that are open in the Workbench AND associated with the TaskFrame that is being closed. Calls the confirmClose methods defined in the WorkbenchFrame class. I think this method is currently the place where the closing of a task frame begins. (This is probably the method that is called when the user clicks on the close button of a TaskFrame. Should it be called by the TaskFrame class by triggering a callto the InternalFrameAdapter class associated with each TaskFrame?)

WorkbenchFrame.addInternalFrame

public method that allows a JInternalFrame to be added to the WorkbenchFrame. If the JInternalFrame being added is a LayerManagerProxy, as a TaskFrame is, then the WorkbenchFrame.setClosingBehavior method is called.

Workbench.addTaskFrame(Task argTask)

Uses a TaskFrameFactory to create a TaskFrame if a TaskFrameFactory exists. If a TaskFrameFactory does not exist, one of the TaskFrame constructors is called directly. The WorkBenchFrame.addTaskFrame(TaskFrame argTaskFrame) method is called.

Workbench.addTaskFrame(TaskFrame argFrame)

Calls the add internalFrame method.

Workbench.setClosingBehavior(LayerManagerProxy argProxy)

Adds an InternalFrameCloseHandler to the TaskFrame being added to the WorkbenchFrame. This is an internal class. The internal class is an InternalFrameAdapter that simply calls the InternalFrameCloseHandler.close method. The InternalFrameCloseHandler class whose clsoe method is called by the InternalFrameAdapter is whatever InternalFrameCloseHandler is set with the workbenchFrame.setInternalFrameCloseHandler method.

Proposed Changes For Customizable TaskFrames

When questioning the purpose of the TaskFrame.setTask method I disovered that Paul Austin had enabled a system to allow for customized extensions of the TaskFrame class. Paul did this in an effort to test the InfoNode docking framework in OpenJUMP.

I am proposing some changes to the system that Paul implemented. It will eliminate the use of the setTask method, which I think could produce some bugs, and will allow TaskFrame extensions to be added via a plug-in.

Here is how it would work.

The Workbench.addTask method will be modified to accept a String identifying the TaskFrame type in addition to the Task beind displayed in the TaskFrame.

The Workbench.addTask method will create a TaskFrameFactory (a new class that extends org.openjump.swing.ComponentFactory) and will use it to create the type of TaskFrame identified by the String argument passed to the addTask method. It obtains the new TaskFrame by using the TaskFrameFactory.createComponent method.

The TaskFrameFactory method obtains a list of TaskFrame extensions from the Registry. It then loads the appropriate class based on the String argument passed to the addTask method and creates and instance from it. This is returned and added to the WorkbenchFrame.

A programmer can add support for a custom task by creating a plug-in that adds the TaskFrame extension class name to the Registry during initialization. This will make it available to the TaskFrameFactory.

All custom TaskFrame’s will need to extend the TaskFrame class and implement the constructor that accepts a Task and a WorkbenchContext as its only arguments.

I am close to having this system implemented, and I will begin testing it soon.

Documentation

The Sunburned Surveyor — Tue, 01 Jul 2008 20:06:19 Z

This page gives access to documentation for users and developers (scroll down).

A – Documentation for users

On-Line

OpenJUMP 1.2F New User Guide (ongoing documentation) – English
OpenJUMP 1.2F List of Functions – English
OpenJUMP 1.0.1 Basics Tutorial by Uwe Dalluege – German

Download (PDF)

OpenJUMP 1.2F Tutorial by Uwe Dalluege (in German!)

OpenJUMP 1.0.1 Basics Tutorial by Uwe Dalluege:
- English Beta (still german images inside)
- German Version
- French Version
- german sample data
- Uwe has also written a german PostGIS Tutorial

Original VIVID Solutions JUMP User Guide
- English
- Spanish

JUMP 1.1 / OpenJUMP Tutorials in other languages:
- Portuguese User Guide by Flavia Coelho Couto João Batista Brito and Ezequias Rodrigues da Rocha
- Presentation, by Ezequias R. da Rocha
- Italian User Guide by Diego Magni
- User Guide for Field Work GIS Station powered by OpenJUMP in Japanese by Yuji Murayama, Hisaji Ono
- OpenJump Workshop for Foss4G 2006” by Erwan Brocher – OpenJUMP Sigle (here you can find other documentations of the same author in French)

Other original JUMP documentation (a wee bit old)

B – Documentation for developers

Jump Developers Guide
Devel FAQ
Basics
Making Your Own Plugins
Tips and Tricks around the Java Topology Suite
Notes On OpenJUMP's Rendering System
Notes on TaskFrames
Adding support for new data formats:
- How to write a new driver (Spring 2007)
- HOWTO Create an Open Wizard (Since OpenJUMP Version 1.2)
- Some additional notes on adding support for a new file format: File DataSource Notes
- Working with GML

C – Projects where OpenJUMP can give its contribution

OSGeo Cartographic Library

GIS Terminology

HomePage

sstein — Mon, 30 Jun 2008 22:21:17 Z

OpenJUMP – The free, Java based and open source Geographic Information System for the World.

WIKI CONTENT

What is OpenJUMP? and OpenJUMPs Family
Screenshots
Download a stable version (win32 installer or platform independent)
Download nightly snapshot (for JRE 1.5 – list of changes)
Installation Instructions
Documentation (please contribute!)
Plugins and Installing PlugIns
FAQ
Reporting problems and asking questions on OpenJUMP Installation, on OpenJUMP Functions or PlugIns
User Mailing List (our beloved users – a friendly bunch)
Testimonials, Research-Papers and User World-Map
Future Developments of OpenJUMP and Contributors
Contact
Professional Support and Job Board

NEWS

[30th June 2008] Team member of the Month: This month we like to acknowledge Paul Austin’s work on OpenJUMP. Paul has his own comapny and contributed for instance the new Load Dataset/File framework and the file drag & drop function. We thank You!

[15th June 2008] Larry Becker Added “Get buffer distance from attribute” option to Buffer Tool on OpenJUMP nightly snapshot.

[20th May 2008] Andreas Schmidt improved capability of OpenJUMP nightly snapshot to import/export SLD. OpenJUMP can export (and import) layer styles to other GIS softwares (uDig, Kosmo,..) and to WMS

[3rd Feb 2008] OpenJUMP user list moved from jump-users@jump-project.org to openjump-users@googlegroups.com. Users can subscribe here:
http://groups.google.com/group/openjump-users

[13th Jul 2007] New help documentation: OpenJUMP List of Functions

[24th Apr 2007] we just discovered the project Jump4Schools – unfortunately the webpage is in german, but the person may also speak English if you have questions. ...and of course; we wish good luck with the project!

Developer Section

Project Administration Section

We are looking for volunteers

We need You as developer helping to improve OpenJUMP
We need You to help in webpage support and writing and updating user manuals.

If you are interested subscribe to JPP-Devel email list first and post to that list.

Related Sites and Blogs

http://jump-project.org/ – Website for the original version of JUMP GIS
http://www.vividsolutions.com/jump/ – Vivid Solutions, the company that created the original version of JUMP
http://sourceforge.net/projects/jump-pilot – Sourceforge website for infos about OpenJUMP development (bugs, feature requests and team)
http://jump-pilot.sourceforge.net/ – website of the Jump Pilot Project
http://www.projet-sigle.org/ – OpenJUMP in French
http://geo.michaelm.free.fr/ – Another site with OpenJUMP resources in french
deeJUMP – Version with better support for OGC standards (and projection support); for download also here
SkyJUMP by Larry and Bob has some other nice features, focusing on CAD like editing ;)
Kosmo Corporate Open GIS Platform (Spanish)
What is GIS? – GIS Basics by the OpenContent GITTA e-learning project
BTW: Our lovely icons are from: http://www.famfamfam.com/ ..thank you James :-)

OpenJump on OSX

Index

Peppe — Sat, 28 Jun 2008 09:41:28 Z

back to Documentation page

NEW USER GUIDE

Getting Started

Working with Projects

Working with Vector files

Working With Features

Working with Raster files

Working with WMS/WFS? °

Working with Databases? °

Working with Projections

Analysis Tools? °

Printing °

Appendix

GIS Terminology

FAQ

Bibliography

° Pages that need to be write or to be detail

This New Help wiki page provides an ongoing documentation of OpenJUMP Nightly Build.
A complete description of all functionalities and tools is on OpenJUMP List of Functions wiki page

Giuseppe Aruta

back to Documentation page

Point Symbology

Peppe — Sat, 28 Jun 2008 09:38:50 Z

AnonymousCoward

sstein — Thu, 26 Jun 2008 07:37:47 Z

DINMO

sstein — Thu, 26 Jun 2008 07:37:22 Z

JTin Google Summer of Code 2008

Peppe — Sun, 22 Jun 2008 14:33:07 Z

I created this page on the wiki for discussion of the JTin library. This will be a low-level library that allows for the creation and manipulation of TINs. This may be something that we can work on with GeoTools/UDig. In this scenario OpenJUMP and UDig would create their own plug-ins to access the low-level JTin library.

Before serious work begins on the library I think we should make some decisions on the following items:

How is TIN defined, and how will we represent it in memory? (Note: We aren’t talking about the display of a TIN, but rather the model from which a display or view of the TIN might be created.)
What data input formats will we support? Will we wrap access to these formats in a common interface?
What data output formats will we support?
How will we integrate TIN support into OpenJUMP?
How will we display TINs? Do we want this display to be in the normal Layer View of OpenJUMP? Will this be a 2D display? Will it be a 3D display? Can we support 3D display of a TIN in a separate component to avoid tweaking the existing 2D rendering code?

I will add my comments below. Other interested programmers can add their content also. Then we can make a decision on the best way to proceed.

TIN Definition
The Sunburned Surveyor: From a land surveying perspective a TIN is defined by three (3) components.

The first component is a collection of points representing the samples of the surface being modeled by the TIN. Each sample site has a horizontal position and a measure of the value being modeled with the surface. (This could be the ground elevation surface or the surface of something completely different, like population)

The second component is a line, either 2D or 3D, that represents the boundaries of the surface being modeled. There must be at least one exterior boundary and there may be one or more interior boundaries. (An interior boundary might be used to exclude a building envelope from an elevation TIN.)

The third component is a set of 3D lines that represent the breaklines of the TIN. TIN lines, or the edges of the triangular faces in the TIN, are not allowed to cross breaklines. Breaklines are a critical component of accurate TIN definition and creation.

I believe that our library should incorporate creation of TINs using all three (3) components, not just the first component, as is typically done in GIS.

Christopher DeMars: Do we need to include support for both hard and soft breaklines (hard breaklines indicating a change in height along the line like in a road grade)?

The Sunburned Surveyor: I’m not really sure what a “soft” breakline would be. What I am talking about would be a hard breakline. It is basically a set of connected TIN lines that can’t be crossed by other TIN lines. You would typically create these breaklines along topographic features like ridge tops or valleys.

TIN Representation
The Sunburned Surveyor: I believe that our TIN representation should be made as simple as possible. In my perspective this simplest representation is a set of TIN faces. Each TIN face is defined by three (3) three-dimensional points. I believe we can represent each TIN face by using a JTS Polygon whose nodes have a valid elevation value. Other alternatives are representing each face by a set of raw coordinate values, perhaps as JTS Coordinate objects, or by a set of three (3) LineStrings, with one LineString used to represent each edge of the face. Paul Austin mentioned that representing a face with raw coordinates might be the most efficient method. Whatever method is finally selected, it I think it would be practical to provide methods that allow access to either a JTS Polygon, JTS Point, or JTS LineString representation of the face.

Perhaps the best way to approach this is by encapsulating the common behavior of a TIN face in an interface, and then allowing multiple implementations of this interface using one of the JTS Geometries.

Paul Austin: Each face is a Triangle which could be modelled as a Triangle object with 3 coordinates. This would be a very efficient data structure and the Triangle object can have methods to return properties of the Triangle such as the circumcentre. There can be methods on the Tin to wrap this Triangle as a Polygon for use in renderring. See CoordinateSequence as the interface that would allow this wrapping.

Christopher DeMars: Most of the following commentary was inspired by this paper: http://www.cs.unc.edu/%7Eisenburg/papers/ilss-scdt-06.pdf

The paper mentions that another fundamental value to be stored in a TIN for each triangle facet is three links to adjacent facets.

Other aspects that could/should be associated with each TIN face might be precomputed normals and water flow data (like WaterBug, determine where water flowing in the uphill edges exits).

Another big question that needs to be answered is shall we stick with JTS and use a 2.5D model or go full 3D (2.5D surfaces can be projected onto the xy plane without having overlap)? The advantages of 2.5D is that the algorithms are out there and it would mesh well with OpenJUMP. The disadvantage is that we couldn’t model such things as cave structures or mines and the TIN library couldn’t be used for non-GIS 3D applications like medical imaging. The biggest downside to going full 3D is that Delaunay triangulation of 3D surfaces is an open research topic with regards to creating a decently fast implementation. As of this moment, my thoughts are that we should stick with 2.5D, but try to craft the interface such that full 3D code could be plugged in at some future time.

The Sunburned Surveyor: I agree with Paul. Each TIN face could be stored as three Coordinates. We could then provide methods that return things like a 2D Polygon representation of the triangle, the slope, the aspect, or the normal as suggested by Chris.

However, I don’t think we should store topology data in the object representing the actual TIN face. I think this should be stored in a separate data structure or data structures.

Chris wrote: “The disadvantage is that we couldn’t model such things as cave structures or mines and the TIN library couldn’t be used for non-GIS 3D applications like medical imaging.”

I didn’t even think about that Chris. Those are interesting applications of a TIN library.

Chris wrote: “The biggest downside to going full 3D is that Delaunay triangulation of 3D surfaces is an open research topic with regards to creating a decently fast implementation. As of this moment, my thoughts are that we should stick with 2.5D, but try to craft the interface such that full 3D code could be plugged in at some future time.”

Excellent points. I agree with your suggestion. Let’s go with 2.5D know, but design the library so that we can plug-in true 3D functionality in the future.

TIN Input Formats
Christopher DeMars: At the very least, we should import DEMs and CSV points are converted into a TIN.

The Sunburned Surveyor: O.K. – Let’s support DEM and CSV in our “alpha” release of the library. Still, we should design an interface that allows access to the three (3) main elements above. That would be (1) 3D points defining the surface, (2) 3D points defining breaklines, and (3) 3d points that define interior and exterior boundaries. We would only require access to a set of 3D points defining the surface. The breaklines and boundaries would be supplemental information that could be using to construct the TIN if available, but which would not be required.

If we take this route I can work on a format for define TINs based on a simple text format. I’d prefer something in YAML, but woudln’t be against using XML if there was a lot of support for that.

TIN Output Formats
Christopher DeMars: I see two possibilities. The preferred option IMHO would be to have a streaming architecture where the last stage in the pipeline wrote out the data (triangles, breaklines, borders, waterflow etc) to a PostGIS database. Then the TIN class (or TINDB class) could have a method that returns a subset of the TIN as a new TIN. The new TIN could either be DB backed, or reside only in memory. This would allow us to process, store, and use TINs that are larger than main memory.

Another possible output format would be a raw list of points segregated into a breakline section, border section, and triangle section. This could be either in WKT, WKB, or our own format. In order to save space, markup languages should be avoided. The downside to this is it would be much harder to deal with data sets that dwarf main memory.

The Sunburned Surveyor: I agree with Chris on some of the main “outputs” our TIN library should support. I think that these should be a representation of the constructed TIN, including TIN faces, breaklines and boundaries. At some point in the future I would hope to see support for contours (as JTS LineStrings so they could be displayed in OpenJUMP) hillshades, and water flow analysis.

Chris mentioned a “streaming” API that allows access to a TIN in a manner that is independent of memory. I believe this is very important. However, I do not believe we should tie the API to any relational database, at least not directly. We should present a streaming API and then allow individual programmers the liberty to choose their implementation. For example, I would personally avoid a relational database and would focus on streaming access to a TIN based on a binary file or series of text files.

GeoTools/OpenJUMP Collaboration

TIN Display Options

I don’t think, at least initially, that we should be concerned with making major modifications to OpenJUMP so that TIN’s can be displayed. I think the more simple, and easily obtained solution, would be to focus on exporting data products from a TIN that could be displayed in OpenJUMP. This could be TIN faces represented as JTS Polygons, countour lines represented as JTS LineStrings, and Hillshades represented as JTS Polygons or raster images.

I believe 3D display of TIN files should take place in either [1] a stand alone tool, or [2] in a plug-in specifically designed for display of 3D data. The second option would allow us to write 3D display code that could be used for future extensions in OpenJUMP’s functionality. However, I do not think it would be wise to attempt a mash-up of OpenJUMP’s current 2D dispaly and a new 3D display. OpenJUMP’s current 2D rendering system is quick and capable of producing high-quality map images. Let’s not mess with that. Separating display of 3D data into another component will allow us to experiment with and use tools specifically build for 3D data, liek Java OpenGL bindings, without polluting the current (and effective) 2D rendering system.

Integration of TIN Support In OpenJUMP

I don’t think, at least initially, that we should worry about integrating TINs into OpenJUMP as a special type of feature. Let’s concentrate on building TINs and on creating simple output from TINs in the formats OpenJUMP already permits. When we are successful with this goal we can consider adding more built in support for TIN manipulation directly into OpenJUMP via plug-ins.

Integration of TIN Support In UDig

Reference

2008 Google Summerof Code http://code.google.com/soc/2008/

TIN (Triangulated irregular network) http://en.wikipedia.org/wiki/Triangulated_irregular_network

Delaunay triangulation http://en.wikipedia.org/wiki/Delaunay_triangulation

Edit

Peppe — Fri, 20 Jun 2008 15:06:42 Z

Back to OpenJUMP List of Functions

EDIT

Undo/Redo
These functions undo or redo actions performed by users in OpenJUMP. (Note: Not all user actions will support undo/redo.)

Add new features…
This function opens a dialog where the user add new features to current layer in WKT format.
(See the “Workbench User’s Guide” by Vivid Solutions for more information: http://www.vividsolutions.com/jump/bin/JUMP%20User%20Guide.pdf, Well-Known Text Syntax – Page 49).
- Note 1: The current layer must be editable to add new features.
- Note 2: This function only allows you to create the feature geomtry, it does not allow you to create the feature attributes as well. You will need to do this with other functions in OpenJUMP.

View / Edit selected feature
This function opens a dialog where the user can view and/or edit the geometry of the selected feature. This feature geometry is presented to the user in WKT format.
(See the “Workbench User’s Guide” by Vivid Solutions for more information: http://www.vividsolutions.com/jump/bin/JUMP%20User%20Guide.pdf, Well-Known Text Syntax – Page 49)
- Note 1: The user can only edit the WKT of the Feature Geometry if the layer is editable. If the layer is not edtiable the user can only view the WKT of the Feature Geometry. (See Toolbar Function>Edit)

Select Features In Fence
This function allows the user to select the features touched or contained by a fence that has already been drawn by the user. (To learn more about drawing a fence in OpenJUMP, see description of the “Fence” function on Toolbar functions page.)

Select Items by Fence from Selected Layers
This function allows the user to select the features in the selected layer or layers that are touched or contained by a fence that has already been drawn by the user. (To learn more about drawing a fence in OpenJUMP, see description of the “Fence” function on the page that describes Toolbar functions.)

Select Items by Circle from Selected Layers
This function allows the user to select features that touch or fall within a circle. The diameter and center of circle used to make the selection are specified by the user. The selection is made from the layer or layers that are currently selected.

Select by Geometry Type
This function opens a new dialog box that allows the user to select all features represented by a specified type of geometry. (For example: Select all features that are represented by a Polygon.) The dialog box includes an option that allows the user to constrain the selection to currently selected layers or the currently selected layer. (This option is checked by default when the dialog opens.)

Select Layer Items
This function selects all items on the currently selected layer. (The items on all selected layers will be selected if more than one layer is selected.)

Cut Selected Items
This function “cuts” and places on the clipboard all the of the currently selected items. (In most cases an item is a feature, although it can be “part” of a feature. [For example: inner ring of a polygon.])
Warning 1: Items “cut” using this function will be deleted from their source layer when “pasted” onto another layer. If you want to copy the currently selected items, but do not want to remove them from the source layers, use the Copy Selected Items command instead.

Copy Selected Items
This function copies the items currently selected to the clipboard. (In most cases an item is a feature, although it can be “part” of a feature. [For example: inner ring of a polygon.])

Paste Items
This function allows the user to paste items on the clipboard to the currently selected layer. (In most cases an item is a feature, although it can be “part” of a feature. [For example: inner ring of a polygon.]) You can use this function to copy items in one layer to another layer or to duplicate items in the same layer. (To duplicate items in the same layer, select the same layer you are copying items from when you get ready to paste.)
- Note 1: This function will not work if more that one layer is selected. You can only paste items to a single layer.
- Note 2: To duplicate items in the same layer, users can copy selected items, then move them to another position using the “Move Selected Items Tools” on the Editing Tool (see Tool Function>Editing Tool), then paste new items to the original position.
- Note 3: Attributes of selected features from source layer are copied only if they have corresponding attributes with the same name and data type in the destination layer. This can be set up by editing the schema of the destination layer. Only the geometries of selected items are copied if none of the attributes of the source and destination layer match.
- Note 4: Also see the Replicate (Duplicate) selected items command.

Delete Selected Items
This function allows the user to delete the currently selected items. In most cases an item is a feature, although it can be “part” of a feature. [For example: inner ring of a polygon.])
- Note 1: OpenJUMP will delete the selected items without warning when this function is used. (In most cases this action can be undone using the undo function.)

Replicate selected items
Duplicate the selected items from the current layer to a destination layer. In this action the attribute values of features stored in the layer are copied as well.

Extract Layers by geometry type
This functions allows to extract from a multy geometry layer (eg. In GML, DXF or WNT file format) all geometries and to separate in different layers according to the geopetry types (point, line, polygon)

Extract Layers in Fence
This function allows to extract geometries, on a n editable layer selected on layer list, which are inside or touched by a Fence

<—- back to OpenJUMP List of Functions

OSX

Anonymous Coward — Fri, 20 Jun 2008 14:17:50 Z

Introduction

Peppe — Fri, 20 Jun 2008 12:54:23 Z

back to Index page

OpenJUMP is a GIS (Geographic Information System) deriving from JUMP Workbench developed by Vivid Solution and Refraction Research, Inc., BC, Canada.
The name “JUMP” is the abbreviation of Unified Mapping Platform, while J points out the “Java” programming language on which OpenJUMP is based.
“Open” is for Open Source. OpenJUMP is distribuited under GNU General Public Licence and it is developed and mantained by a community of programmers and users around the World.

OpenJUMP has an impressive editing and drawing capability: features can be scaled, moved, duplicated.
The Tools section provides a flexible and complete list of querry and editing tools.
OpenJUMp can load vector, raster and database files thanks to a complete set of plugins, constantly upgrade by developers

Beanshell:Fill in a JUMP column

sstein — Thu, 19 Jun 2008 03:27:02 Z

import com.vividsolutions.jump.util.*;

map = CollectionUtil.createMap(new String[]{"DA24900010", "Road", "DA24900020", "Road", "DE22800000", "Rail Line", "FA02650000", "Boundary", "FA02700000", "Boundary", "GA24850000", "River/Stream", "GB15300000", "Lake", "GE14850000", "Island", "GG05800000", "Coastline"});

for (feature : layer.featureCollectionWrapper.features) {
feature.setAttribute("FCODE2", map{feature.getAttribute("FCODE")});
}

Beanshell:Get the WMS URL that JUMP is using

sstein — Thu, 19 Jun 2008 03:25:09 Z

print(wc.getLayerManager().getLayerables( com.vividsolutions.jump.workbench.model.WMSLayer.class).iterator().next().createRequest(wc.getLayerViewPanel()).getURL());

Beanshell:Find features with repeated points

sstein — Thu, 19 Jun 2008 03:24:00 Z

import com.vividsolutions.jump.feature.*;

repeatedPoints(geometry) {
geometry .coordinates .length - new HashSet(Arrays .asList(geometry .coordinates)) .size();
}

debugFC = wc .layerManager .getLayer("debug") .featureCollectionWrapper .ultimateWrappee;

for (feature : wc .layerManager .getLayer("navtech roads") .featureCollectionWrapper .features) {
BasicFeature debugFeature = new BasicFeature(debugFC.featureSchema);
debugFeature.setAttribute("GEOMETRY", feature.geometry);
debugFeature.setAttribute("REPEATEDPTS", repeatedPoints(feature.geometry));
debugFC.add(debugFeature);
}

Beanshell:Create an image layer from a file or URL

sstein — Thu, 19 Jun 2008 03:23:12 Z

This awesome idea was requested by Andrew Collins and took me two hours to write. It’s a BeanShell script to create an image layer from a GIF, JPEG, or PNG file or URL !!!

1. Click View > BeanShell.
2. Copy the code below into the clipboard.
3. Paste the code into the BeanShell window with Ctrl+V. JUMP will
create the image layer!

{
minx = 100; maxx = 952; miny = 100; maxy = 489; //Image coordinates
filenameOrURL = new
URL("http://www.apsu.edu/field_biology/center/sym2001/fig1p66.jpg");
//filenameOrURL = "c:/junk/Arrow.jpg";
layerName = "Image";
image = Toolkit.getDefaultToolkit().getImage(filenameOrURL);
import com.vividsolutions.jts.geom.*;
import com.vividsolutions.jump.feature.*;
import com.vividsolutions.jump.geom.EnvelopeUtil;
import com.vividsolutions.jump.workbench.model.*;
import com.vividsolutions.jump.workbench.ui.renderer.style.Style;
import com.vividsolutions.jump.workbench.ui.Viewport;
mediaTracker = new MediaTracker(wc.layerViewPanel);
mediaTracker.addImage(image, 0);
mediaTracker.waitForID(0);
envelope = new Envelope(minx, maxx, miny, maxy);
wc.layerManager.addLayer(StandardCategoryNames.WORKING, layerName,
FeatureDatasetFactory.createFromGeometry(
Collections.singleton(EnvelopeUtil.toGeometry(envelope))))
.addStyle(new Style() {
public void paint(Feature f, Graphics2D g, Viewport viewport) {
originalTransform = g.getTransform();
try {
xScale = viewport.scale*envelope.width/image.getWidth(null);
yScale = viewport.scale*envelope.height/image.getHeight(null);
g.scale(xScale, yScale);
upperLeftCorner = viewport.toViewPoint(new Coordinate(minx, maxy));
g.translate(upperLeftCorner.x/xScale, upperLeftCorner.y/yScale);
g.drawImage(image, 0, 0, null);
}
finally {
g.setTransform(originalTransform);
}
}
public void initialize(Layer layer) {}
public Object clone() { throw new UnsupportedOperationException(); }
public void setEnabled(boolean enabled) {}
public boolean isEnabled() { return true; }
});
wc.layerManager.getLayer(layerName).getBasicStyle().renderingFill = false;